feat: add proper __repr__ for criteria / combinations

Author: glichtner

execution_engine/constants.py

@@ -46,7 +46,7 @@ def __repr__(self) -> str:
         """
         Get the string representation of the category.
         """
-        return str(self)
+        return f"{self.__class__.__name__}.{self.name}"
 
     def __str__(self) -> str:
         """

execution_engine/omop/concepts.py

@@ -19,7 +19,7 @@ def from_series(series: pd.Series) -> "Concept":
         """Creates a concept from a pandas Series."""
         return Concept(**series.to_dict())
 
-    def __repr__(self) -> str:
+    def __str__(self) -> str:
         """
         Returns a string representation of the concept.
         """
@@ -30,14 +30,14 @@ def __repr__(self) -> str:
 
         return base
 
-    def __str__(self) -> str:
-        """
-        Returns a string representation of the concept.
-        """
-        if self.vocabulary_id == "UCUM":
-            return str(self.concept_code)
-
-        return str(self.concept_name)
+    # def __str__(self) -> str:
+    #     """
+    #     Returns a string representation of the concept.
+    #     """
+    #     if self.vocabulary_id == "UCUM":
+    #         return str(self.concept_code)
+    #
+    #     return str(self.concept_name)
 
     def is_custom(self) -> bool:
         """

execution_engine/omop/criterion/abstract.py

@@ -11,6 +11,7 @@
 
 from execution_engine.constants import CohortCategory
 from execution_engine.omop.concepts import Concept
+from execution_engine.omop.criterion.meta import SignatureReprABCMeta
 from execution_engine.omop.db.base import DateTimeWithTimeZone
 from execution_engine.omop.db.celida.tables import IntervalTypeEnum, ResultInterval
 from execution_engine.omop.db.omop.tables import (
@@ -88,15 +89,12 @@ def create_conditional_interval_column(condition: ColumnElement) -> ColumnElemen
     )
 
 
-class AbstractCriterion(Serializable, ABC):
+class AbstractCriterion(Serializable, ABC, metaclass=SignatureReprABCMeta):
     """
     Abstract base class for Criterion and CriterionCombination.
     """
 
-    def __init__(
-        self, category: CohortCategory, id: int | None = None
-    ) -> None:
-        self._id = id
+    def __init__(self, category: CohortCategory) -> None:
 
         assert isinstance(
             category, CohortCategory
@@ -129,12 +127,6 @@ def description(self) -> str:
         """
         raise NotImplementedError()
 
-    def __repr__(self) -> str:
-        """
-        Get the representation of the criterion.
-        """
-        return f"{self.type}.{self._category.name}.{self.description()}"
-
     def __str__(self) -> str:
         """
         Get the name of the criterion.
@@ -212,10 +204,8 @@ class Criterion(AbstractCriterion):
     Flag to indicate whether the filter_datetime function has been called.
     """
 
-    def __init__(
-        self, category: CohortCategory, id: int | None = None
-    ) -> None:
-        super().__init__(category=category, id=id)
+    def __init__(self, category: CohortCategory) -> None:
+        super().__init__(category=category)
 
     def _set_omop_variables_from_domain(self, domain_id: str) -> None:
         """

execution_engine/omop/criterion/combination/logical.py

@@ -147,6 +147,39 @@ def AllOrNone(
             criteria=criteria,
         )
 
+    def _repr_pretty(self, level: int = 0) -> str:
+        def snake_to_camel(s: str) -> str:
+            return "".join(word.capitalize() for word in s.lower().split("_"))
+
+        indent = " " * (2 * level)
+        op = snake_to_camel(self.operator.operator)
+
+        lines = []
+        # Opening line
+        lines.append(f"{indent}{self.__class__.__name__}.{op}(")
+
+        # Each child on its own line, indented by level+1
+        for c in self._criteria:
+            if hasattr(c, "_repr_pretty"):
+                # Assume c is another Combination or something that implements _repr_pretty
+                lines.append(c._repr_pretty(level + 1) + ",")
+            else:
+                # If it's a leaf object (e.g. a ConceptCriterion), just call normal repr
+                child_indent = " " * (2 * (level + 1))
+                lines.append(f"{child_indent}{repr(c)},")
+
+        # Closing parenthesis at the current indent level
+        lines.append(f"{indent})")
+
+        # Join all lines with newlines
+        return "\n".join(lines)
+
+    def __repr__(self) -> str:
+        """
+        Get the string representation of the criterion combination.
+        """
+        return self._repr_pretty(0)
+
 
 class NonCommutativeLogicalCriterionCombination(LogicalCriterionCombination):
     """

execution_engine/omop/criterion/concept.py

@@ -1,11 +1,11 @@
-from abc import ABC
 from typing import Any, Dict, cast
 
 from sqlalchemy.sql import Select
 
 from execution_engine.constants import CohortCategory, OMOPConcepts
 from execution_engine.omop.concepts import Concept
 from execution_engine.omop.criterion.abstract import Criterion
+from execution_engine.omop.criterion.meta import SignatureReprMeta
 from execution_engine.util.types import Timing
 from execution_engine.util.value import Value
 from execution_engine.util.value.factory import value_factory
@@ -25,7 +25,7 @@
 # TODO: Only use weight etc from the current encounter/visit!
 
 
