style: improve repr

Author: glichtner

execution_engine/omop/cohort/population_intervention_pair.py

@@ -60,6 +60,20 @@ def __init__(
         self.set_criteria(CohortCategory.POPULATION, population)
         self.set_criteria(CohortCategory.INTERVENTION, intervention)
 
+    def __repr__(self) -> str:
+        """
+        Get the string representation of the population/intervention pair.
+        """
+        return (
+            f"{self.__class__.__name__}(\n"
+            f"  name={self._name},\n"
+            f"  url={self._url},\n"
+            f"  base_criterion={repr(self._base_criterion)},\n"
+            f"  population={self._population._repr_pretty(level=1).strip()},\n"
+            f"  intervention={self._intervention._repr_pretty(level=1).strip()}\n"
+            f")"
+        )
+
     def set_criteria(
         self, category: CohortCategory, criteria: CriterionCombination | None
     ) -> None:

execution_engine/omop/cohort/recommendation.py

@@ -65,6 +65,30 @@ def __init__(
         # The id is used in the recommendation_id field in the result tables.
         self._id = recommendation_id
 
+    def __repr__(self) -> str:
+        """
+        Get the string representation of the recommendation.
+        """
+        pi_repr = "\n".join(
+            [("    " + line) for line in repr(self._pi_pairs).split("\n")]
+        ).strip()
+        pi_repr = (
+            pi_repr[0] + "\n    " + pi_repr[1:-2] + pi_repr[-2] + "\n  " + pi_repr[-1]
+        )
+        return (
+            f"{self.__class__.__name__}(\n"
+            f"  pi_pairs={pi_repr},\n"
+            f"  base_criterion={self._base_criterion},\n"
+            f"  name='{self._name}',\n"
+            f"  title='{self._title}',\n"
+            f"  url='{self._url}',\n"
+            f"  version='{self._version}',\n"
+            f"  description='{self._description}',\n"
+            f"  recommendation_id={self._id}\n"
+            f"  package_version='{self._package_version}',\n"
+            f")"
+        )
+
     @property
     def name(self) -> str:
         """
@@ -179,6 +203,12 @@ def population_intervention_pairs(
         """
         yield from self._pi_pairs
 
+    def __str__(self) -> str:
+        """
+        Get the string representation of the recommendation.
+        """
+        return f"Recommendation(name='{self._name}', description='{self.description}')"
+
     def __len__(self) -> int:
         """
         Get the number of population/intervention pairs.

execution_engine/omop/criterion/combination/combination.py

@@ -7,6 +7,10 @@
 __all__ = ["CriterionCombination"]
 
 
+def snake_to_camel(s: str) -> str:
+    return "".join(word.capitalize() for word in s.lower().split("_"))
+
+
 class CriterionCombination(AbstractCriterion, metaclass=ABCMeta):
     """
     Base class for a combination of criteria (temporal or logical).
@@ -35,9 +39,9 @@ def __repr__(self) -> str:
             Get the string representation of the operator.
             """
             if self.operator in ["AT_LEAST", "AT_MOST", "EXACTLY"]:
-                return f'{self.__class__.__name__}("{self.operator}", threshold={self.threshold})'
+                return f'{self.__class__.__name__}(operator="{self.operator}", threshold={self.threshold})'
             else:
-                return f'{self.__class__.__name__}("{self.operator}")'
+                return f'{self.__class__.__name__}(operator="{self.operator}")'
 
         def __eq__(self, other: object) -> bool:
             """
@@ -128,12 +132,6 @@ def __getitem__(self, index: int) -> Union[Criterion, "CriterionCombination"]:
         """
         return self._criteria[index]
 
-    def __repr__(self) -> str:
-        """
-        Get the string representation of the criterion combination.
-        """
-        return str(self)
-
     def description(self) -> str:
         """
         Description of this combination.
@@ -209,3 +207,89 @@ def from_dict(cls, data: Dict[str, Any]) -> "CriterionCombination":
             combination.add(criterion_factory(**criterion))
 
         return combination
+
+    def _build_repr(
+        self,
+        children: Sequence[tuple[str | None, Any]],
+        params: list[tuple[str, Any]],
+        level: int = 0,
+    ) -> str:
+        """
+        Builds a multi-line string for this criterion combination,
+        properly indenting each level but avoiding double-indenting if
+        a child already handles indentation in its own _repr_pretty.
+        """
+        indent = " " * (2 * level)
+        child_indent = " " * (2 * (level + 1))
+
+        op = snake_to_camel(self.operator.operator)
+
+        lines: list[str] = []
+        kw_lines: list[str] = []
+        criteria_lines: list[str] = []
+
+        method_defined = hasattr(self, op) and callable(getattr(self, op))
+
+        if self._root:
+            params.append(("root_combination", self._root))
+
+        # if there is a specific method for this operator, use it
+        if method_defined:
+            lines.append(f"{indent}{self.__class__.__name__}.{op}(")
+            if self.operator.threshold is not None:
+                params.append(("threshold", self.operator.threshold))
+        else:
+            lines.append(f"{indent}{self.__class__.__name__}(")
+            params.append(("operator", self.operator))
+
+        # Each child on its own line
+        for key, child in children:
+            if hasattr(child, "_repr_pretty"):
+                # The child already handles its own indentation and multi-line formatting.
+                child_repr = child._repr_pretty(level + 1)
+                # We'll put a comma on the last line that the child produces.
+                child_lines = child_repr.split("\n")
+                child_lines[-1] += ","  # add trailing comma to the last line
+                if key is None:
+                    criteria_lines.extend(child_lines)
+                else:
+                    # If you have a key like "left=" or "right=", prepend that to the first line
+                    # or handle it similarly. One approach is:
+                    child_lines[0] = f"{child_indent}{key}={child_lines[0].lstrip()}"
+                    criteria_lines.extend(child_lines)
+            else:
+                # Fallback to normal repr, which we indent at this level
+                child_repr = repr(child)
+                if key is None:
+                    criteria_lines.append(child_indent + child_repr + ",")
+                else:
+                    criteria_lines.append(f"{child_indent}{key}={child_repr},")
+
+        params.append(("category", self.category))
+
+        for key, value in params:
+            kw_lines.append(f"{child_indent}{key}={repr(value)},")
+
+        if method_defined:
+            lines.extend(criteria_lines)
+            lines.extend(kw_lines)
+        else:
+            lines.extend(kw_lines)
+            lines.append(f"{child_indent}criteria=[")
+            lines.extend(criteria_lines)
+            lines.append(f"{child_indent}],")
+
+        lines.append(f"{indent})")
+
+        return "\n".join(lines)
+
+    def _repr_pretty(self, level: int = 0) -> str:
+        children = [(None, c) for c in self._criteria]
+
+        return self._build_repr(children, params=[], level=level)
+
+    def __repr__(self) -> str:
+        """
+        Get the string representation of the criterion combination.
+        """
+        return self._repr_pretty(0)

execution_engine/omop/criterion/combination/logical.py

@@ -147,39 +147,6 @@ 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):
     """
@@ -243,12 +210,6 @@ def __str__(self) -> str:
         """
         return f"{self.operator}({', '.join(str(c) for c in self._criteria)})"
 
-    def __repr__(self) -> str:
-        """
-        Get the string representation of the criterion combination.
-        """
-        return f'{self.__class__.__name__}("{self.operator}", {self._criteria})'
-
     def __eq__(self, other: object) -> bool:
         """
         Check if the criterion combination is equal to another criterion combination.
@@ -282,6 +243,13 @@ def dict(self) -> dict:
             "right": {"class_name": right.__class__.__name__, "data": right.dict()},
         }
 
+    def _repr_pretty(self, level: int = 0) -> str:
+        children = [
+            ("left", self._left),
+            ("right", self._right),
+        ]
+        return self._build_repr(children, params=[], level=level)
+
     @classmethod
     def from_dict(
         cls, data: Dict[str, Any]

execution_engine/omop/criterion/combination/temporal.py

@@ -24,7 +24,7 @@ def __repr__(self) -> str:
         """
         Get the string representation of the time interval type.
         """
-        return f'{self.__class__.__name__}("{self.value}")'
+        return f"{self.__class__.__name__}.{self.name}"
 
 
 class TemporalIndicatorCombination(CriterionCombination):
@@ -103,6 +103,15 @@ def __str__(self) -> str:
         else:
             return super().__str__()
 
+    def _repr_pretty(self, level: int = 0) -> str:
+        children = [(None, c) for c in self._criteria]
+        params = [
+            ("interval_type", self.interval_type),
+            ("start_time", self.start_time),
+            ("end_time", self.end_time),
+        ]
+        return self._build_repr(children, params, level)
+
     def dict(self) -> Dict:
         """
         Get the dictionary representation of the criterion combination.

execution_engine/omop/criterion/custom/tidal_volume.py

@@ -1,5 +1,4 @@
 import numbers
-from typing import Any
 
 import sqlalchemy
 from sqlalchemy import (
@@ -17,13 +16,15 @@
 from sqlalchemy.sql import Select
 
 import execution_engine.omop.db.omop.tables as omop_tables
-from execution_engine.constants import OMOPConcepts
+from execution_engine.constants import CohortCategory, OMOPConcepts
+from execution_engine.omop.concepts import Concept
 from execution_engine.omop.criterion.abstract import (
     observation_end_datetime,
     observation_start_datetime,
 )
 from execution_engine.omop.criterion.point_in_time import PointInTimeCriterion
-from execution_engine.util.value import ValueNumber
+from execution_engine.util.types import Timing
+from execution_engine.util.value import Value, ValueNumber
 
 __all__ = ["TidalVolumePerIdealBodyWeight"]
 
@@ -47,9 +48,24 @@ class TidalVolumePerIdealBodyWeight(PointInTimeCriterion):
 
     __GENDER_TO_INT = {"female": 0, "male": 1, "unknown": 0.5}
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-
+    def __init__(
+        self,
+        category: CohortCategory,
+        concept: Concept,
+        value: Value | None = None,
+        static: bool | None = None,
+        timing: Timing | None = None,
+        override_value_required: bool | None = None,
+        forward_fill: bool = True,
+    ):
+        super().__init__(
+            category=category,
+            concept=concept,
+            value=value,
+            static=static,
+            timing=timing,
+            override_value_required=override_value_required,
+        )
         self._table = self._cte()
 
     def _cte(self) -> CTE:

execution_engine/omop/criterion/meta.py

@@ -76,8 +76,19 @@ def __init__(self: object, *args: Any, **kwargs: Any) -> None:
             init_sig = inspect.signature(original_init)
             __init__.__signature__ = init_sig  # type: ignore[attr-defined]
 
+        original_repr = namespace.get("__repr__")
+
+        if not original_repr:
+            # Try to find an __init__ in the bases
+            for base in reversed(bases):
+                if base.__repr__ is not object.__repr__:
+                    original_repr = base.__repr__
+                    break
+
         # If no user-defined __repr__, attach a default
-        if "__repr__" not in namespace:
+        if not original_repr or getattr(
+            original_repr, "__signature_repr_generated__", False
+        ):
 
             def __repr__(self: object) -> str:
                 if not hasattr(self, "_init_args"):
@@ -99,6 +110,9 @@ def __repr__(self: object) -> str:
                             )
                 return f"{name}({', '.join(parts)})"
 
+            # Tag it so children know it's auto-generated
+            __repr__.__signature_repr_generated__ = True  # type: ignore[attr-defined]
+
             setattr(cls, "__repr__", __repr__)
 
         return cls