# InterpolatePy
[](https://pepy.tech/projects/interpolatepy)
[](https://github.com/GiorgioMedico/InterpolatePy/actions/workflows/pre-commit.yml)
[](https://github.com/GiorgioMedico/InterpolatePy/actions/workflows/test.yml)
[](https://opensource.org/licenses/MIT)
**Production-ready trajectory planning and interpolation for robotics, animation, and scientific computing.**
InterpolatePy provides 20+ algorithms for smooth trajectory generation with precise control over position, velocity, acceleration, and jerk. From cubic splines and B-curves to quaternion interpolation and S-curve motion profiles ā everything you need for professional motion control.
**ā” Fast:** Vectorized NumPy operations, ~1ms for 1000-point cubic splines
**šÆ Precise:** Research-grade algorithms with CĀ² continuity and bounded derivatives
**š Visual:** Built-in plotting for every algorithm
**š§ Complete:** Splines, motion profiles, quaternions, and path planning in one library
---
## Installation
```bash
pip install InterpolatePy
```
**Requirements:** Python ā„3.10, NumPy ā„2.0, SciPy ā„1.15, Matplotlib ā„3.10
<details>
<summary><strong>Development Installation</strong></summary>
```bash
git clone https://github.com/GiorgioMedico/InterpolatePy.git
cd InterpolatePy
pip install -e '.[all]' # Includes testing and development tools
```
</details>
## Quick Start
```python
import numpy as np
import matplotlib.pyplot as plt
from interpolatepy import CubicSpline, DoubleSTrajectory, StateParams, TrajectoryBounds
# Smooth spline through waypoints
t_points = [0.0, 5.0, 10.0, 15.0]
q_points = [0.0, 2.0, -1.0, 3.0]
spline = CubicSpline(t_points, q_points, v0=0.0, vn=0.0)
# Evaluate at any time
position = spline.evaluate(7.5)
velocity = spline.evaluate_velocity(7.5)
acceleration = spline.evaluate_acceleration(7.5)
# Built-in visualization
spline.plot()
# S-curve motion profile (jerk-limited)
state = StateParams(q_0=0.0, q_1=10.0, v_0=0.0, v_1=0.0)
bounds = TrajectoryBounds(v_bound=5.0, a_bound=10.0, j_bound=30.0)
trajectory = DoubleSTrajectory(state, bounds)
print(f"Duration: {trajectory.get_duration():.2f}s")
# Manual plotting (DoubleSTrajectory doesn't have built-in plot method)
t_eval = np.linspace(0, trajectory.get_duration(), 100)
results = [trajectory.evaluate(t) for t in t_eval]
positions = [r[0] for r in results]
velocities = [r[1] for r in results]
plt.figure(figsize=(10, 6))
plt.subplot(2, 1, 1)
plt.plot(t_eval, positions)
plt.ylabel('Position')
plt.title('S-Curve Trajectory')
plt.subplot(2, 1, 2)
plt.plot(t_eval, velocities)
plt.ylabel('Velocity')
plt.xlabel('Time')
plt.show()
```
---
## Algorithm Overview
| Category | Algorithms | Key Features | Use Cases |
|----------|------------|--------------|-----------|
| **šµ Splines** | Cubic, B-Spline, Smoothing | CĀ² continuity, noise-robust | Waypoint interpolation, curve fitting |
| **ā” Motion Profiles** | S-curves, Trapezoidal, Polynomial | Bounded derivatives, time-optimal | Industrial automation, robotics |
| **š Quaternions** | SLERP, SQUAD, Splines | Smooth rotations, no gimbal lock | 3D orientation control, animation |
| **šÆ Path Planning** | Linear, Circular, Frenet frames | Geometric primitives, tool orientation | Path following, machining |
š **[Complete Algorithms Reference ā](ALGORITHMS.md)**
*Detailed technical documentation, mathematical foundations, and implementation details for all 22 algorithms*
<details>
<summary><strong>Complete Algorithm List</strong></summary>
### Spline Interpolation
- `CubicSpline` ā Natural cubic splines with boundary conditions
- `CubicSmoothingSpline` ā Noise-robust splines with smoothing parameter
- `CubicSplineWithAcceleration1/2` ā Bounded acceleration constraints
- `BSpline` ā General B-spline curves with configurable degree
- `ApproximationBSpline`, `CubicBSpline`, `InterpolationBSpline`, `SmoothingCubicBSpline`
### Motion Profiles
- `DoubleSTrajectory` ā S-curve profiles with bounded jerk
- `TrapezoidalTrajectory` ā Classic trapezoidal velocity profiles
- `PolynomialTrajectory` ā 3rd, 5th, 7th order polynomials
- `LinearPolyParabolicTrajectory` ā Linear segments with parabolic blends
### Quaternion Interpolation
- `Quaternion` ā Core quaternion operations with SLERP
- `QuaternionSpline` ā CĀ²-continuous rotation trajectories
- `SquadC2` ā Enhanced SQUAD with zero-clamped boundaries
- `LogQuaternion` ā Logarithmic quaternion methods
### Path Planning & Utilities
- `SimpleLinearPath`, `SimpleCircularPath` ā 3D geometric primitives
- `FrenetFrame` ā Frenet-Serret frame computation along curves
- `LinearInterpolation` ā Basic linear interpolation
- `TridiagonalInverse` ā Efficient tridiagonal system solver
</details>
## Advanced Examples
<details>
<summary><strong>Quaternion Rotation Interpolation</strong></summary>
```python
import matplotlib.pyplot as plt
from interpolatepy import QuaternionSpline, Quaternion
# Define rotation waypoints
orientations = [
Quaternion.identity(),
Quaternion.from_euler_angles(0.5, 0.3, 0.1),
Quaternion.from_euler_angles(1.0, -0.2, 0.8)
]
times = [0.0, 2.0, 5.0]
# Smooth quaternion trajectory with CĀ² continuity
quat_spline = QuaternionSpline(times, orientations, interpolation_method="squad")
# Evaluate at any time
orientation, segment = quat_spline.interpolate_at_time(3.5)
# For angular velocity, use interpolate_with_velocity
orientation_with_vel, angular_velocity, segment = quat_spline.interpolate_with_velocity(3.5)
# QuaternionSpline doesn't have built-in plotting - manual visualization needed
plt.show()
```
</details>
<details>
<summary><strong>B-Spline Curve Fitting</strong></summary>
```python
import numpy as np
import matplotlib.pyplot as plt
from interpolatepy import CubicSmoothingSpline
# Fit smooth curve to noisy data
t = np.linspace(0, 10, 50)
q = np.sin(t) + 0.1 * np.random.randn(50)
# Use CubicSmoothingSpline with correct parameter name 'mu'
spline = CubicSmoothingSpline(t, q, mu=0.01)
spline.plot()
plt.show()
```
</details>
<details>
<summary><strong>Industrial Motion Planning</strong></summary>
```python
import numpy as np
import matplotlib.pyplot as plt
from interpolatepy import DoubleSTrajectory, StateParams, TrajectoryBounds
# Jerk-limited S-curve for smooth industrial motion
state = StateParams(q_0=0.0, q_1=50.0, v_0=0.0, v_1=0.0)
bounds = TrajectoryBounds(v_bound=10.0, a_bound=5.0, j_bound=2.0)
trajectory = DoubleSTrajectory(state, bounds)
print(f"Duration: {trajectory.get_duration():.2f}s")
# Evaluate trajectory
t_eval = np.linspace(0, trajectory.get_duration(), 1000)
results = [trajectory.evaluate(t) for t in t_eval]
positions = [r[0] for r in results]
velocities = [r[1] for r in results]
# Manual plotting
plt.figure(figsize=(12, 8))
plt.subplot(2, 1, 1)
plt.plot(t_eval, positions)
plt.ylabel('Position')
plt.title('Industrial S-Curve Motion Profile')
plt.grid(True)
plt.subplot(2, 1, 2)
plt.plot(t_eval, velocities)
plt.ylabel('Velocity')
plt.xlabel('Time')
plt.grid(True)
plt.show()
```
</details>
## Who Should Use InterpolatePy?
**š¤ Robotics Engineers:** Motion planning, trajectory optimization, smooth control
**š¬ Animation Artists:** Smooth keyframe interpolation, camera paths, character motion
**š¬ Scientists:** Data smoothing, curve fitting, experimental trajectory analysis
**š Automation Engineers:** Industrial motion control, CNC machining, conveyor systems
---
## Performance & Quality
- **Fast:** Vectorized NumPy operations, optimized algorithms
- **Reliable:** 85%+ test coverage, continuous integration
- **Modern:** Python 3.10+, strict typing, dataclass-based APIs
- **Research-grade:** Peer-reviewed algorithms from robotics literature
**Typical Performance:**
- Cubic spline (1000 points): ~1ms
- B-spline evaluation (10k points): ~5ms
- S-curve trajectory planning: ~0.5ms
---
## Development
<details>
<summary><strong>Development Setup</strong></summary>
```bash
git clone https://github.com/GiorgioMedico/InterpolatePy.git
cd InterpolatePy
pip install -e '.[all]'
pre-commit install
# Run tests
python -m pytest tests/
# Run tests with coverage
python -m pytest tests/ --cov=interpolatepy --cov-report=html --cov-report=term
# Code quality
ruff format interpolatepy/
ruff check interpolatepy/
mypy interpolatepy/
```
</details>
---
## Contributing
Contributions welcome! Please:
1. Fork the repo and create a feature branch
2. Install dev dependencies: `pip install -e '.[all]'`
3. Follow existing patterns and add tests
4. Run `pre-commit run --all-files` before submitting
5. Open a pull request with clear description
For major changes, open an issue first to discuss the approach.
---
## Support the Project
ā **Star the repo** if InterpolatePy helps your work!
š **Report issues** on [GitHub Issues](https://github.com/GiorgioMedico/InterpolatePy/issues)
š¬ **Join discussions** to share your use cases and feedback
---
## License & Citation
**MIT License** ā Free for commercial and academic use. See [LICENSE](LICENSE) for details.
If you use InterpolatePy in research, please cite:
```bibtex
@misc{InterpolatePy,
author = {Giorgio Medico},
title = {InterpolatePy: Trajectory Planning and Interpolation for Python},
year = {2025},
url = {https://github.com/GiorgioMedico/InterpolatePy}
}
```
<details>
<summary><strong>Academic References</strong></summary>
This library implements algorithms from:
**Robotics & Trajectory Planning:**
- Biagiotti & Melchiorri (2008). *Trajectory Planning for Automatic Machines and Robots*
- Siciliano et al. (2010). *Robotics: Modelling, Planning and Control*
**Quaternion Interpolation:**
- Parker et al. (2023). "Logarithm-Based Methods for Interpolating Quaternion Time Series"
- Wittmann et al. (2023). "Spherical Cubic Blends: CĀ²-Continuous Quaternion Interpolation"
- Dam, E. B., Koch, M., & Lillholm, M. (1998). "Quaternions, Interpolation and Animation"
</details>
---
*Built with ā¤ļø for the robotics and scientific computing community.*
Raw data
{
"_id": null,
"home_page": null,
"name": "InterpolatePy",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.11",
"maintainer_email": "Giorgio Medico <giorgio.medico11@gmail.com>",
"keywords": "interpolation, trajectory planning, motion profiles, robotics, b-splines, cubic splines, frenet frames, path generation, motion control",
"author": null,
"author_email": "Giorgio Medico <giorgio.medico11@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/99/c6/0c76b571ec5af8e0e900bec02e6bcd33db372f4235f167a09c0694e5b62d/interpolatepy-2.0.1.tar.gz",
"platform": "unix",
"description": "# InterpolatePy\n\n\n[](https://pepy.tech/projects/interpolatepy)\n[](https://github.com/GiorgioMedico/InterpolatePy/actions/workflows/pre-commit.yml)\n[](https://github.com/GiorgioMedico/InterpolatePy/actions/workflows/test.yml)\n[](https://opensource.org/licenses/MIT)\n\n**Production-ready trajectory planning and interpolation for robotics, animation, and scientific computing.**\n\nInterpolatePy provides 20+ algorithms for smooth trajectory generation with precise control over position, velocity, acceleration, and jerk. From cubic splines and B-curves to quaternion interpolation and S-curve motion profiles \u2014 everything you need for professional motion control.\n\n**\u26a1 Fast:** Vectorized NumPy operations, ~1ms for 1000-point cubic splines \n**\ud83c\udfaf Precise:** Research-grade algorithms with C\u00b2 continuity and bounded derivatives \n**\ud83d\udcca Visual:** Built-in plotting for every algorithm \n**\ud83d\udd27 Complete:** Splines, motion profiles, quaternions, and path planning in one library\n\n---\n\n## Installation\n\n```bash\npip install InterpolatePy\n```\n\n**Requirements:** Python \u22653.10, NumPy \u22652.0, SciPy \u22651.15, Matplotlib \u22653.10\n\n<details>\n<summary><strong>Development Installation</strong></summary>\n\n```bash\ngit clone https://github.com/GiorgioMedico/InterpolatePy.git\ncd InterpolatePy\npip install -e '.[all]' # Includes testing and development tools\n```\n</details>\n\n## Quick Start\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom interpolatepy import CubicSpline, DoubleSTrajectory, StateParams, TrajectoryBounds\n\n# Smooth spline through waypoints\nt_points = [0.0, 5.0, 10.0, 15.0]\nq_points = [0.0, 2.0, -1.0, 3.0]\nspline = CubicSpline(t_points, q_points, v0=0.0, vn=0.0)\n\n# Evaluate at any time\nposition = spline.evaluate(7.5)\nvelocity = spline.evaluate_velocity(7.5)\nacceleration = spline.evaluate_acceleration(7.5)\n\n# Built-in visualization\nspline.plot()\n\n# S-curve motion profile (jerk-limited)\nstate = StateParams(q_0=0.0, q_1=10.0, v_0=0.0, v_1=0.0)\nbounds = TrajectoryBounds(v_bound=5.0, a_bound=10.0, j_bound=30.0)\ntrajectory = DoubleSTrajectory(state, bounds)\n\nprint(f\"Duration: {trajectory.get_duration():.2f}s\")\n\n# Manual plotting (DoubleSTrajectory doesn't have built-in plot method)\nt_eval = np.linspace(0, trajectory.get_duration(), 100)\nresults = [trajectory.evaluate(t) for t in t_eval]\npositions = [r[0] for r in results]\nvelocities = [r[1] for r in results]\n\nplt.figure(figsize=(10, 6))\nplt.subplot(2, 1, 1)\nplt.plot(t_eval, positions)\nplt.ylabel('Position')\nplt.title('S-Curve Trajectory')\nplt.subplot(2, 1, 2)\nplt.plot(t_eval, velocities)\nplt.ylabel('Velocity')\nplt.xlabel('Time')\n\nplt.show()\n```\n\n---\n\n## Algorithm Overview\n\n| Category | Algorithms | Key Features | Use Cases |\n|----------|------------|--------------|-----------|\n| **\ud83d\udd35 Splines** | Cubic, B-Spline, Smoothing | C\u00b2 continuity, noise-robust | Waypoint interpolation, curve fitting |\n| **\u26a1 Motion Profiles** | S-curves, Trapezoidal, Polynomial | Bounded derivatives, time-optimal | Industrial automation, robotics |\n| **\ud83d\udd04 Quaternions** | SLERP, SQUAD, Splines | Smooth rotations, no gimbal lock | 3D orientation control, animation |\n| **\ud83c\udfaf Path Planning** | Linear, Circular, Frenet frames | Geometric primitives, tool orientation | Path following, machining |\n\n\ud83d\udcda **[Complete Algorithms Reference \u2192](ALGORITHMS.md)** \n*Detailed technical documentation, mathematical foundations, and implementation details for all 22 algorithms*\n\n<details>\n<summary><strong>Complete Algorithm List</strong></summary>\n\n### Spline Interpolation\n- `CubicSpline` \u2013 Natural cubic splines with boundary conditions\n- `CubicSmoothingSpline` \u2013 Noise-robust splines with smoothing parameter \n- `CubicSplineWithAcceleration1/2` \u2013 Bounded acceleration constraints\n- `BSpline` \u2013 General B-spline curves with configurable degree\n- `ApproximationBSpline`, `CubicBSpline`, `InterpolationBSpline`, `SmoothingCubicBSpline`\n\n### Motion Profiles\n- `DoubleSTrajectory` \u2013 S-curve profiles with bounded jerk\n- `TrapezoidalTrajectory` \u2013 Classic trapezoidal velocity profiles\n- `PolynomialTrajectory` \u2013 3rd, 5th, 7th order polynomials\n- `LinearPolyParabolicTrajectory` \u2013 Linear segments with parabolic blends\n\n### Quaternion Interpolation \n- `Quaternion` \u2013 Core quaternion operations with SLERP\n- `QuaternionSpline` \u2013 C\u00b2-continuous rotation trajectories\n- `SquadC2` \u2013 Enhanced SQUAD with zero-clamped boundaries\n- `LogQuaternion` \u2013 Logarithmic quaternion methods\n\n### Path Planning & Utilities\n- `SimpleLinearPath`, `SimpleCircularPath` \u2013 3D geometric primitives\n- `FrenetFrame` \u2013 Frenet-Serret frame computation along curves\n- `LinearInterpolation` \u2013 Basic linear interpolation\n- `TridiagonalInverse` \u2013 Efficient tridiagonal system solver\n\n</details>\n\n## Advanced Examples\n\n<details>\n<summary><strong>Quaternion Rotation Interpolation</strong></summary>\n\n```python\nimport matplotlib.pyplot as plt\nfrom interpolatepy import QuaternionSpline, Quaternion\n\n# Define rotation waypoints\norientations = [\n Quaternion.identity(),\n Quaternion.from_euler_angles(0.5, 0.3, 0.1),\n Quaternion.from_euler_angles(1.0, -0.2, 0.8)\n]\ntimes = [0.0, 2.0, 5.0]\n\n# Smooth quaternion trajectory with C\u00b2 continuity\nquat_spline = QuaternionSpline(times, orientations, interpolation_method=\"squad\")\n\n# Evaluate at any time\norientation, segment = quat_spline.interpolate_at_time(3.5)\n# For angular velocity, use interpolate_with_velocity\norientation_with_vel, angular_velocity, segment = quat_spline.interpolate_with_velocity(3.5)\n\n# QuaternionSpline doesn't have built-in plotting - manual visualization needed\nplt.show()\n```\n</details>\n\n<details>\n<summary><strong>B-Spline Curve Fitting</strong></summary>\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom interpolatepy import CubicSmoothingSpline\n\n# Fit smooth curve to noisy data\nt = np.linspace(0, 10, 50)\nq = np.sin(t) + 0.1 * np.random.randn(50)\n\n# Use CubicSmoothingSpline with correct parameter name 'mu'\nspline = CubicSmoothingSpline(t, q, mu=0.01)\nspline.plot()\nplt.show()\n```\n</details>\n\n<details>\n<summary><strong>Industrial Motion Planning</strong></summary>\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom interpolatepy import DoubleSTrajectory, StateParams, TrajectoryBounds\n\n# Jerk-limited S-curve for smooth industrial motion\nstate = StateParams(q_0=0.0, q_1=50.0, v_0=0.0, v_1=0.0)\nbounds = TrajectoryBounds(v_bound=10.0, a_bound=5.0, j_bound=2.0)\n\ntrajectory = DoubleSTrajectory(state, bounds)\nprint(f\"Duration: {trajectory.get_duration():.2f}s\")\n\n# Evaluate trajectory\nt_eval = np.linspace(0, trajectory.get_duration(), 1000)\nresults = [trajectory.evaluate(t) for t in t_eval]\npositions = [r[0] for r in results]\nvelocities = [r[1] for r in results]\n\n# Manual plotting\nplt.figure(figsize=(12, 8))\nplt.subplot(2, 1, 1)\nplt.plot(t_eval, positions)\nplt.ylabel('Position')\nplt.title('Industrial S-Curve Motion Profile')\nplt.grid(True)\nplt.subplot(2, 1, 2)\nplt.plot(t_eval, velocities)\nplt.ylabel('Velocity')\nplt.xlabel('Time')\nplt.grid(True)\nplt.show()\n```\n</details>\n\n## Who Should Use InterpolatePy?\n\n**\ud83e\udd16 Robotics Engineers:** Motion planning, trajectory optimization, smooth control \n**\ud83c\udfac Animation Artists:** Smooth keyframe interpolation, camera paths, character motion \n**\ud83d\udd2c Scientists:** Data smoothing, curve fitting, experimental trajectory analysis \n**\ud83c\udfed Automation Engineers:** Industrial motion control, CNC machining, conveyor systems \n\n---\n\n## Performance & Quality\n\n- **Fast:** Vectorized NumPy operations, optimized algorithms\n- **Reliable:** 85%+ test coverage, continuous integration\n- **Modern:** Python 3.10+, strict typing, dataclass-based APIs\n- **Research-grade:** Peer-reviewed algorithms from robotics literature\n\n**Typical Performance:**\n- Cubic spline (1000 points): ~1ms\n- B-spline evaluation (10k points): ~5ms\n- S-curve trajectory planning: ~0.5ms\n\n---\n\n## Development\n\n<details>\n<summary><strong>Development Setup</strong></summary>\n\n```bash\ngit clone https://github.com/GiorgioMedico/InterpolatePy.git\ncd InterpolatePy\npip install -e '.[all]'\npre-commit install\n\n# Run tests\npython -m pytest tests/\n\n# Run tests with coverage\npython -m pytest tests/ --cov=interpolatepy --cov-report=html --cov-report=term\n\n# Code quality\nruff format interpolatepy/\nruff check interpolatepy/\nmypy interpolatepy/\n\n```\n</details>\n\n---\n\n## Contributing\n\nContributions welcome! Please:\n\n1. Fork the repo and create a feature branch\n2. Install dev dependencies: `pip install -e '.[all]'`\n3. Follow existing patterns and add tests\n4. Run `pre-commit run --all-files` before submitting\n5. Open a pull request with clear description\n\nFor major changes, open an issue first to discuss the approach.\n\n---\n\n## Support the Project\n\n\u2b50 **Star the repo** if InterpolatePy helps your work! \n\ud83d\udc1b **Report issues** on [GitHub Issues](https://github.com/GiorgioMedico/InterpolatePy/issues) \n\ud83d\udcac **Join discussions** to share your use cases and feedback \n\n---\n\n## License & Citation\n\n**MIT License** \u2013 Free for commercial and academic use. See [LICENSE](LICENSE) for details.\n\nIf you use InterpolatePy in research, please cite:\n\n```bibtex\n@misc{InterpolatePy,\n author = {Giorgio Medico},\n title = {InterpolatePy: Trajectory Planning and Interpolation for Python},\n year = {2025},\n url = {https://github.com/GiorgioMedico/InterpolatePy}\n}\n```\n\n<details>\n<summary><strong>Academic References</strong></summary>\n\nThis library implements algorithms from:\n\n**Robotics & Trajectory Planning:**\n- Biagiotti & Melchiorri (2008). *Trajectory Planning for Automatic Machines and Robots*\n- Siciliano et al. (2010). *Robotics: Modelling, Planning and Control*\n\n**Quaternion Interpolation:**\n- Parker et al. (2023). \"Logarithm-Based Methods for Interpolating Quaternion Time Series\"\n- Wittmann et al. (2023). \"Spherical Cubic Blends: C\u00b2-Continuous Quaternion Interpolation\"\n- Dam, E. B., Koch, M., & Lillholm, M. (1998). \"Quaternions, Interpolation and Animation\"\n\n</details>\n\n---\n\n*Built with \u2764\ufe0f for the robotics and scientific computing community.*\n",
"bugtrack_url": null,
"license": null,
"summary": "A comprehensive Python library for generating smooth trajectories and curves with precise control over position, velocity, acceleration, and jerk profiles",
"version": "2.0.1",
"project_urls": {
"Bug Tracker": "https://github.com/GiorgioMedico/InterpolatePy/issues",
"Homepage": "https://github.com/GiorgioMedico/InterpolatePy"
},
"split_keywords": [
"interpolation",
" trajectory planning",
" motion profiles",
" robotics",
" b-splines",
" cubic splines",
" frenet frames",
" path generation",
" motion control"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "a2a5c5d0dbdb2411351bcab9279ec267b3015b0a42ad72fa0d1353166020a1e6",
"md5": "e7c5aac6fb38372bc25c2da84dc6fc5d",
"sha256": "d4c9a21b4d7318dbeb02f88a021a17a0ac47742714741dc662989db3a0fd8f1f"
},
"downloads": -1,
"filename": "interpolatepy-2.0.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "e7c5aac6fb38372bc25c2da84dc6fc5d",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.11",
"size": 103775,
"upload_time": "2025-08-14T14:34:58",
"upload_time_iso_8601": "2025-08-14T14:34:58.393132Z",
"url": "https://files.pythonhosted.org/packages/a2/a5/c5d0dbdb2411351bcab9279ec267b3015b0a42ad72fa0d1353166020a1e6/interpolatepy-2.0.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "99c60c76b571ec5af8e0e900bec02e6bcd33db372f4235f167a09c0694e5b62d",
"md5": "9b394c432ee68b08305b6e7328f98a41",
"sha256": "284824be5d6390c4ac928ed26b463a2bc030e6d98d29b9dcd56213e1e52ff46e"
},
"downloads": -1,
"filename": "interpolatepy-2.0.1.tar.gz",
"has_sig": false,
"md5_digest": "9b394c432ee68b08305b6e7328f98a41",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.11",
"size": 272520,
"upload_time": "2025-08-14T14:34:59",
"upload_time_iso_8601": "2025-08-14T14:34:59.813675Z",
"url": "https://files.pythonhosted.org/packages/99/c6/0c76b571ec5af8e0e900bec02e6bcd33db372f4235f167a09c0694e5b62d/interpolatepy-2.0.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-14 14:34:59",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "GiorgioMedico",
"github_project": "InterpolatePy",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "numpy",
"specs": [
[
">=",
"2.0.0"
]
]
},
{
"name": "matplotlib",
"specs": [
[
">=",
"3.10.1"
]
]
},
{
"name": "scipy",
"specs": [
[
">=",
"1.15.2"
]
]
}
],
"lcname": "interpolatepy"
}
JSON
