spyrrow 0.5.0__tar.gz → 0.7.0__tar.gz

{spyrrow-0.5.0 → spyrrow-0.7.0}/Cargo.lock

@@ -326,9 +326,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hermit-abi"
-version = "0.3.9"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
 name = "indoc"
@@ -359,8 +359,8 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jagua-rs"
-version = "0.6.1"
-source = "git+https://github.com/JeroenGar/jagua-rs.git?rev=25efc5afcace4703a27d842e7a7d021575db2c5c#25efc5afcace4703a27d842e7a7d021575db2c5c"
+version = "0.6.3"
+source = "git+https://github.com/JeroenGar/jagua-rs.git?rev=f8f18907a6a82310769eed60fa6d8c0e7aaea0d3#f8f18907a6a82310769eed60fa6d8c0e7aaea0d3"
 dependencies = [
  "anyhow",
  "document-features",
@@ -535,9 +535,9 @@ dependencies = [
 
 [[package]]
 name = "num_cpus"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
 dependencies = [
  "hermit-abi",
  "libc",
@@ -603,11 +603,10 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.24.1"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17da310086b068fbdcefbba30aeb3721d5bb9af8db4987d6735b2183ca567229"
+checksum = "8970a78afe0628a3e3430376fc5fd76b6b45c4d43360ffd6cdd40bdde72b682a"
 dependencies = [
- "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -621,9 +620,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.24.1"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e27165889bd793000a098bb966adc4300c312497ea25cf7a690a9f0ac5aa5fc1"
+checksum = "458eb0c55e7ece017adeba38f2248ff3ac615e53660d7c71a238d7d2a01c7598"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -631,9 +630,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.24.1"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05280526e1dbf6b420062f3ef228b78c0c54ba94e157f5cb724a609d0f2faabc"
+checksum = "7114fe5457c61b276ab77c5055f206295b812608083644a5c5b2640c3102565c"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -641,9 +640,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.24.1"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c3ce5686aa4d3f63359a5100c62a127c9f15e8398e5fdeb5deef1fed5cd5f44"
+checksum = "a8725c0a622b374d6cb051d11a0983786448f7785336139c3c94f5aa6bef7e50"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -653,9 +652,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.24.1"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4cf6faa0cbfb0ed08e89beb8103ae9724eb4750e3a78084ba4017cbe94f3855"
+checksum = "4109984c22491085343c05b0dbc54ddc405c3cf7b4374fc533f5c3313a572ccc"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -839,7 +838,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 [[package]]
 name = "sparrow"
 version = "0.1.0"
-source = "git+https://github.com/JeroenGar/sparrow.git?rev=f65962e39cee87274f0105eeaf25047283179d7e#f65962e39cee87274f0105eeaf25047283179d7e"
+source = "git+https://github.com/JeroenGar/sparrow.git?rev=8361c59e2d800e3492ae5e7f7f781c575bdde636#8361c59e2d800e3492ae5e7f7f781c575bdde636"
 dependencies = [
  "anyhow",
  "clap",
@@ -850,6 +849,7 @@ dependencies = [
  "jagua-rs",
  "jiff",
  "log",
+ "ndarray",
  "num_cpus",
  "numfmt",
  "ordered-float",
@@ -875,9 +875,10 @@ dependencies = [
 
 [[package]]
 name = "spyrrow"
-version = "0.5.0"
+version = "0.7.0"
 dependencies = [
  "jagua-rs",
+ "num_cpus",
  "pyo3",
  "rand",
  "serde",

{spyrrow-0.5.0 → spyrrow-0.7.0}/Cargo.toml

@@ -1,8 +1,9 @@
 [package]
 name = "spyrrow"
-version = "0.5.0"
+version = "0.7.0"
 edition = "2024"
 license = "MIT"
+readme = "README.md"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
@@ -10,9 +11,10 @@ name = "spyrrow"
 crate-type = ["cdylib"]
 
 [dependencies]
-jagua-rs = { git = "https://github.com/JeroenGar/jagua-rs.git", rev="25efc5afcace4703a27d842e7a7d021575db2c5c", features = ["spp"], default-features = false}
-pyo3 = "0.24.0"
+jagua-rs = { git = "https://github.com/JeroenGar/jagua-rs.git", rev="f8f18907a6a82310769eed60fa6d8c0e7aaea0d3", features = ["spp"]}
+pyo3 = "0.25.1"
 rand = { version = "0.9.0", features = ["small_rng"] }
 serde = {version = "1.0.219", features = ["derive"]}
 serde_json = "1.0.140"
-sparrow = { git = "https://github.com/JeroenGar/sparrow.git",rev="f65962e39cee87274f0105eeaf25047283179d7e",features = ["only_final_svg"], default-features = false}
+sparrow = { git = "https://github.com/JeroenGar/sparrow.git",rev="8361c59e2d800e3492ae5e7f7f781c575bdde636",features = ["only_final_svg"]}
+num_cpus="1.17.0"

spyrrow-0.7.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: spyrrow
+Version: 0.7.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.7.0/clippy.toml

@@ -0,0 +1,4 @@
+
+# Configuration object in Python can have a lot of parameters thanks to keyword arguments
+# Creating intermediary types to reduce parameter number increases complexity for the Python user
+too-many-arguments-threshold=8 

{spyrrow-0.5.0 → spyrrow-0.7.0}/docs/api.rst

@@ -7,6 +7,8 @@ Public API of `spyrrow`
 
 .. autoclass:: spyrrow::StripPackingInstance
 
+.. autoclass:: spyrrow::StripPackingConfig
+
 .. autoclass:: spyrrow::StripPackingSolution
 
 .. autoclass:: spyrrow::PlacedItem

{spyrrow-0.5.0 → spyrrow-0.7.0}/docs/index.rst

@@ -46,7 +46,8 @@ Examples
       )
 
    instance = spyrrow.StripPackingInstance("test", strip_height=2.001, items=[rectangle1,triangle1])
-   sol:spyrrow.StripPackingSolution = instance.solve(30)
+   config = spyrrow.StripPackingConfig(early_termination=False,total_computation_time=60,num_wokers=3,seed=0)
+   sol = instance.solve(config)
    print(sol.width)
    print(sol.density)
    print("\n")
@@ -54,4 +55,17 @@ Examples
       print(pi.id)
       print(pi.rotation)
       print(pi.translation)
-      print("\n")
+      print("\n")
+
+In order to express that an Item can rotate freely, its `allowed_orientations` attributes should be set to `None`.
+
+.. code-block:: python
+
+   import spyrrow
+
+   triangle1 = spyrrow.Item(
+         "triangle",
+         [(0, 0), (1, 0), (1, 1), (0, 0)],
+         demand=6,
+         allowed_orientations=None,
+      )

spyrrow-0.7.0/spyrrow.pyi

@@ -0,0 +1,155 @@
+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 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_wokers: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_wokers: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 config object to precise behavior of how to solve the strip packing instance.
+
+        Returns:
+            a StripPackingSolution
+        """

{spyrrow-0.5.0 → spyrrow-0.7.0}/src/lib.rs

@@ -1,18 +1,20 @@
 use jagua_rs::io::ext_repr::{ExtItem as BaseItem, ExtSPolygon, ExtShape};
 use jagua_rs::io::import::Importer;
 use jagua_rs::probs::spp::io::ext_repr::{ExtItem, ExtSPInstance};
+use num_cpus;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use rand::SeedableRng;
 use rand::prelude::SmallRng;
 use serde::Serialize;
 use sparrow::EPOCH;
-use sparrow::config::{
-    CDE_CONFIG, COMPRESS_TIME_RATIO, EXPLORE_TIME_RATIO, MIN_ITEM_SEPARATION, SIMPL_TOLERANCE,
-};
-use sparrow::optimizer::{Terminator, optimize};
+use sparrow::config::{DEFAULT_SPARROW_CONFIG, ShrinkDecayStrategy};
+use sparrow::consts::{DEFAULT_FAIL_DECAY_RATIO_CMPR, DEFAULT_MAX_CONSEQ_FAILS_EXPL};
+use sparrow::optimizer::optimize;
+use sparrow::util::listener::DummySolListener;
+use sparrow::util::terminator::BasicTerminator;
 use std::collections::HashSet;
-use std::fs;
+
 use std::time::Duration;
 
 #[pyclass(name = "Item", get_all, set_all)]
@@ -21,8 +23,6 @@ use std::time::Duration;
 ///
 /// Spyrrow doesn't support hole(s) inside the shape as of yet. Therefore no Item can be nested inside another.
 ///
-/// Continous rotation is not supported as of yet. A workaround  is to specify any integer degrees between 0 and 360
-/// to the allowed_orientations list.
 ///
 /// Args:
 ///     id (str): The Item identifier
@@ -30,7 +30,9 @@ use std::time::Duration;
 ///     shape (list[tuple[float,float]]): 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 (int): The quantity of identical Items to be placed inside the strip. Should be positive.
-///     allowed_orientations (list[float]): List of angles in degrees allowed. An empty list is equivalent to [0.].
+///     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.
 ///
 struct ItemPy {
@@ -47,12 +49,12 @@ impl ItemPy {
         id: String,
         shape: Vec<(f32, f32)>,
         demand: u64,
-        allowed_orientations: Vec<f32>,
+        allowed_orientations: Option<Vec<f32>>,
     ) -> Self {
         ItemPy {
             id,
             demand,
-            allowed_orientations: Some(allowed_orientations),
+            allowed_orientations,
             shape,
         }
     }
@@ -123,6 +125,100 @@ fn all_unique(strings: &[&str]) -> bool {
     strings.iter().all(|s| seen.insert(*s))
 }
 
+#[pyclass(name = "StripPackingConfig", get_all, set_all)]
+#[derive(Clone, Serialize)]
+/// 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.
+struct StripPackingConfigPy {
+    early_termination: bool,
+    seed: u64,
+    exploration_time: Duration,
+    compression_time: Duration,
+    quadtree_depth: u8,
+    min_items_separation: Option<f32>,
+    num_wokers: usize,
+}
+
+#[pymethods]
+impl StripPackingConfigPy {
+    #[new]
+    #[pyo3(signature = (early_termination=true,quadtree_depth=4,min_items_separation=None,total_computation_time=600,exploration_time=None,compression_time=None,num_wokers=None,seed=None))]
+    fn new(
+        early_termination: bool,
+        quadtree_depth: u8,
+        min_items_separation: Option<f32>,
+        total_computation_time: Option<u64>,
+        exploration_time: Option<u64>,
+        compression_time: Option<u64>,
+        num_wokers: Option<usize>,
+        seed: Option<u64>,
+    ) -> PyResult<Self> {
+        let (exploration_time, compression_time) = match (
+            total_computation_time,
+            exploration_time,
+            compression_time,
+        ) {
+            (None, Some(exploration_time), Some(compression_time)) => (
+                Duration::from_secs(exploration_time),
+                Duration::from_secs(compression_time),
+            ),
+            (Some(total_computation_time), None, None) => (
+                Duration::from_secs(total_computation_time).mul_f32(0.8),
+                Duration::from_secs(total_computation_time).mul_f32(0.2),
+            ),
+            _ => {
+                return Err(PyValueError::new_err(
+                    "Either total_computation_time or both exploration_time and compression_time should be provided, not all 3 or some other combination",
+                ));
+            }
+        };
+        let seed = seed.unwrap_or_else(rand::random);
+        let num_wokers = num_wokers.unwrap_or_else(num_cpus::get);
+        Ok(Self {
+            early_termination,
+            seed,
+            exploration_time,
+            compression_time,
+            quadtree_depth,
+            num_wokers,
+            min_items_separation,
+        })
+    }
+
+    /// Return a string of the JSON representation of the object
+    ///
+    /// Returns:
+    ///     str
+    ///
+    fn to_json_str(&self) -> String {
+        serde_json::to_string(&self).unwrap()
+    }
+}
+
 #[pyclass(name = "StripPackingInstance", get_all, set_all)]
 #[derive(Clone, Serialize)]
 /// An Instance of a Strip Packing Problem.
@@ -160,7 +256,6 @@ impl From<StripPackingInstancePy> for ExtSPInstance {
                 ExtItem {
                     base,
                     demand: v.demand,
-                    //         }
                 }
             })
             .collect();
@@ -178,7 +273,7 @@ impl StripPackingInstancePy {
     fn new(name: String, strip_height: f32, items: Vec<ItemPy>) -> PyResult<Self> {
         let item_ids: Vec<&str> = items.iter().map(|i| i.id.as_str()).collect();
         if !all_unique(&item_ids) {
-            let error_string = format!("The item ids are not uniques: {:#?}", item_ids);
+            let error_string = format!("The item ids are not uniques: {item_ids:#?}");
             return Err(PyValueError::new_err(error_string));
         }
         Ok(StripPackingInstancePy {
@@ -197,7 +292,6 @@ impl StripPackingInstancePy {
         serde_json::to_string(&self).unwrap()
     }
 
-    #[pyo3(signature = (computation_time=600))]
     /// The method to solve the instance.
     ///
     /// Args:
@@ -207,37 +301,42 @@ impl StripPackingInstancePy {
     /// Returns:
     ///     a StripPackingSolution
     ///
-    fn solve(&self, computation_time: u64, py: Python) -> StripPackingSolutionPy {
-        // Temporary output dir for intermediary solution
-
-        // let tmp = TempDir::new().expect("could not create output directory");
-        let tmp_str = String::from("tmp");
-        fs::create_dir_all(&tmp_str).expect("Temporary foulder should be created");
-
-        // Reproductibility
-        let seed = rand::random();
-        let rng = SmallRng::seed_from_u64(seed);
-
-        // Execution Time
-        let (explore_dur, compress_dur) = (
-            Duration::from_secs(computation_time).mul_f32(EXPLORE_TIME_RATIO),
-            Duration::from_secs(computation_time).mul_f32(COMPRESS_TIME_RATIO),
-        );
+    fn solve(&self, config_py: StripPackingConfigPy, py: Python) -> StripPackingSolutionPy {
+        let mut config = DEFAULT_SPARROW_CONFIG;
+        config.rng_seed = Some(config_py.seed as usize);
+        config.expl_cfg.time_limit = config_py.exploration_time;
+        config.expl_cfg.separator_config.n_workers = config_py.num_wokers;
+        config.cmpr_cfg.time_limit = config_py.compression_time;
+        let rng = SmallRng::seed_from_u64(config_py.seed);
+        if config_py.early_termination {
+            config.expl_cfg.max_conseq_failed_attempts = Some(DEFAULT_MAX_CONSEQ_FAILS_EXPL);
+            config.cmpr_cfg.shrink_decay =
+                ShrinkDecayStrategy::FailureBased(DEFAULT_FAIL_DECAY_RATIO_CMPR);
+        }
+        config.cde_config.quadtree_depth = config_py.quadtree_depth;
+        config.min_item_separation = config_py.min_items_separation;
 
         let ext_instance = self.clone().into();
-        let importer = Importer::new(CDE_CONFIG, SIMPL_TOLERANCE, MIN_ITEM_SEPARATION);
+        let importer = Importer::new(
+            config.cde_config,
+            config.poly_simpl_tolerance,
+            config.min_item_separation,
+        );
         let instance = jagua_rs::probs::spp::io::import(&importer, &ext_instance)
             .expect("Expected a Strip Packing Problem Instance");
+        let mut terminator = BasicTerminator::new();
+
+        // The Python code is not concerned with intermediary solution for now
+        let mut dummy_exporter = DummySolListener {};
 
         py.allow_threads(move || {
-            let terminator = Terminator::new_without_ctrlc();
             let solution = optimize(
                 instance.clone(),
                 rng,
-                tmp_str.clone(),
-                terminator,
-                explore_dur,
-                compress_dur,
+                &mut dummy_exporter,
+                &mut terminator,
+                &config.expl_cfg,
+                &config.cmpr_cfg,
             );
 
             let solution = jagua_rs::probs::spp::io::export(&instance, &solution, *EPOCH);
@@ -252,7 +351,7 @@ impl StripPackingInstancePy {
                     translation: jpi.transformation.translation,
                 })
                 .collect();
-            fs::remove_dir_all(&tmp_str).expect("Should be able to remove tmp dir");
+
             StripPackingSolutionPy {
                 width: solution.strip_width,
                 density: solution.density,
@@ -268,6 +367,7 @@ fn spyrrow(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<ItemPy>()?;
     m.add_class::<PlacedItemPy>()?;
     m.add_class::<StripPackingInstancePy>()?;
+    m.add_class::<StripPackingConfigPy>()?;
     m.add_class::<StripPackingSolutionPy>()?;
     m.add("__version__", env!("CARGO_PKG_VERSION"))?;
     Ok(())

spyrrow-0.7.0/tests/test_basic.py

@@ -0,0 +1,91 @@
+import spyrrow
+import pytest
+
+def test_basic():
+    rectangle1 = spyrrow.Item(
+        "rectangle", [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], demand=4, allowed_orientations=[0]
+    )
+    triangle1 = spyrrow.Item(
+        "triangle",
+        [(0, 0), (1, 0), (1, 1), (0, 0)],
+        demand=6,
+        allowed_orientations=[0, 90, 180, -90],
+    )
+
+    instance = spyrrow.StripPackingInstance(
+        "test", strip_height=2.001, items=[rectangle1, triangle1]
+    )
+    config = spyrrow.StripPackingConfig(early_termination=False,total_computation_time=60,num_wokers=3,seed=0)
+    sol = instance.solve(config)
+    assert sol.width == pytest.approx(4,rel=0.05)
+
+def test_early_termination():
+    rectangle1 = spyrrow.Item(
+        "rectangle", [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], demand=4, allowed_orientations=[0]
+    )
+    triangle1 = spyrrow.Item(
+        "triangle",
+        [(0, 0), (1, 0), (1, 1), (0, 0)],
+        demand=6,
+        allowed_orientations=[0, 90, 180, -90],
+    )
+
+    instance = spyrrow.StripPackingInstance(
+        "test", strip_height=2.001, items=[rectangle1, triangle1]
+    )
+    config = spyrrow.StripPackingConfig(early_termination=True,total_computation_time=600,num_wokers=3,seed=0)
+    sol = instance.solve(config)
+    assert sol.width == pytest.approx(4,rel=0.05)
+
+def test_2_consecutive_calls():
+    # Test corresponding to crash on the second consecutive call of solve method
+    rectangle1 = spyrrow.Item(
+        "rectangle", [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], demand=4, allowed_orientations=[0]
+    )
+    triangle1 = spyrrow.Item(
+        "triangle",
+        [(0, 0), (1, 0), (1, 1), (0, 0)],
+        demand=6,
+        allowed_orientations=[0, 90, 180, -90],
+    )
+
+    instance = spyrrow.StripPackingInstance(
+        "test", strip_height=2.001, items=[rectangle1, triangle1]
+    )
+    config = spyrrow.StripPackingConfig(early_termination=False,total_computation_time=10,seed=0)
+    sol = instance.solve(config)
+    config = spyrrow.StripPackingConfig(early_termination=False,total_computation_time=30,seed=0)
+    sol = instance.solve(config)
+    assert sol.width == pytest.approx(4,rel=0.05)
+
+def test_concave_polygons():
+    poly1 = spyrrow.Item("0",[(0, 0), (3, 0), (4, 1), (3, 2), (0, 2), (1, 1), (0, 0)],demand=2,allowed_orientations=[0,90,180,270])
+    poly2 = spyrrow.Item("1",[(0, 0), (1, 0), (1, 2), (3, 2), (3, 0), (4, 0), (4, 3), (0, 3), (0, 0)], demand=3, allowed_orientations=[0,90,180,270])
+    instance = spyrrow.StripPackingInstance(
+        "test", strip_height=4.001, items=[poly1, poly2]
+    )
+    config = spyrrow.StripPackingConfig(early_termination=True,total_computation_time=30,seed=0)
+    sol = instance.solve(config)
+
+def test_continuous_rotation():
+    rectangle1 = spyrrow.Item(
+        "rectangle", [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], demand=4, allowed_orientations=None
+    )
+    triangle1 = spyrrow.Item(
+        "triangle",
+        [(0, 0), (1, 0), (1, 1), (0, 0)],
+        demand=6,
+        allowed_orientations=None,
+    )
+
+    instance = spyrrow.StripPackingInstance(
+        "test", strip_height=2.001, items=[rectangle1, triangle1]
+    )
+    config = spyrrow.StripPackingConfig(early_termination=True,total_computation_time=90,seed=0)
+    sol = instance.solve(config)
+    print(sol.width)
+    assert sol.width >= 3.5
+    assert sol.width < 4
+
+if __name__ == '__main__':
+    test_continuous_rotation()

spyrrow-0.5.0/PKG-INFO

@@ -1,68 +0,0 @@
-Metadata-Version: 2.4
-Name: spyrrow
-Version: 0.5.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>
-License: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: documentation, https://spyrrow.readthedocs.io/
-Project-URL: source, https://github.com/PaulDL-RS/spyrrow
-
-# Spyrrow
-
-`spyrrow` is a Python wrapper on the Rust project [`sparrow`](https://github.com/JeroenGar/sparrow).
-It enables to solve 2D [Strip packing problems](https://en.wikipedia.org/wiki/Strip_packing_problem). 
-
-The documentation is hosted [here](https://spyrrow.readthedocs.io/). 
-
-## Installation
-
-Spyrrow is hosted on [PyPI](https://pypi.org/project/spyrrow/).
-
-You can install with the package manager of your choice, using the PyPI package index.
-
-For example, with `pip`, the default Python package:
-```bash
-pip install spyrrow
-```
-
-## Examples
-```python
-import spyrrow
-
-rectangle1 = spyrrow.Item(
-        "rectangle", [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], demand=4, allowed_orientations=[0]
-    )
-triangle1 = spyrrow.Item(
-         "triangle",
-        [(0, 0), (1, 0), (1, 1), (0, 0)],
-        demand=6,
-        allowed_orientations=[0, 90, 180, -90],
-    )
-
-instance = spyrrow.StripPackingInstance("test", strip_height=2.001, items=[rectangle1,triangle1])
-sol:spyrrow.StripPackingSolution = instance.solve(30)
-print(sol.width)
-print(sol.density)
-print("\n")
-for pi in sol.placed_items:
-    print(pi.id)
-    print(pi.rotation)
-    print(pi.translation)
-    print("\n")
-```
-
-## Contributing
-
-Spyrrow is open to contributions.
-The first target should be to reach  Python open sources packages standards and practices. 
-Second, a easier integration with the package `shapely` is envsionned.
-
-Please use GitHub issues to request features. 
-They will be considered relative to what is already implemented in the parent library `sparrow`. 
-If necessary, they can be forwarded to it. 
-

spyrrow-0.5.0/spyrrow.pyi

@@ -1,102 +0,0 @@
-from typing import TypeAlias
-
-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],
-    ):
-        """
-        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.
-
-        Continous rotation is not supported as of yet. A workaround  is to specify any integer degrees between 0 and 360
-        to the allowed_orientations list.
-
-        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 positive.
-            allowed_orientations: List of angles in degrees allowed. An empty list is equivalent to [0.].
-              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 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, computation_time: int = 600) -> StripPackingSolution:
-        """
-        The method to solve the instance.
-
-        Args:
-            computation_time (int): The total computation time in seconds used to find a solution.
-              The algorithm won't exit early.Waht you input is what you get. Default is 600 s = 10 minutes.
-
-        Returns:
-            a StripPackingSolution
-        """

spyrrow-0.5.0/tests/test_basic.py

@@ -1,47 +0,0 @@
-import spyrrow
-import pytest
-
-def test_basic():
-    ## Continuous rotation seems to not be implemented for strip packing
-    rectangle1 = spyrrow.Item(
-        "rectangle", [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], demand=4, allowed_orientations=[0]
-    )
-    triangle1 = spyrrow.Item(
-        "triangle",
-        [(0, 0), (1, 0), (1, 1), (0, 0)],
-        demand=6,
-        allowed_orientations=[0, 90, 180, -90],
-    )
-
-    instance = spyrrow.StripPackingInstance(
-        "test", strip_height=2.001, items=[rectangle1, triangle1]
-    )
-    sol = instance.solve(30)
-    assert sol.width == pytest.approx(4,rel=0.2)
-
-def test_2_consecutive_calls():
-    # Test correpsonding to crash on the second consecutive call of solve method
-    rectangle1 = spyrrow.Item(
-        "rectangle", [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], demand=4, allowed_orientations=[0]
-    )
-    triangle1 = spyrrow.Item(
-        "triangle",
-        [(0, 0), (1, 0), (1, 1), (0, 0)],
-        demand=6,
-        allowed_orientations=[0, 90, 180, -90],
-    )
-
-    instance = spyrrow.StripPackingInstance(
-        "test", strip_height=2.001, items=[rectangle1, triangle1]
-    )
-    sol = instance.solve(10)
-    sol = instance.solve(30)
-    assert sol.width == pytest.approx(4,rel=0.2)
-
-def test_concave_polygons():
-    poly1 = spyrrow.Item("0",[(0, 0), (3, 0), (4, 1), (3, 2), (0, 2), (1, 1), (0, 0)],demand=2,allowed_orientations=[0,90,180,270])
-    poly2 = spyrrow.Item("1",[(0, 0), (1, 0), (1, 2), (3, 2), (3, 0), (4, 0), (4, 3), (0, 3), (0, 0)], demand=3, allowed_orientations=[0,90,180,270])
-    instance = spyrrow.StripPackingInstance(
-        "test", strip_height=4.001, items=[poly1, poly2]
-    )
-    sol = instance.solve(30)