-class ConceptCriterion(Criterion, ABC):
+class ConceptCriterion(Criterion, metaclass=SignatureReprMeta):
     """
     Abstract class for a criterion based on an OMOP concept and optional value.
 
@@ -43,13 +43,12 @@ def __init__(
         self,
         category: CohortCategory,
         concept: Concept,
-        id: int | None = None,
         value: Value | None = None,
         static: bool | None = None,
         timing: Timing | None = None,
         override_value_required: bool | None = None,
     ):
-        super().__init__(category=category, id=id)
+        super().__init__(category=category)
 
         self._set_omop_variables_from_domain(concept.domain_id)
         self._concept = concept

execution_engine/omop/criterion/meta.py

@@ -0,0 +1,129 @@
+import abc
+import inspect
+from typing import Any, Type, TypeVar
+
+T = TypeVar("T", bound="SignatureReprMeta")
+
+
+class SignatureReprMeta(type):
+    """
+    A metaclass that automatically captures constructor arguments and generates a __repr__ method.
+
+    This metaclass wraps the `__init__` method of a class to store the arguments passed at instantiation,
+    allowing `__repr__` to dynamically generate an informative string representation, omitting default values.
+
+    Features:
+    - Captures constructor arguments at instantiation time (`self._init_args`).
+    - Automatically generates a `__repr__` if the class does not define one.
+    - Ensures that `__repr__` only displays arguments that differ from the default values.
+    - Prevents redundant re-capturing when a parent class’s `__init__` is invoked via `super()`.
+    - Retains the original `__init__` function signature for accurate introspection.
+
+    Usage:
+    ```python
+    class MyClass(metaclass=SignatureReprMeta):
+        def __init__(self, x, y=10, z=None):
+            self.x = x
+            self.y = y
+            self.z = z
+
+    obj = MyClass(5, z="test")
+    print(obj)  # Output: MyClass(x=5, z='test')  (y is omitted since it uses the default 10)
+    ```
+
+    """
+
+    def __new__(
+        mcs: Type[T], name: str, bases: tuple[type, ...], namespace: dict[str, Any]
+    ) -> T:
+        """
+        Wrap the __init__ method and attach a default __repr__ if not defined.
+        """
+        original_init = namespace.get("__init__")
+
+        if not original_init:
+            # Try to find an __init__ in the bases
+            for base in reversed(bases):
+                if base.__init__ is not object.__init__:
+                    original_init = base.__init__
+                    break
+
+        # We'll define a new __init__ only if there's an actual one to wrap
+        if original_init:
+
+            def __init__(self: object, *args: Any, **kwargs: Any) -> None:
+                if type(self) is cls:
+                    assert original_init is not None, "No valid __init__ found!"
+                    sig = inspect.signature(original_init)
+                    bound = sig.bind(self, *args, **kwargs)
+                    bound.apply_defaults()
+                    all_args = dict(bound.arguments)
+                    all_args.pop("self", None)
+                    self._init_args = all_args  # type: ignore[attr-defined]
+
+                original_init(self, *args, **kwargs)
+
+        # The rest is basically the same
+        # But we must create the class first so we can set new_init.__signature__ = ...
+        cls = super().__new__(mcs, name, bases, namespace)
+
+        # If we actually did define new_init, attach it
+        if original_init:
+            # Replace/attach the new __init__ to cls
+            setattr(cls, "__init__", __init__)
+
+            # Manually override the function's signature
+            init_sig = inspect.signature(original_init)
+            __init__.__signature__ = init_sig  # type: ignore[attr-defined]
+
+        # If no user-defined __repr__, attach a default
+        if "__repr__" not in namespace:
+
+            def __repr__(self: object) -> str:
+                if not hasattr(self, "_init_args"):
+                    return super(type(self), self).__repr__()
+                sig = inspect.signature(original_init) if original_init else None
+                parts = []
+                if sig:
+                    for param_name, param in sig.parameters.items():
+                        if param_name == "self":
+                            continue
+                        default = param.default
+                        # Only show params if they differ from the default
+                        if (
+                            param_name in self._init_args
+                            and self._init_args[param_name] != default
+                        ):
+                            parts.append(
+                                f"{param_name}={repr(self._init_args[param_name])}"
+                            )
+                return f"{name}({', '.join(parts)})"
+
+            setattr(cls, "__repr__", __repr__)
+
+        return cls
+
+
+class SignatureReprABCMeta(SignatureReprMeta, abc.ABCMeta):
+    """
+    A metaclass combining `SignatureReprMeta` and `ABCMeta`.
+
+    This metaclass extends `SignatureReprMeta`, allowing abstract base classes (`ABC`) to inherit
+    automatic argument capturing and dynamic `__repr__` generation.
+
+    Usage:
+    ```python
+    class AbstractExample(metaclass=SignatureReprABCMeta):
+        @abc.abstractmethod
+        def some_method(self):
+            pass
+
+    class ConcreteExample(AbstractExample):
+        def __init__(self, value, flag=True):
+            self.value = value
+            self.flag = flag
+
+    obj = ConcreteExample(42)
+    print(obj)  # Output: ConcreteExample(value=42) (flag is omitted since it uses the default True)
+    ```
+    """