spyrrow 0.8.0__cp314-cp314-win32.whl

spyrrow/__init__.py

@@ -0,0 +1,5 @@
+from .spyrrow import *
+
+__doc__ = spyrrow.__doc__
+if hasattr(spyrrow, "__all__"):
+    __all__ = spyrrow.__all__

spyrrow/__init__.pyi

@@ -0,0 +1,153 @@
+from typing import TypeAlias, Optional
+from datetime import timedelta
+
+Point: TypeAlias = tuple[float, float]
+
+class Item:
+    id: str
+    demand: int
+    shape: list[Point]
+    allowed_orientations: list[float]
+
+    def __init__(
+        self,
+        id: str,
+        shape: list[Point],
+        demand: int,
+        allowed_orientations: list[float] | None,
+    ):
+        """
+        An Item represents any closed 2D shape by its outer boundary.
+
+        Spyrrow doesn't support hole(s) inside the shape as of yet. Therefore no Item can be nested inside another.
+
+        Args:
+            id (str): The Item identifier
+              Needs to be unique accross all Items of a StripPackingInstance
+            shape: An ordered list of (x,y) defining the shape boundary. The shape is represented as a polygon formed by this list of points.
+              The origin point can be included twice as the finishing point. If not, [last point, first point] is infered to be the last straight line of the shape.
+            demand: The quantity of identical Items to be placed inside the strip. Should be strictly positive.
+            allowed_orientations (list[float]|None): List of angles in degrees allowed.
+              An empty list is equivalent to [0.].
+              A None value means that the item is free to rotate
+              The algorithmn is only very weakly sensible to the length of the list given.
+
+        """
+
+    def to_json_str(self) -> str:
+        """Return a string of the JSON representation of the object"""
+
+class PlacedItem:
+    """
+    An object representing where a copy of an Item was placed inside the strip.
+
+    Attributes:
+        id (str): The Item identifier referencing the items of the StripPackingInstance
+        rotation (float): The rotation angle in degrees, assuming that the original Item was defined with 0° as its rotation angle.
+          Use the origin (0.0,0.0) as the rotation point.
+        translation (tuple[float,float]): the translation vector in the X-Y axis. To apply after the rotation
+    """
+
+    id: str
+    translation: Point
+    rotation: float
+
+class StripPackingSolution:
+    """
+    An object representing the solution to a given StripPackingInstance.
+
+    Can not be directly instanciated. Result from StripPackingInstance.solve.
+
+    Attributes:
+        width (float): the width of the strip found to contains all Items. In the same unit as input.
+        placed_items (list[PlacedItem]): a list of all PlacedItems, describing how Items are placed in the solution
+        density (float): the fraction of the final strip used by items.
+    """
+
+    width: float
+    density: float
+    placed_items: list[PlacedItem]
+
+class StripPackingConfig:
+    early_termination: bool
+    seed: int
+    exploration_time: timedelta
+    compression_time: timedelta
+    quadtree_depth: int
+    num_workers:Optional[int]
+    min_items_separation: Optional[float]
+
+    def __init__(
+        self,
+        early_termination: bool = True,
+        quadtree_depth: int = 4,
+        min_items_separation: Optional[float] = None,
+        total_computation_time: Optional[int] = 600,
+        exploration_time: Optional[int] = None,
+        compression_time: Optional[int] = None,
+        num_workers:Optional[int]= None,
+        seed: Optional[int] = None,
+    ) -> None:
+        """Initializes a configuration object for the strip packing algorithm.
+
+        Either `total_computation_time`, or both `exploration_time` and `compression_time`, must be provided. 
+          Providing all three or only one of the latter two raises an error.
+        If `total_computation_time` is provided, 80% of it is allocated to exploration and 20% to compression.
+        If `seed` is not provided, a random seed will be generated.
+
+        
+        Args:
+            early_termination (bool, optional): Whether to allow early termination of the algorithm. Defaults to True.
+            quadtree_depth (int, optional): Maximum depth of the quadtree used by the collision detection engine jagua-rs. 
+              Must be positive, common values are 3,4,5. Defaults to 4.
+            min_items_separation (Optional[float], optional): Minimum required distance between packed items. Defaults to None.
+            total_computation_time (Optional[int], optional): Total time budget in seconds. 
+              Used if `exploration_time` and `compression_time` are not provided. Defaults to 600.
+            exploration_time (Optional[int], optional): Time in seconds allocated to exploration. Defaults to None.
+            compression_time (Optional[int], optional): Time in seconds allocated to compression. Defaults to None.
+            num_workers (Optional[int], optional): Number of threads used by the collision detection engine during exploration.
+              When set to None, detect the number of logical CPU cores on the execution plateform. Defaults to None.
+            seed (Optional[int], optional): Optional random seed to give reproductibility. If None, a random seed is generated. Defaults to None.
+
+        Raises:
+            ValueError: If the combination of time arguments is invalid.
+
+        """
+
+    def to_json_str(self)->str:
+        """Return a string of the JSON representation of the object
+
+        Returns:
+            str
+        """
+
+class StripPackingInstance:
+    name: str
+    strip_height: float
+    items: list[Item]
+
+    def __init__(self, name: str, strip_height: float, items: list[Item]):
+        """
+        An Instance of a Strip Packing Problem.
+
+        Args:
+            name (str): The name of the instance. Required by the underlying sparrow library.
+              An empty string '' can be used, if the user doesn't have a use for this name.
+            strip_height (float): the fixed height of the strip. The unit should be compatible with the Item
+            items (list[Item]): The Items which defines the instances. All Items should be defined with the same scale ( same length unit).
+         Raises:
+            ValueError
+        """
+    def to_json_str(self) -> str:
+        """Return a string of the JSON representation of the object"""
+
+    def solve(self, config: StripPackingConfig) -> StripPackingSolution:
+        """
+        The method to solve the instance.
+
+        Args:
+            config (StripPackingConfig): The configuration object to control how the instance is solved.
+
+        Returns:
+            a StripPackingSolution
+        """

