solverforge 0.2.2__tar.gz → 0.2.4__tar.gz

{solverforge-0.2.2 → solverforge-0.2.4}/Cargo.lock

@@ -1507,7 +1507,7 @@ dependencies = [
 
 [[package]]
 name = "solverforge"
-version = "0.2.2"
+version = "0.2.4"
 dependencies = [
  "solverforge-core",
  "solverforge-derive",
@@ -1516,7 +1516,7 @@ dependencies = [
 
 [[package]]
 name = "solverforge-core"
-version = "0.2.2"
+version = "0.2.4"
 dependencies = [
  "base64",
  "indexmap",
@@ -1532,7 +1532,7 @@ dependencies = [
 
 [[package]]
 name = "solverforge-derive"
-version = "0.2.2"
+version = "0.2.4"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1544,7 +1544,7 @@ dependencies = [
 
 [[package]]
 name = "solverforge-python"
-version = "0.2.2"
+version = "0.2.4"
 dependencies = [
  "log",
  "pyo3",
@@ -1557,7 +1557,7 @@ dependencies = [
 
 [[package]]
 name = "solverforge-service"
-version = "0.2.2"
+version = "0.2.4"
 dependencies = [
  "base64",
  "chrono",

{solverforge-0.2.2 → solverforge-0.2.4}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["solverforge-core", "solverforge-python"]
 resolver = "2"
 
 [workspace.package]
-version = "0.2.2"
+version = "0.2.4"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/solverforge/solverforge"

{solverforge-0.2.2 → solverforge-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solverforge
-Version: 0.2.2
+Version: 0.2.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3

{solverforge-0.2.2 → solverforge-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "solverforge"
-version = "0.2.2"
+version = "0.2.4"
 description = "Python bindings for SolverForge constraint solver"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{solverforge-0.2.2 → solverforge-0.2.4}/python/solverforge/__init__.py

@@ -24,6 +24,9 @@ from solverforge._solverforge import (
     PlanningEntityCollectionProperty,
     PlanningPin,
     InverseRelationShadowVariable,
+    PreviousElementShadowVariable,
+    NextElementShadowVariable,
+    CascadingUpdateShadowVariable,
     # Score types
     SimpleScore,
     HardSoftScore,
@@ -35,6 +38,36 @@ from solverforge._solverforge import (
     build_domain_model,
     DomainClass,
     DomainModel,
+    constraint_provider,
+    ConstraintProvider,
+    # Solver runtime
+    TerminationConfig,
+    DiminishedReturnsConfig,
+    EnvironmentMode,
+    MoveThreadCount,
+    SolverConfig,
+    SolveHandle,
+    SolveState,
+    ScoreDto,
+    SolveStatus,
+    SolveResponse,
+    SolverFactory,
+    Solver,
+    # Constraint streams
+    ConstraintFactory,
+    UniConstraintStream,
+    BiConstraintStream,
+    TriConstraintStream,
+    UniConstraintBuilder,
+    BiConstraintBuilder,
+    TriConstraintBuilder,
+    Constraint,
+    # Joiners
+    Joiner,
+    Joiners,
+    # Collectors
+    Collector,
+    ConstraintCollectors,
 )
 
 __all__ = [
@@ -51,6 +84,9 @@ __all__ = [
     "PlanningEntityCollectionProperty",
     "PlanningPin",
     "InverseRelationShadowVariable",
+    "PreviousElementShadowVariable",
+    "NextElementShadowVariable",
+    "CascadingUpdateShadowVariable",
     # Score types
     "SimpleScore",
     "HardSoftScore",
@@ -62,4 +98,34 @@ __all__ = [
     "build_domain_model",
     "DomainClass",
     "DomainModel",
+    "constraint_provider",
+    "ConstraintProvider",
+    # Solver runtime
+    "TerminationConfig",
+    "DiminishedReturnsConfig",
+    "EnvironmentMode",
+    "MoveThreadCount",
+    "SolverConfig",
+    "SolveHandle",
+    "SolveState",
+    "ScoreDto",
+    "SolveStatus",
+    "SolveResponse",
+    "SolverFactory",
+    "Solver",
+    # Constraint streams
+    "ConstraintFactory",
+    "UniConstraintStream",
+    "BiConstraintStream",
+    "TriConstraintStream",
+    "UniConstraintBuilder",
+    "BiConstraintBuilder",
+    "TriConstraintBuilder",
+    "Constraint",
+    # Joiners
+    "Joiner",
+    "Joiners",
+    # Collectors
+    "Collector",
+    "ConstraintCollectors",
 ]

{solverforge-0.2.2 → solverforge-0.2.4}/solverforge-python/python/solverforge/__init__.py

@@ -24,6 +24,9 @@ from solverforge._solverforge import (
     PlanningEntityCollectionProperty,
     PlanningPin,
     InverseRelationShadowVariable,
+    PreviousElementShadowVariable,
+    NextElementShadowVariable,
+    CascadingUpdateShadowVariable,
     # Score types
     SimpleScore,
     HardSoftScore,
@@ -35,6 +38,36 @@ from solverforge._solverforge import (
     build_domain_model,
     DomainClass,
     DomainModel,
+    constraint_provider,
+    ConstraintProvider,
+    # Solver runtime
+    TerminationConfig,
+    DiminishedReturnsConfig,
+    EnvironmentMode,
+    MoveThreadCount,
+    SolverConfig,
+    SolveHandle,
+    SolveState,
+    ScoreDto,
+    SolveStatus,
+    SolveResponse,
+    SolverFactory,
+    Solver,
+    # Constraint streams
+    ConstraintFactory,
+    UniConstraintStream,
+    BiConstraintStream,
+    TriConstraintStream,
+    UniConstraintBuilder,
+    BiConstraintBuilder,
+    TriConstraintBuilder,
+    Constraint,
+    # Joiners
+    Joiner,
+    Joiners,
+    # Collectors
+    Collector,
+    ConstraintCollectors,
 )
 
 __all__ = [
@@ -51,6 +84,9 @@ __all__ = [
     "PlanningEntityCollectionProperty",
     "PlanningPin",
     "InverseRelationShadowVariable",
+    "PreviousElementShadowVariable",
+    "NextElementShadowVariable",
+    "CascadingUpdateShadowVariable",
     # Score types
     "SimpleScore",
     "HardSoftScore",
@@ -62,4 +98,34 @@ __all__ = [
     "build_domain_model",
     "DomainClass",
     "DomainModel",
+    "constraint_provider",
+    "ConstraintProvider",
+    # Solver runtime
+    "TerminationConfig",
+    "DiminishedReturnsConfig",
+    "EnvironmentMode",
+    "MoveThreadCount",
+    "SolverConfig",
+    "SolveHandle",
+    "SolveState",
+    "ScoreDto",
+    "SolveStatus",
+    "SolveResponse",
+    "SolverFactory",
+    "Solver",
+    # Constraint streams
+    "ConstraintFactory",
+    "UniConstraintStream",
+    "BiConstraintStream",
+    "TriConstraintStream",
+    "UniConstraintBuilder",
+    "BiConstraintBuilder",
+    "TriConstraintBuilder",
+    "Constraint",
+    # Joiners
+    "Joiner",
+    "Joiners",
+    # Collectors
+    "Collector",
+    "ConstraintCollectors",
 ]

{solverforge-0.2.2 → solverforge-0.2.4}/solverforge-python/src/annotations.rs

@@ -383,6 +383,140 @@ impl PyInverseRelationShadowVariable {
     }
 }
 
+/// Marks a field as a previous element shadow variable.
+///
+/// Automatically tracks the previous element in a planning list variable.
+/// Used with PlanningListVariable to access the element before this one.
+///
+/// # Parameters
+///
+/// - `source_variable_name`: Name of the planning list variable this shadows
+///
+/// # Example
+///
+/// ```python
+/// @planning_entity
+/// class Visit:
+///     previous_visit: Annotated[Optional['Visit'], PreviousElementShadowVariable(source_variable_name='visits')]
+/// ```
+#[pyclass(name = "PreviousElementShadowVariable")]
+#[derive(Clone, Debug)]
+pub struct PyPreviousElementShadowVariable {
+    #[pyo3(get)]
+    pub source_variable_name: String,
+}
+
+#[pymethods]
+impl PyPreviousElementShadowVariable {
+    #[new]
+    fn new(source_variable_name: String) -> Self {
+        Self {
+            source_variable_name,
+        }
+    }
+
+    fn __repr__(&self) -> String {
+        format!(
+            "PreviousElementShadowVariable(source_variable_name='{}')",
+            self.source_variable_name
+        )
+    }
+}
+
+/// Marks a field as a next element shadow variable.
+///
+/// Automatically tracks the next element in a planning list variable.
+/// Used with PlanningListVariable to access the element after this one.
+///
+/// # Parameters
+///
+/// - `source_variable_name`: Name of the planning list variable this shadows
+///
+/// # Example
+///
+/// ```python
+/// @planning_entity
+/// class Visit:
+///     next_visit: Annotated[Optional['Visit'], NextElementShadowVariable(source_variable_name='visits')]
+/// ```
+#[pyclass(name = "NextElementShadowVariable")]
+#[derive(Clone, Debug)]
+pub struct PyNextElementShadowVariable {
+    #[pyo3(get)]
+    pub source_variable_name: String,
+}
+
+#[pymethods]
+impl PyNextElementShadowVariable {
+    #[new]
+    fn new(source_variable_name: String) -> Self {
+        Self {
+            source_variable_name,
+        }
+    }
+
+    fn __repr__(&self) -> String {
+        format!(
+            "NextElementShadowVariable(source_variable_name='{}')",
+            self.source_variable_name
+        )
+    }
+}
+
+/// Marks a field as a cascading update shadow variable.
+///
+/// A shadow variable that is updated based on other shadow variables or planning variables,
+/// with updates cascading through a chain of elements.
+///
+/// # Parameters
+///
+/// - `target_method_name`: Name of the method to call for computing the shadow value
+/// - `source_variable_name`: Optional name of the source variable that triggers updates
+///
+/// # Example
+///
+/// ```python
+/// @planning_entity
+/// class Visit:
+///     arrival_time: Annotated[datetime, CascadingUpdateShadowVariable(
+///         target_method_name='calculate_arrival_time',
+///         source_variable_name='visits'
+///     )]
+/// ```
+#[pyclass(name = "CascadingUpdateShadowVariable")]
+#[derive(Clone, Debug)]
+pub struct PyCascadingUpdateShadowVariable {
+    #[pyo3(get)]
+    pub target_method_name: String,
+    #[pyo3(get)]
+    pub source_variable_name: Option<String>,
+}
+
+#[pymethods]
+impl PyCascadingUpdateShadowVariable {
+    #[new]
+    #[pyo3(signature = (target_method_name, source_variable_name=None))]
+    fn new(target_method_name: String, source_variable_name: Option<String>) -> Self {
+        Self {
+            target_method_name,
+            source_variable_name,
+        }
+    }
+
+    fn __repr__(&self) -> String {
+        match &self.source_variable_name {
+            Some(src) => format!(
+                "CascadingUpdateShadowVariable(target_method_name='{}', source_variable_name='{}')",
+                self.target_method_name, src
+            ),
+            None => format!(
+                "CascadingUpdateShadowVariable(target_method_name='{}')",
+                self.target_method_name
+            ),
+        }
+    }
+}
+
 /// Marks a field as requiring deep planning cloning.
 ///
 /// Not needed for `planning_solution` or `planning_entity` attributes because those
@@ -454,6 +588,9 @@ pub fn register_annotations(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyPlanningEntityCollectionProperty>()?;
     m.add_class::<PyPlanningPin>()?;
     m.add_class::<PyInverseRelationShadowVariable>()?;
+    m.add_class::<PyPreviousElementShadowVariable>()?;
+    m.add_class::<PyNextElementShadowVariable>()?;
+    m.add_class::<PyCascadingUpdateShadowVariable>()?;
     m.add_class::<PyDeepPlanningClone>()?;
     m.add_function(wrap_pyfunction!(py_deep_planning_clone, m)?)?;
     Ok(())
@@ -546,6 +683,43 @@ mod tests {
         assert!(shadow.__repr__().contains("visits"));
     }
 
+    #[test]
+    fn test_previous_element_shadow_variable() {
+        let shadow = PyPreviousElementShadowVariable::new("visits".to_string());
+        assert_eq!(shadow.source_variable_name, "visits");
+        assert!(shadow.__repr__().contains("visits"));
+        assert!(shadow.__repr__().contains("PreviousElementShadowVariable"));
+    }
+
+    #[test]
+    fn test_next_element_shadow_variable() {
+        let shadow = PyNextElementShadowVariable::new("visits".to_string());
+        assert_eq!(shadow.source_variable_name, "visits");
+        assert!(shadow.__repr__().contains("visits"));
+        assert!(shadow.__repr__().contains("NextElementShadowVariable"));
+    }
+
+    #[test]
+    fn test_cascading_update_shadow_variable() {
+        let shadow = PyCascadingUpdateShadowVariable::new(
+            "calculate_arrival".to_string(),
+            Some("visits".to_string()),
+        );
+        assert_eq!(shadow.target_method_name, "calculate_arrival");
+        assert_eq!(shadow.source_variable_name, Some("visits".to_string()));
+        assert!(shadow.__repr__().contains("calculate_arrival"));
+        assert!(shadow.__repr__().contains("visits"));
+    }
+
+    #[test]
+    fn test_cascading_update_shadow_variable_no_source() {
+        let shadow = PyCascadingUpdateShadowVariable::new("update_time".to_string(), None);
+        assert_eq!(shadow.target_method_name, "update_time");
+        assert_eq!(shadow.source_variable_name, None);
+        assert!(shadow.__repr__().contains("update_time"));
+        assert!(!shadow.__repr__().contains("source_variable_name"));
+    }
+
     #[test]
     fn test_deep_planning_clone() {
         let clone = PyDeepPlanningClone::new();

solverforge-0.2.4/solverforge-python/src/lib.rs

@@ -0,0 +1,171 @@
+//! Python bindings for SolverForge constraint solver
+//!
+//! This crate provides Python bindings using PyO3, offering a 1:1 compatible API
+//! with Timefold's Python bindings.
+
+use pyo3::prelude::*;
+
+mod annotations;
+mod bridge;
+mod collectors;
+mod decorators;
+mod joiners;
+mod lambda_analyzer;
+mod score;
+mod solver;
+mod stream;
+
+pub use annotations::{
+    PyCascadingUpdateShadowVariable, PyDeepPlanningClone, PyInverseRelationShadowVariable,
+    PyNextElementShadowVariable, PyPlanningEntityCollectionProperty, PyPlanningEntityProperty,
+    PyPlanningId, PyPlanningListVariable, PyPlanningPin, PyPlanningScore, PyPlanningVariable,
+    PyPreviousElementShadowVariable, PyProblemFactCollectionProperty, PyProblemFactProperty,
+    PyValueRangeProvider,
+};
+pub use bridge::{PyBridge, PythonBridge};
+pub use collectors::{PyCollector, PyConstraintCollectors};
+pub use decorators::{PyConstraintProvider, PyDomainClass, PyDomainModel};
+pub use joiners::{PyJoiner, PyJoiners};
+pub use lambda_analyzer::{analyze_lambda, generate_lambda_name, LambdaInfo};
+pub use score::{PyHardMediumSoftScore, PyHardSoftScore, PySimpleScore};
+pub use solver::{
+    PyDiminishedReturnsConfig, PyEnvironmentMode, PyMoveThreadCount, PySolveHandle,
+    PySolveResponse, PySolveStatus, PySolver, PySolverConfig, PySolverFactory, PyTerminationConfig,
+};
+pub use stream::{
+    PyBiConstraintBuilder, PyBiConstraintStream, PyConstraint, PyConstraintFactory,
+    PyTriConstraintBuilder, PyTriConstraintStream, PyUniConstraintBuilder, PyUniConstraintStream,
+};
+
+/// SolverForge Python module
+///
+/// Provides constraint solving capabilities with an API compatible with Timefold.
+#[pymodule]
+fn _solverforge(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    // Version info
+    m.add("__version__", env!("CARGO_PKG_VERSION"))?;
+
+    // Bridge for Python-Rust object interop
+    m.add_class::<PyBridge>()?;
+
+    // Annotation marker classes
+    annotations::register_annotations(m)?;
+
+    // Score types
+    score::register_scores(m)?;
+
+    // Decorators
+    decorators::register_decorators(m)?;
+
+    // Constraint streams
+    stream::register_streams(m)?;
+
+    // Joiners
+    joiners::register_joiners(m)?;
+
+    // Collectors
+    collectors::register_collectors(m)?;
+
+    // Solver
+    solver::register_solver(m)?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Verify that all solver runtime types are accessible from lib.rs exports
+    #[test]
+    fn test_solver_runtime_types_exported() {
+        // These type assertions verify the types are publicly re-exported
+        fn assert_type<T>() {}
+
+        assert_type::<PySolverConfig>();
+        assert_type::<PyTerminationConfig>();
+        assert_type::<PySolverFactory>();
+        assert_type::<PySolver>();
+        assert_type::<PySolveHandle>();
+        assert_type::<PySolveResponse>();
+        assert_type::<PySolveStatus>();
+        assert_type::<PyEnvironmentMode>();
+        assert_type::<PyMoveThreadCount>();
+        assert_type::<PyDiminishedReturnsConfig>();
+    }
+
+    /// Verify that all constraint stream types are accessible
+    #[test]
+    fn test_constraint_stream_types_exported() {
+        fn assert_type<T>() {}
+
+        assert_type::<PyConstraintFactory>();
+        assert_type::<PyUniConstraintStream>();
+        assert_type::<PyBiConstraintStream>();
+        assert_type::<PyTriConstraintStream>();
+        assert_type::<PyUniConstraintBuilder>();
+        assert_type::<PyBiConstraintBuilder>();
+        assert_type::<PyTriConstraintBuilder>();
+        assert_type::<PyConstraint>();
+    }
+
+    /// Verify that joiner types are accessible
+    #[test]
+    fn test_joiner_types_exported() {
+        fn assert_type<T>() {}
+
+        assert_type::<PyJoiner>();
+        assert_type::<PyJoiners>();
+    }
+
+    /// Verify that collector types are accessible
+    #[test]
+    fn test_collector_types_exported() {
+        fn assert_type<T>() {}
+
+        assert_type::<PyCollector>();
+        assert_type::<PyConstraintCollectors>();
+    }
+
+    /// Verify that decorator types are accessible
+    #[test]
+    fn test_decorator_types_exported() {
+        fn assert_type<T>() {}
+
+        assert_type::<PyConstraintProvider>();
+        assert_type::<PyDomainClass>();
+        assert_type::<PyDomainModel>();
+    }
+
+    /// Verify that score types are accessible
+    #[test]
+    fn test_score_types_exported() {
+        fn assert_type<T>() {}
+
+        assert_type::<PySimpleScore>();
+        assert_type::<PyHardSoftScore>();
+        assert_type::<PyHardMediumSoftScore>();
+    }
+
+    /// Verify that annotation types are accessible
+    #[test]
+    fn test_annotation_types_exported() {
+        fn assert_type<T>() {}
+
+        assert_type::<PyPlanningId>();
+        assert_type::<PyPlanningVariable>();
+        assert_type::<PyPlanningListVariable>();
+        assert_type::<PyPlanningScore>();
+        assert_type::<PyValueRangeProvider>();
+        assert_type::<PyProblemFactProperty>();
+        assert_type::<PyProblemFactCollectionProperty>();
+        assert_type::<PyPlanningEntityProperty>();
+        assert_type::<PyPlanningEntityCollectionProperty>();
+        assert_type::<PyPlanningPin>();
+        assert_type::<PyInverseRelationShadowVariable>();
+        assert_type::<PyPreviousElementShadowVariable>();
+        assert_type::<PyNextElementShadowVariable>();
+        assert_type::<PyCascadingUpdateShadowVariable>();
+        assert_type::<PyDeepPlanningClone>();
+    }
+}

solverforge-0.2.2/solverforge-python/src/lib.rs

@@ -1,72 +0,0 @@
-//! Python bindings for SolverForge constraint solver
-//!
-//! This crate provides Python bindings using PyO3, offering a 1:1 compatible API
-//! with Timefold's Python bindings.
-
-use pyo3::prelude::*;
-
-mod annotations;
-mod bridge;
-mod collectors;
-mod decorators;
-mod joiners;
-mod lambda_analyzer;
-mod score;
-mod solver;
-mod stream;
-
-pub use annotations::{
-    PyDeepPlanningClone, PyInverseRelationShadowVariable, PyPlanningEntityCollectionProperty,
-    PyPlanningEntityProperty, PyPlanningId, PyPlanningListVariable, PyPlanningPin, PyPlanningScore,
-    PyPlanningVariable, PyProblemFactCollectionProperty, PyProblemFactProperty,
-    PyValueRangeProvider,
-};
-pub use bridge::{PyBridge, PythonBridge};
-pub use collectors::{PyCollector, PyConstraintCollectors};
-pub use decorators::{PyConstraintProvider, PyDomainClass, PyDomainModel};
-pub use joiners::{PyJoiner, PyJoiners};
-pub use lambda_analyzer::{analyze_lambda, generate_lambda_name, LambdaInfo};
-pub use score::{PyHardMediumSoftScore, PyHardSoftScore, PySimpleScore};
-pub use solver::{
-    PyDiminishedReturnsConfig, PyEnvironmentMode, PyMoveThreadCount, PySolveHandle,
-    PySolveResponse, PySolveStatus, PySolver, PySolverConfig, PySolverFactory, PyTerminationConfig,
-};
-pub use stream::{
-    PyBiConstraintBuilder, PyBiConstraintStream, PyConstraint, PyConstraintFactory,
-    PyTriConstraintBuilder, PyTriConstraintStream, PyUniConstraintBuilder, PyUniConstraintStream,
-};
-
-/// SolverForge Python module
-///
-/// Provides constraint solving capabilities with an API compatible with Timefold.
-#[pymodule]
-fn _solverforge(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    // Version info
-    m.add("__version__", env!("CARGO_PKG_VERSION"))?;
-
-    // Bridge for Python-Rust object interop
-    m.add_class::<PyBridge>()?;
-
-    // Annotation marker classes
-    annotations::register_annotations(m)?;
-
-    // Score types
-    score::register_scores(m)?;
-
-    // Decorators
-    decorators::register_decorators(m)?;
-
-    // Constraint streams
-    stream::register_streams(m)?;
-
-    // Joiners
-    joiners::register_joiners(m)?;
-
-    // Collectors
-    collectors::register_collectors(m)?;
-
-    // Solver
-    solver::register_solver(m)?;
-
-    Ok(())
-}