solverforge 0.6.12__tar.gz → 0.6.13__tar.gz

{solverforge-0.6.12 → solverforge-0.6.13}/Cargo.lock

@@ -644,7 +644,7 @@ dependencies = [
 
 [[package]]
 name = "solverforge_py"
-version = "0.6.12"
+version = "0.6.13"
 dependencies = [
  "indexmap",
  "once_cell",

{solverforge-0.6.12 → solverforge-0.6.13}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solverforge_py"
-version = "0.6.12"
+version = "0.6.13"
 edition = "2021"
 license = "Apache-2.0"
 rust-version = "1.95"

{solverforge-0.6.12 → solverforge-0.6.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solverforge
-Version: 0.6.12
+Version: 0.6.13
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -51,12 +51,12 @@ requirements, and other APIs that are not part of this package.
 
 ## Installation
 
-The package version prepared by this checkout is `solverforge` `0.6.12`, targeting
+The package version prepared by this checkout is `solverforge` `0.6.13`, targeting
 the published and registry-locked SolverForge Rust `0.21.2` dependency base.
 Install the matching package after its Python release with:
 
 ```sh
-python3.14 -m pip install "solverforge==0.6.12"
+python3.14 -m pip install "solverforge==0.6.13"
 ```
 
 The installable wheel contains the core `solverforge` package, native extension,
@@ -76,12 +76,12 @@ make deliveries-run PORT=7861
 ```
 
 The same source-checkout examples can be run against the matching published
-package once `0.6.12` is released, without `PYTHONPATH` or an editable checkout:
+package once `0.6.13` is released, without `PYTHONPATH` or an editable checkout:
 
 ```sh
 python3.14 -m venv .venv-examples
 . .venv-examples/bin/activate
-python -m pip install "solverforge[examples]==0.6.12"
+python -m pip install "solverforge[examples]==0.6.13"
 python examples/nqueens.py
 python -m examples.solverforge_hospital
 python -m examples.solverforge_deliveries

{solverforge-0.6.12 → solverforge-0.6.13}/README.md

@@ -20,12 +20,12 @@ requirements, and other APIs that are not part of this package.
 
 ## Installation
 
-The package version prepared by this checkout is `solverforge` `0.6.12`, targeting
+The package version prepared by this checkout is `solverforge` `0.6.13`, targeting
 the published and registry-locked SolverForge Rust `0.21.2` dependency base.
 Install the matching package after its Python release with:
 
 ```sh
-python3.14 -m pip install "solverforge==0.6.12"
+python3.14 -m pip install "solverforge==0.6.13"
 ```
 
 The installable wheel contains the core `solverforge` package, native extension,
@@ -45,12 +45,12 @@ make deliveries-run PORT=7861
 ```
 
 The same source-checkout examples can be run against the matching published
-package once `0.6.12` is released, without `PYTHONPATH` or an editable checkout:
+package once `0.6.13` is released, without `PYTHONPATH` or an editable checkout:
 
 ```sh
 python3.14 -m venv .venv-examples
 . .venv-examples/bin/activate
-python -m pip install "solverforge[examples]==0.6.12"
+python -m pip install "solverforge[examples]==0.6.13"
 python examples/nqueens.py
 python -m examples.solverforge_hospital
 python -m examples.solverforge_deliveries

{solverforge-0.6.12 → solverforge-0.6.13}/pyproject.toml

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

{solverforge-0.6.12 → solverforge-0.6.13}/python/solverforge/__init__.py

@@ -41,7 +41,7 @@ from .manager import JobHandle, SolverManager
 from .score import HardMediumSoftScore, HardSoftDecimalScore, HardSoftScore, SoftScore
 from .solver import Solver
 
-__version__ = "0.6.12"
+__version__ = "0.6.13"
 
 __all__ = [
     "CallbackError",

{solverforge-0.6.12 → solverforge-0.6.13}/src/runtime/dynamic_assignment_group.rs

@@ -123,7 +123,6 @@ fn build_assignment_group(
     let metadata = Arc::new(PyDynamicAssignmentMetadata {
         schema,
         group_index,
-        entity_index,
     });
     Ok(ScalarGroupBinding::dynamic_assignment(
         intern(group.name.clone()),
@@ -146,7 +145,6 @@ fn scalar_group_limits(group: &AssignmentScalarGroupSchema) -> ScalarGroupLimits
 struct PyDynamicAssignmentMetadata {
     schema: Arc<DynamicSchema>,
     group_index: usize,
-    entity_index: usize,
 }
 
 impl PyDynamicAssignmentMetadata {
@@ -182,10 +180,16 @@ impl PyDynamicAssignmentMetadata {
         };
         solution
             .state
-            .entities
-            .get(self.entity_index)
+            .assignment_group_fields
+            .get(self.group_index)
             .and_then(|rows| rows.get(entity_index))
-            .and_then(|row| row.fields.get(field_name))
+            .and_then(|fields| match hook_name {
+                "required_entity" => fields.required_entity.as_ref(),
+                "capacity_key" => fields.capacity_key.as_ref(),
+                "position_key" => fields.position_key.as_ref(),
+                "sequence_key" => fields.sequence_key.as_ref(),
+                _ => unreachable!("assignment metadata source resolved"),
+            })
             .map(Some)
             .ok_or_else(|| {
                 py_err(format!(
@@ -420,10 +424,10 @@ impl PyDynamicAssignmentMetadata {
     ) -> PyResult<bool> {
         let value = solution
             .state
-            .entities
-            .get(self.entity_index)
+            .assignment_group_fields
+            .get(self.group_index)
             .and_then(|rows| rows.get(entity_index))
-            .and_then(|row| row.fields.get(field_name))
+            .and_then(|fields| fields.same_value_conflicts.as_ref())
             .ok_or_else(|| {
                 py_err(format!(
                     "assignment scalar group `{}` field `{field_name}` is missing on row {entity_index}",
@@ -547,3 +551,93 @@ fn indexed_usize(field_value: &DynamicValue, candidate_value: usize) -> PyResult
         )),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use pyo3::ffi::c_str;
+
+    use super::*;
+    use crate::schema::parse::parse_schema;
+    use crate::schema::runtime_plan::CompiledRuntimePlan;
+    use crate::state::callback_view::PythonCallbackView;
+    use crate::state::entity_table::{AssignmentRowFields, DynamicEntityRow, DynamicState};
+
+    #[test]
+    fn assignment_access_uses_imported_slots_not_named_row_fields() {
+        Python::initialize();
+        Python::attach(|py| {
+            let raw = py
+                .eval(
+                    c_str!(
+                        r#"{
+                'solution_type': 'Plan', 'score_family': 'hard_soft',
+                'entities': [{'type_name': 'Task', 'collection': 'tasks', 'fields': [
+                    {'name': 'value', 'kind': 'planning_variable', 'allows_unassigned': True}
+                ]}],
+                'constraints': [], 'conflict_repairs': [], 'candidate_metrics': [],
+                'scalar_groups': [{'kind': 'assignment', 'name': 'assign',
+                    'entity_class': 'Task', 'variable_name': 'value',
+                    'required_entity_field': 'required', 'capacity_key_field': 'capacity',
+                    'position_key_field': 'position', 'sequence_key_field': 'sequence',
+                    'same_value_conflict_field': 'conflicts'}]
+            }"#
+                    ),
+                    None,
+                    None,
+                )
+                .unwrap();
+            let schema = Arc::new(parse_schema(raw.cast().unwrap()).unwrap());
+            let plan = Arc::new(CompiledRuntimePlan::from_schema(Arc::clone(&schema)).unwrap());
+            let metadata = PyDynamicAssignmentMetadata {
+                schema,
+                group_index: 0,
+            };
+            let state = DynamicState {
+                entities: vec![vec![DynamicEntityRow::default(); 2]],
+                assignment_group_fields: Arc::new(vec![vec![
+                    AssignmentRowFields {
+                        required_entity: Some(DynamicValue::Bool(true)),
+                        capacity_key: Some(DynamicValue::List(vec![
+                            DynamicValue::Int(7),
+                            DynamicValue::None,
+                        ])),
+                        position_key: Some(DynamicValue::Int(13)),
+                        sequence_key: Some(DynamicValue::Int(5)),
+                        same_value_conflicts: Some(DynamicValue::List(vec![DynamicValue::Int(1)])),
+                    },
+                    AssignmentRowFields {
+                        required_entity: Some(DynamicValue::Bool(false)),
+                        same_value_conflicts: Some(DynamicValue::List(Vec::new())),
+                        ..AssignmentRowFields::default()
+                    },
+                ]]),
+                ..DynamicState::default()
+            };
+            let solution = PyDynamicSolution::from_runtime_plan(
+                plan,
+                state,
+                PythonCallbackView::default(),
+                None,
+                SolverConfig::default(),
+                0,
+            );
+            let cloned = solution.clone();
+            assert!(Arc::ptr_eq(
+                &solution.state.assignment_group_fields,
+                &cloned.state.assignment_group_fields
+            ));
+            for state in [&solution, &cloned] {
+                assert!(state.state.entities[0][0].fields.is_empty());
+                assert!(metadata.required_entity(state, 0));
+                assert!(!metadata.required_entity(state, 1));
+                assert_eq!(metadata.capacity_key(state, 0, 0), Some(7));
+                assert_eq!(metadata.capacity_key(state, 0, 1), None);
+                assert_eq!(metadata.position_key(state, 0), Some(13));
+                assert_eq!(metadata.sequence_key(state, 0, 0), Some(5));
+                assert!(!metadata.assignment_edge_allowed(state, 0, 0, 1, 0));
+                assert!(!metadata.assignment_edge_allowed(state, 1, 0, 0, 0));
+                assert!(metadata.assignment_edge_allowed(state, 0, 0, 1, 1));
+            }
+        });
+    }
+}

{solverforge-0.6.12 → solverforge-0.6.13}/src/state/entity_table.rs

@@ -3,6 +3,19 @@ use std::sync::Arc;
 
 use crate::value::DynamicValue;
 
+/// Immutable assignment row sources, resolved by group and hook once at import.
+/// State clones share these values; planning-variable changes never rewrite them.
+pub type AssignmentGroupFields = Vec<Vec<AssignmentRowFields>>;
+
+#[derive(Debug, Clone, Default)]
+pub struct AssignmentRowFields {
+    pub required_entity: Option<DynamicValue>,
+    pub capacity_key: Option<DynamicValue>,
+    pub position_key: Option<DynamicValue>,
+    pub sequence_key: Option<DynamicValue>,
+    pub same_value_conflicts: Option<DynamicValue>,
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct DynamicState {
     pub entities: Vec<Vec<DynamicEntityRow>>,
@@ -10,6 +23,7 @@ pub struct DynamicState {
     pub scalar_value_ranges: Vec<Vec<Option<Arc<[usize]>>>>,
     pub list_elements: Vec<Vec<Option<Arc<[usize]>>>>,
     pub solution_fields: Arc<BTreeMap<String, DynamicValue>>,
+    pub assignment_group_fields: Arc<AssignmentGroupFields>,
 }
 
 impl DynamicState {

{solverforge-0.6.12 → solverforge-0.6.13}/src/state/marshal.rs

@@ -12,7 +12,9 @@ use crate::schema::types::{
 };
 use crate::schema::DynamicSchema;
 use crate::state::callback_view::PythonCallbackView;
-use crate::state::entity_table::{DynamicEntityRow, DynamicState};
+use crate::state::entity_table::{
+    AssignmentGroupFields, AssignmentRowFields, DynamicEntityRow, DynamicState,
+};
 use crate::state::PyDynamicSolution;
 use crate::value::DynamicValue;
 
@@ -148,6 +150,7 @@ pub fn import_solution(
         fact_objects.push(objects);
     }
     validate_assignment_group_field_metadata(schema, &entity_tables)?;
+    let assignment_group_fields = resolve_assignment_group_fields(schema, &entity_tables)?;
     validate_list_element_metadata_field_sources(
         schema,
         &entity_tables,
@@ -163,6 +166,7 @@ pub fn import_solution(
             scalar_value_ranges,
             list_elements,
             solution_fields: Arc::new(solution_fields),
+            assignment_group_fields: Arc::new(assignment_group_fields),
         },
         PythonCallbackView::from_import(
             py_solution.clone().unbind(),
@@ -484,6 +488,57 @@ fn collect_list_metadata_row_fields(
     }
 }
 
+fn resolve_assignment_group_fields(
+    schema: &DynamicSchema,
+    entity_tables: &[Vec<DynamicEntityRow>],
+) -> PyResult<AssignmentGroupFields> {
+    schema
+        .assignment_scalar_groups
+        .iter()
+        .map(|group| {
+            let entity_index = schema
+                .entity_index_by_type(&group.entity_class)
+                .expect("assignment group entity validated");
+            let fields = [
+                group
+                    .required_entity
+                    .as_ref()
+                    .and_then(MetadataSourceSchema::row),
+                group
+                    .capacity_key
+                    .as_ref()
+                    .and_then(MetadataSourceSchema::row),
+                group
+                    .position_key
+                    .as_ref()
+                    .and_then(MetadataSourceSchema::row),
+                group
+                    .sequence_key
+                    .as_ref()
+                    .and_then(MetadataSourceSchema::row),
+                group.same_value_conflict_field.as_deref(),
+            ];
+            entity_tables[entity_index]
+                .iter()
+                .enumerate()
+                .map(|(row_index, row)| {
+                    let mut resolved = std::array::from_fn(|_| None);
+                    for (index, field) in fields.iter().enumerate() {
+                        if let Some(field) = field {
+                            resolved[index] = Some(
+                                assignment_metadata_field(row, &group.name, row_index, field)?
+                                    .clone(),
+                            );
+                        }
+                    }
+                    let [required_entity, capacity_key, position_key, sequence_key, same_value_conflicts] = resolved;
+                    Ok(AssignmentRowFields { required_entity, capacity_key, position_key, sequence_key, same_value_conflicts })
+                })
+                .collect()
+        })
+        .collect()
+}
+
 fn validate_assignment_group_field_metadata(
     schema: &DynamicSchema,
     entity_tables: &[Vec<DynamicEntityRow>],