spyrrow-0.8.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: spyrrow
+Version: 0.8.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+License-File: LICENSE.txt
+Author-email: Paul Durand-Lupinski <paul.durand-lupinski@reeverse-systems.com>
+Requires-Python: >=3.10
+Project-URL: documentation, https://spyrrow.readthedocs.io/
+Project-URL: source, https://github.com/PaulDL-RS/spyrrow

spyrrow-0.8.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+spyrrow-0.8.0.dist-info/METADATA,sha256=VqdpFe_-2OjZz_0YnLJpG1ac78qUBECOWk6Qn1I4ykI,480
+spyrrow-0.8.0.dist-info/WHEEL,sha256=8HN3N__kOX50d01M5g7gDrPP9KRQGBqXq8p0TJZtkmI,93
+spyrrow-0.8.0.dist-info/licenses/LICENSE.txt,sha256=Ugi_fLJkCPA3DrzIdQnHifz5MwSyxuzTsNWUFRMQvMM,1096
+spyrrow/__init__.py,sha256=MajlSBAliv8o8SqAqLgJARyi3egmvNIaXKTDXxvIAFY,111
+spyrrow/__init__.pyi,sha256=wsVvDG45Aq5nHfaqFKBkPL1a0aZCa2_ABKsGH97CXGg,6594
+spyrrow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spyrrow/spyrrow.cp314-win32.pyd,sha256=QTRccWR92jI-_VrBfT2R9wHt8Gdeef-hkIlXJwOHsxg,1082368
+spyrrow-0.8.0.dist-info/RECORD,,

spyrrow-0.8.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.10.2)
+Root-Is-Purelib: false
+Tag: cp314-cp314-win32

spyrrow-0.8.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Paul Durand-Lupinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.