feat: sync ConstraintRef API

Author: zepfred

tests/test_solution_manager.py

@@ -220,6 +220,13 @@ def test_score_manager_constraint_analysis_map():
     assert constraint_analysis.match_count == 3
 
 
+def test_score_manager_constraint_ref():
+    constraint_ref = ConstraintRef.parse_id('package/Maximize Value')
+
+    assert constraint_ref.package_name == 'package'
+    assert constraint_ref.constraint_name == 'Maximize Value'
+
+
 ignored_java_functions = {
     'equals',
     'getClass',
@@ -232,7 +239,8 @@ def test_score_manager_constraint_analysis_map():
 }
 
 ignored_java_functions_per_class = {
-    'Indictment': {'getJustification'}  # deprecated
+    'Indictment': {'getJustification'},  # deprecated
+    'ConstraintRef': {'of', 'packageName', 'constraintName'}  # built-in constructor and properties with @dataclass
 }
 
 
@@ -242,6 +250,7 @@ def test_has_all_methods():
                                    (ScoreAnalysis, JavaScoreAnalysis),
                                    (ConstraintAnalysis, JavaConstraintAnalysis),
                                    (ScoreExplanation, JavaScoreExplanation),
+                                   (ConstraintRef, JavaConstraintRef),
                                    (Indictment, JavaIndictment)):
         type_name = python_type.__name__
         ignored_java_functions_type = ignored_java_functions_per_class[

timefold-solver-python-core/src/main/java/ai/timefold/solver/python/score/constraint/ConstraintRefPythonJavaTypeMapping.java

@@ -0,0 +1,60 @@
+package ai.timefold.solver.python.score.constraint;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+
+import ai.timefold.jpyinterpreter.PythonLikeObject;
+import ai.timefold.jpyinterpreter.types.PythonJavaTypeMapping;
+import ai.timefold.jpyinterpreter.types.PythonLikeType;
+import ai.timefold.jpyinterpreter.types.PythonString;
+import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
+
+public final class ConstraintRefPythonJavaTypeMapping implements PythonJavaTypeMapping<PythonLikeObject, ConstraintRef> {
+    private final PythonLikeType type;
+    private final Constructor<?> constructor;
+    private final Field packageNameField;
+    private final Field constraintNameField;
+
+    public ConstraintRefPythonJavaTypeMapping(PythonLikeType type)
+            throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
+        this.type = type;
+        Class<?> clazz = type.getJavaClass();
+        constructor = clazz.getConstructor();
+        packageNameField = clazz.getField("package_name");
+        constraintNameField = clazz.getField("constraint_name");
+    }
+
+    @Override
+    public PythonLikeType getPythonType() {
+        return type;
+    }
+
+    @Override
+    public Class<? extends ConstraintRef> getJavaType() {
+        return ConstraintRef.class;
+    }
+
+    @Override
+    public PythonLikeObject toPythonObject(ConstraintRef javaObject) {
+        try {
+            var instance = constructor.newInstance();
+            packageNameField.set(instance, PythonString.valueOf(javaObject.packageName()));
+            constraintNameField.set(instance, PythonString.valueOf(javaObject.constraintName()));
+            return (PythonLikeObject) instance;
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public ConstraintRef toJavaObject(PythonLikeObject pythonObject) {
+        try {
+            var packageName = ((PythonString) packageNameField.get(pythonObject)).value.toString();
+            var constraintName = ((PythonString) constraintNameField.get(pythonObject)).value.toString();
+            return ConstraintRef.of(packageName, constraintName);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

timefold-solver-python-core/src/main/python/_timefold_java_interop.py

@@ -98,13 +98,14 @@ def update_log_level() -> None:
     PythonLoggingToLogbackAdapter.setLevel(logger.getEffectiveLevel())
 
 
-def register_score_python_java_type_mappings():
+def register_python_java_type_mappings():
     global _scores_registered, _java_score_mapping_dict, _python_score_mapping_dict
     if _scores_registered:
         return
 
     _scores_registered = True
 
+    # score types
     from .score._score import SimpleScore, HardSoftScore, HardMediumSoftScore, BendableScore
     from ai.timefold.solver.core.api.score.buildin.simplelong import SimpleLongScore as _SimpleScore
     from ai.timefold.solver.core.api.score.buildin.hardsoftlong import HardSoftLongScore as _HardSoftScore
@@ -137,6 +138,20 @@ def register_score_python_java_type_mappings():
     add_python_java_type_mapping(HardMediumSoftScorePythonJavaTypeMapping(HardMediumSoftScoreType))
     add_python_java_type_mapping(BendableScorePythonJavaTypeMapping(BendableScoreType))
 
+    # score analysis types
+    from .score._score_analysis import ConstraintRef
+    from ai.timefold.solver.core.api.score.constraint import ConstraintRef as _ConstraintRef
+
+    from ai.timefold.solver.python.score.constraint import ConstraintRefPythonJavaTypeMapping
+
+    _python_score_mapping_dict['ConstraintRef'] = ConstraintRef
+
+    _java_score_mapping_dict['ConstraintRef'] = _ConstraintRef
+
+    ConstraintRefType = translate_python_class_to_java_class(ConstraintRef)
+
+    add_python_java_type_mapping(ConstraintRefPythonJavaTypeMapping(ConstraintRefType))
+
 
 def forward_logging_events(event: 'PythonLoggingEvent') -> None:
     logger.log(event.level().getPythonLevelNumber(),
@@ -301,7 +316,7 @@ def _add_to_compilation_queue(python_class: type | PythonSupplier) -> None:
 def _process_compilation_queue() -> None:
     global _compilation_queue
 
-    register_score_python_java_type_mappings()
+    register_python_java_type_mappings()
     while len(_compilation_queue) > 0:
         python_class = _compilation_queue.pop(0)
 
@@ -324,7 +339,7 @@ def _generate_constraint_provider_class(original_function: Callable[['_Constrain
                                         wrapped_constraint_provider: Callable[['_ConstraintFactory'],
                                                                               list['_Constraint']]) -> JClass:
     ensure_init()
-    register_score_python_java_type_mappings()
+    register_python_java_type_mappings()
     from ai.timefold.solver.python import PythonWrapperGenerator  # noqa
     from ai.timefold.solver.core.api.score.stream import ConstraintProvider
     class_identifier = _get_class_identifier_for_object(original_function)

timefold-solver-python-core/src/main/python/score/_score_analysis.py

@@ -1,5 +1,6 @@
 from .._timefold_java_interop import get_class
 from .._jpype_type_conversions import to_python_score
+from .._timefold_java_interop import _java_score_mapping_dict
 from _jpyinterpreter import unwrap_python_like_object, add_java_interface
 from dataclasses import dataclass
 from multipledispatch import dispatch
@@ -42,17 +43,26 @@ class ConstraintRef:
         The constraint name.
         It might not be unique, but `constraint_id` is unique.
         When using a `constraint_configuration`, it is equal to the `ConstraintWeight.constraint_name`.
+
+    constraint_id : str
+        Always derived from `packageName` and `constraintName`.
     """
     package_name: str
     constraint_name: str
 
     @property
     def constraint_id(self) -> str:
-        """
-        Always derived from packageName and constraintName.
-        """
         return f'{self.package_name}/{self.constraint_name}'
 
+    @staticmethod
+    def parse_id(constraint_id: str):
+        slash_index = constraint_id.rfind('/')
+        if slash_index == -1: raise RuntimeError(
+            f'The constraint_id {constraint_id} is invalid as it does not contain a package separator \'/\'.')
+        package_name = constraint_id[:slash_index]
+        constraint_name = constraint_id[slash_index + 1:]
+        return ConstraintRef(package_name, constraint_name)
+
     @staticmethod
     def compose_constraint_id(solution_type_or_package: Union[type, str], constraint_name: str) -> str:
         """
@@ -78,6 +88,9 @@ def compose_constraint_id(solution_type_or_package: Union[type, str], constraint
         return ConstraintRef(package_name=package,
                              constraint_name=constraint_name).constraint_id
 
+    def _to_java(self):
+        return _java_score_mapping_dict['ConstraintRef'].of(self.package_name, self.constraint_name)
+
 
 def _safe_hash(obj: Any) -> int:
     try:
@@ -201,7 +214,7 @@ def _map_constraint_match_set(constraint_match_set: set['_JavaConstraintMatch'])
                                                      .getConstraintRef().constraintName()),
                         justification=_unwrap_justification(constraint_match.getJustification()),
                         indicted_objects=tuple([unwrap_python_like_object(indicted)
-                                               for indicted in cast(list, constraint_match.getIndictedObjectList())]),
+                                                for indicted in cast(list, constraint_match.getIndictedObjectList())]),
                         score=to_python_score(constraint_match.getScore())
                         )
         for constraint_match in constraint_match_set
@@ -214,7 +227,7 @@ def _unwrap_justification(justification: Any) -> ConstraintJustification:
     if isinstance(justification, _JavaDefaultConstraintJustification):
         fact_list = justification.getFacts()
         return DefaultConstraintJustification(facts=tuple([unwrap_python_like_object(fact)
-                                                          for fact in cast(list, fact_list)]),
+                                                           for fact in cast(list, fact_list)]),
                                               impact=to_python_score(justification.getImpact()))
     else:
         return unwrap_python_like_object(justification)
@@ -245,6 +258,7 @@ class Indictment(Generic[Score_]):
         in `constraint_match_set`.
 
     """
+
     def __init__(self, delegate: '_JavaIndictment[Score_]'):
         self._delegate = delegate
 
@@ -496,6 +510,7 @@ def score(self) -> Score_:
     def summarize(self) -> str:
         return self._delegate.summarize()
 
+
 class ScoreAnalysis:
     """
     Represents the breakdown of a `Score` into individual `ConstraintAnalysis` instances,
@@ -592,7 +607,7 @@ def constraint_analysis(self, constraint_package: str, constraint_name: str) ->
         return ConstraintAnalysis(self._delegate.getConstraintAnalysis(constraint_package, constraint_name))
 
     @dispatch(ConstraintRef)
-    def constraint_analysis(self, constraint_ref: ConstraintRef) -> ConstraintAnalysis:
+    def constraint_analysis(self, constraint_ref: 'ConstraintRef') -> ConstraintAnalysis:
         """
         Performs a lookup on `constraint_map`.
 
@@ -605,7 +620,7 @@ def constraint_analysis(self, constraint_ref: ConstraintRef) -> ConstraintAnalys
         ConstraintAnalysis
             None if no constraint matches of such constraint are present
         """
-        return self.constraint_analysis(constraint_ref.package_name, constraint_ref.constraint_name)
+        return ConstraintAnalysis(self._delegate.getConstraintAnalysis(constraint_ref._to_java()))
 
     @property
     def summarize(self) -> str:
@@ -615,7 +630,6 @@ def summarize(self) -> str:
     def is_solution_initialized(self) -> bool:
         return self._delegate.isSolutionInitialized()
 
-
     def diff(self, other: 'ScoreAnalysis') -> 'ScoreAnalysis':
         """
         Compare this `ScoreAnalysis to another `ScoreAnalysis`
@@ -647,9 +661,6 @@ def diff(self, other: 'ScoreAnalysis') -> 'ScoreAnalysis':
         return ScoreAnalysis(self._delegate.diff(other._delegate))
 
 
-
-
-
 __all__ = ['ScoreExplanation',
            'ConstraintRef', 'ConstraintMatch', 'ConstraintMatchTotal',
            'ConstraintJustification', 'DefaultConstraintJustification', 'Indictment',