feat: Add support for ConstraintConfiguration (#37)

- Remove penalize, reward, impact methods docs as
  they are out of date, will be re-added with correct info later.

Author: Christopher-Chianelli

tests/test_solver_configuration.py

@@ -0,0 +1,58 @@
+from timefold.solver.api import *
+from timefold.solver.annotation import *
+from timefold.solver.config import *
+from timefold.solver.constraint import *
+from timefold.solver.score import *
+
+from dataclasses import dataclass, field
+from typing import Annotated, List
+
+
+def test_solver_configuration():
+    @planning_entity
+    @dataclass
+    class Entity:
+        code: str
+        value: Annotated[int, PlanningVariable] = field(default=None)
+
+    @constraint_provider
+    def my_constraints(constraint_factory: ConstraintFactory):
+        return [
+            constraint_factory.for_each(Entity)
+                              .reward_configurable(lambda entity: entity.value)
+                              .as_constraint('Maximize value'),
+        ]
+
+    @constraint_configuration
+    @dataclass
+    class ConstraintConfiguration:
+        maximize_value: Annotated[SimpleScore, ConstraintWeight('Maximize value')] = field(default=SimpleScore.ONE)
+
+    @planning_solution
+    @dataclass
+    class Solution:
+        entities: Annotated[List[Entity], PlanningEntityCollectionProperty]
+        value_range: Annotated[List[int], ValueRangeProvider]
+        score: Annotated[SimpleScore, PlanningScore] = field(default=None)
+        configuration: Annotated[ConstraintConfiguration, ConstraintConfigurationProvider] = (
+            field(default_factory=ConstraintConfiguration))
+
+    solver_config = SolverConfig(
+        solution_class=Solution,
+        entity_class_list=[Entity],
+        score_director_factory_config=ScoreDirectorFactoryConfig(
+            constraint_provider_function=my_constraints,
+        ),
+        termination_config=TerminationConfig(
+            best_score_limit='6'
+        )
+    )
+
+    problem: Solution = Solution([Entity('A')], [1, 2, 3],
+                                 configuration=ConstraintConfiguration(maximize_value=SimpleScore.of(2)))
+
+    solver = SolverFactory.create(solver_config).build_solver()
+    solution = solver.solve(problem)
+
+    assert solution.score.score() == 6
+    assert solution.entities[0].value == 3

timefold-solver-python-core/src/main/python/annotation/_annotations.py

@@ -194,6 +194,24 @@ def __init__(self):
         super().__init__(JavaDeepPlanningClone, {})
 
 
+class ConstraintConfigurationProvider(JavaAnnotation):
+    def __init__(self):
+        ensure_init()
+        from ai.timefold.solver.core.api.domain.constraintweight import (
+            ConstraintConfigurationProvider as JavaConstraintConfigurationProvider)
+        super().__init__(JavaConstraintConfigurationProvider, {})
+
+
+class ConstraintWeight(JavaAnnotation):
+    def __init__(self, constraint_name: str, *, constraint_package: str = None):
+        ensure_init()
+        from ai.timefold.solver.core.api.domain.constraintweight import ConstraintWeight as JavaConstraintWeight
+        super().__init__(JavaConstraintWeight, {
+            'value': constraint_name,
+            'constraintPackage': constraint_package
+        })
+
+
 @JImplements('ai.timefold.solver.core.api.domain.entity.PinningFilter', deferred=True)
 class _PythonPinningFilter:
     def __init__(self, delegate):
@@ -301,6 +319,15 @@ def __init__(self, a_list):
     return out
 
 
+def constraint_configuration(constraint_configuration_class: Type[Solution_]) -> Type[Solution_]:
+    ensure_init()
+    from jpyinterpreter import add_class_annotation
+    from ai.timefold.solver.core.api.domain.constraintweight import (
+        ConstraintConfiguration as JavaConstraintConfiguration)
+    out = add_class_annotation(JavaConstraintConfiguration)(constraint_configuration_class)
+    return out
+
+
 def nearby_distance_meter(distance_function: Callable[[Origin_, Destination_], float], /) \
         -> Callable[[Origin_, Destination_], float]:
     ensure_init()
@@ -575,8 +602,9 @@ def wrapper_doChange(self, solution, problem_change_director):
            'IndexShadowVariable', 'AnchorShadowVariable', 'InverseRelationShadowVariable',
            'ProblemFactProperty', 'ProblemFactCollectionProperty',
            'PlanningEntityProperty', 'PlanningEntityCollectionProperty',
-           'ValueRangeProvider', 'DeepPlanningClone',
-           'planning_entity', 'planning_solution',
+           'ValueRangeProvider', 'DeepPlanningClone', 'ConstraintConfigurationProvider',
+           'ConstraintWeight',
+           'planning_entity', 'planning_solution', 'constraint_configuration',
            'nearby_distance_meter',
            'constraint_provider', 'easy_score_calculator', 'incremental_score_calculator',
            'variable_listener', 'problem_change']