solverforge 0.2.5__tar.gz → 0.2.6__tar.gz

{solverforge-0.2.5 → solverforge-0.2.6}/Cargo.lock

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

{solverforge-0.2.5 → solverforge-0.2.6}/Cargo.toml

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

{solverforge-0.2.5 → solverforge-0.2.6}/PKG-INFO

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

{solverforge-0.2.5 → solverforge-0.2.6}/pyproject.toml

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

{solverforge-0.2.5 → solverforge-0.2.6}/python/solverforge/__init__.py

@@ -33,6 +33,8 @@ from solverforge._solverforge import (
     HardMediumSoftScore,
     HardSoftDecimalScore,
     HardMediumSoftDecimalScore,
+    BendableScore,
+    BendableDecimalScore,
     # Decorators
     planning_entity,
     planning_solution,
@@ -105,6 +107,8 @@ __all__ = [
     "HardMediumSoftScore",
     "HardSoftDecimalScore",
     "HardMediumSoftDecimalScore",
+    "BendableScore",
+    "BendableDecimalScore",
     # Decorators
     "planning_entity",
     "planning_solution",

{solverforge-0.2.5 → solverforge-0.2.6}/solverforge-python/python/solverforge/__init__.py

@@ -33,6 +33,8 @@ from solverforge._solverforge import (
     HardMediumSoftScore,
     HardSoftDecimalScore,
     HardMediumSoftDecimalScore,
+    BendableScore,
+    BendableDecimalScore,
     # Decorators
     planning_entity,
     planning_solution,
@@ -105,6 +107,8 @@ __all__ = [
     "HardMediumSoftScore",
     "HardSoftDecimalScore",
     "HardMediumSoftDecimalScore",
+    "BendableScore",
+    "BendableDecimalScore",
     # Decorators
     "planning_entity",
     "planning_solution",

{solverforge-0.2.5 → solverforge-0.2.6}/solverforge-python/src/collectors.rs

@@ -244,6 +244,57 @@ impl PyConstraintCollectors {
         })
     }
 
+    /// Compose multiple collectors into a single result.
+    ///
+    /// # Arguments
+    /// * `collectors` - List of collectors to compose
+    /// * `combiner` - Lambda that combines the results into a single value
+    ///
+    /// # Example
+    /// ```python
+    /// ConstraintCollectors.compose(
+    ///     [ConstraintCollectors.count(), ConstraintCollectors.sum(lambda x: x.value)],
+    ///     lambda count, total: total / count if count > 0 else 0
+    /// )
+    /// ```
+    #[staticmethod]
+    fn compose(
+        py: Python<'_>,
+        collectors: Vec<PyCollector>,
+        combiner: Py<PyAny>,
+    ) -> PyResult<PyCollector> {
+        let rust_collectors: Vec<Collector> = collectors.iter().map(|c| c.to_rust()).collect();
+        let combiner_info = LambdaInfo::new(py, combiner, "compose_combiner")?;
+        Ok(PyCollector {
+            inner: Collector::compose(rust_collectors, combiner_info.to_wasm_function()),
+        })
+    }
+
+    /// Apply a collector conditionally based on a predicate.
+    ///
+    /// # Arguments
+    /// * `predicate` - Lambda that returns true if the item should be collected
+    /// * `collector` - The collector to apply when predicate is true
+    ///
+    /// # Example
+    /// ```python
+    /// ConstraintCollectors.conditionally(
+    ///     lambda shift: shift.is_overtime,
+    ///     ConstraintCollectors.count()
+    /// )
+    /// ```
+    #[staticmethod]
+    fn conditionally(
+        py: Python<'_>,
+        predicate: Py<PyAny>,
+        collector: PyCollector,
+    ) -> PyResult<PyCollector> {
+        let pred_info = LambdaInfo::new(py, predicate, "conditionally_pred")?;
+        Ok(PyCollector {
+            inner: Collector::conditionally(pred_info.to_wasm_function(), collector.to_rust()),
+        })
+    }
+
     fn __repr__(&self) -> &'static str {
         "ConstraintCollectors()"
     }
@@ -439,4 +490,42 @@ mod tests {
         let repr = collector.__repr__();
         assert!(repr.contains("Count"));
     }
+
+    #[test]
+    fn test_compose_collector() {
+        init_python();
+        Python::with_gil(|py| {
+            let locals = PyDict::new(py);
+            py.run(c"combiner = lambda a, b: a + b", None, Some(&locals))
+                .unwrap();
+            let combiner = locals.get_item("combiner").unwrap().unwrap();
+
+            let collectors = vec![
+                PyConstraintCollectors::count(),
+                PyConstraintCollectors::count_distinct(),
+            ];
+
+            let collector =
+                PyConstraintCollectors::compose(py, collectors, combiner.unbind()).unwrap();
+            let rust_collector = collector.to_rust();
+            assert!(matches!(rust_collector, Collector::Compose { .. }));
+        });
+    }
+
+    #[test]
+    fn test_conditionally_collector() {
+        init_python();
+        Python::with_gil(|py| {
+            let locals = PyDict::new(py);
+            py.run(c"pred = lambda x: x.active", None, Some(&locals))
+                .unwrap();
+            let pred = locals.get_item("pred").unwrap().unwrap();
+
+            let inner = PyConstraintCollectors::count();
+            let collector =
+                PyConstraintCollectors::conditionally(py, pred.unbind(), inner).unwrap();
+            let rust_collector = collector.to_rust();
+            assert!(matches!(rust_collector, Collector::Conditionally { .. }));
+        });
+    }
 }

{solverforge-0.2.5 → solverforge-0.2.6}/solverforge-python/src/lambda_analyzer.rs

@@ -172,7 +172,7 @@ fn analyze_lambda_bytecode(py: Python<'_>, lambda_info: &LambdaInfo) -> PyResult
             "RESUME" | "PRECALL" | "PUSH_NULL" | "COPY_FREE_VARS" | "CACHE" => {
                 // Skip these opcodes
             }
-            "LOAD_FAST" | "LOAD_FAST_CHECK" => {
+            "LOAD_FAST" | "LOAD_FAST_CHECK" | "LOAD_FAST_AND_CLEAR" => {
                 // Load a local variable (parameter) - argval is the variable name
                 // We need to find the parameter index
                 let var_name: String = argval.extract()?;
@@ -180,6 +180,29 @@ fn analyze_lambda_bytecode(py: Python<'_>, lambda_info: &LambdaInfo) -> PyResult
                 let varnames: Vec<String> = code.getattr("co_varnames")?.extract()?;
                 if let Some(idx) = varnames.iter().position(|n| n == &var_name) {
                     stack.push(BytecodeValue::Param(idx as u32));
+                } else {
+                    // Variable not in varnames - could be a closure variable
+                    return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                        "Cannot analyze lambda: unknown variable '{}'. Lambda parameters must be used directly.",
+                        var_name
+                    )));
+                }
+            }
+            "LOAD_FAST_LOAD_FAST" => {
+                // Python 3.12+ optimization: loads two variables at once
+                // argval is a tuple of two variable names like ('a', 'b')
+                let var_names: Vec<String> = argval.extract()?;
+                let code = callable.getattr("__code__")?;
+                let varnames: Vec<String> = code.getattr("co_varnames")?.extract()?;
+                for var_name in var_names {
+                    if let Some(idx) = varnames.iter().position(|n| n == &var_name) {
+                        stack.push(BytecodeValue::Param(idx as u32));
+                    } else {
+                        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                            "Cannot analyze lambda: unknown variable '{}'. Lambda parameters must be used directly.",
+                            var_name
+                        )));
+                    }
                 }
             }
             "LOAD_ATTR" | "LOAD_METHOD" => {
@@ -1361,6 +1384,79 @@ mod tests {
         });
     }
 
+    #[test]
+    fn test_analyze_bi_lambda_direct_param_add() {
+        // Tests LOAD_FAST_LOAD_FAST bytecode (Python 3.12+)
+        // This is used by compose() combiner lambdas like: lambda a, b: a + b
+        init_python();
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(c"f = lambda a, b: a + b", None, Some(&locals))
+                .unwrap();
+            let func = locals.get_item("f").unwrap().unwrap();
+
+            let info = LambdaInfo {
+                callable: func.unbind(),
+                name: "test".to_string(),
+                param_count: 2,
+                class_hint: None,
+                expression: None,
+            };
+
+            let result = analyze_lambda(py, &info).unwrap();
+
+            match result {
+                Expression::Add { left, right } => {
+                    assert!(matches!(*left, Expression::Param { index: 0 }));
+                    assert!(matches!(*right, Expression::Param { index: 1 }));
+                }
+                _ => panic!("Expected Add expression, got {:?}", result),
+            }
+        });
+    }
+
+    #[test]
+    fn test_analyze_tri_lambda_arithmetic() {
+        // Tests three-parameter lambda with arithmetic
+        init_python();
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(c"f = lambda a, b, c: a + b + c", None, Some(&locals))
+                .unwrap();
+            let func = locals.get_item("f").unwrap().unwrap();
+
+            let info = LambdaInfo {
+                callable: func.unbind(),
+                name: "test".to_string(),
+                param_count: 3,
+                class_hint: None,
+                expression: None,
+            };
+
+            let result = analyze_lambda(py, &info).unwrap();
+
+            // Should be Add(Add(a, b), c)
+            match result {
+                Expression::Add { left, right } => {
+                    // right should be Param 2 (c)
+                    assert!(matches!(*right, Expression::Param { index: 2 }));
+                    // left should be Add(a, b)
+                    match *left {
+                        Expression::Add {
+                            left: l2,
+                            right: r2,
+                        } => {
+                            assert!(matches!(*l2, Expression::Param { index: 0 }));
+                            assert!(matches!(*r2, Expression::Param { index: 1 }));
+                        }
+                        _ => panic!("Expected nested Add"),
+                    }
+                }
+                _ => panic!("Expected Add expression, got {:?}", result),
+            }
+        });
+    }
+
     #[test]
     fn test_analyze_nested_field_access() {
         init_python();