Make time conversion a function of data if available.

Author: MImmesberger

src/ttsim/function_types.py

@@ -379,8 +379,6 @@ class DerivedTimeConversionFunction(TTSIMFunction):
     def __post_init__(self):
         if self.source is None:
             raise ValueError("The source must be specified.")
-        if self.conversion_target is None:
-            raise ValueError("The conversion target must be specified.")
 
 
 def _convert_and_validate_dates(

src/ttsim/shared.py

@@ -70,6 +70,41 @@ def get_re_pattern_for_time_units_and_groupings(
     )
 
 
+def get_re_pattern_for_some_base_name(
+    base_name: str, supported_time_units: list[str], supported_groupings: list[str]
+) -> re.Pattern:
+    """Get a regex for a specific base name with optional time unit and aggregation.
+
+    The pattern matches strings in any of these formats:
+    - <specific_base_name>
+    - <specific_base_name>_<time_unit>
+    - <specific_base_name>_<aggregation>
+    - <specific_base_name>_<time_unit>_<aggregation>
+
+    Parameters
+    ----------
+    base_name
+        The specific base name to match.
+    supported_time_units
+        The supported time units.
+    supported_groupings
+        The supported groupings.
+
+    Returns
+    -------
+    pattern
+        The regex pattern.
+    """
+    units = "".join(supported_time_units)
+    groupings = "|".join(supported_groupings)
+    return re.compile(
+        f"(?P<base_name>{re.escape(base_name)})"
+        f"(?:_(?P<time_unit>[{units}]))?"
+        f"(?:_(?P<aggregation>{groupings}))?"
+        f"$"
+    )
+
+
 def all_variations_of_base_name(
     base_name: str,
     supported_time_conversions: list[str],

src/ttsim/time_conversion.py

@@ -7,10 +7,14 @@
 from dags import rename_arguments
 
 from _gettsim.config import SUPPORTED_GROUPINGS
-from ttsim.function_types import DerivedTimeConversionFunction, PolicyFunction
-from ttsim.shared import get_re_pattern_for_time_units_and_groupings
+from ttsim.function_types import DerivedTimeConversionFunction, TTSIMObject
+from ttsim.shared import (
+    get_re_pattern_for_some_base_name,
+    get_re_pattern_for_time_units_and_groupings,
+)
 
 if TYPE_CHECKING:
+    import re
     from collections.abc import Callable
 
     from ttsim.typing import QualNameDataDict, QualNameTTSIMObjectDict
@@ -374,7 +378,7 @@ def d_to_w(value: float) -> float:
 
 
 def create_time_conversion_functions(
-    functions: QualNameTTSIMObjectDict,
+    ttsim_objects: QualNameTTSIMObjectDict,
     data: QualNameDataDict,
 ) -> QualNameTTSIMObjectDict:
     """
@@ -414,58 +418,64 @@ def create_time_conversion_functions(
     The functions dict with the new time conversion functions.
     """
 
-    converted_functions = {}
+    converted_ttsim_objects = {}
 
-    # Create time-conversions for existing functions
-    for name, function in functions.items():
-        all_time_conversions_for_this_function = _create_time_conversion_functions(
-            name=name, func=function
+    for source_name, ttsim_object in ttsim_objects.items():
+        all_time_units = list(_TIME_UNITS)
+        time_unit_pattern = get_re_pattern_for_time_units_and_groupings(
+            supported_groupings=SUPPORTED_GROUPINGS,
+            supported_time_units=all_time_units,
         )
-        for der_name, der_func in all_time_conversions_for_this_function.items():
-            # Skip if the function already exists or the data column exists
-            if der_name in converted_functions or der_name in data:
-                continue
-            else:
-                converted_functions[der_name] = der_func
+        match = time_unit_pattern.fullmatch(source_name)
+        base_name = match.group("base_name")
+
+        # If base_name is in data, make all time conversion depend on it instead of the
+        # function
+        for data_name in data:
+            match = get_re_pattern_for_some_base_name(
+                base_name=base_name,
+                supported_time_units=all_time_units,
+                supported_groupings=SUPPORTED_GROUPINGS,
+            ).fullmatch(data_name)
+            if match:
+                source_name = data_name  # noqa: PLW2901
+                break
 
-    # Create time-conversions for data columns
-    for name in data:
-        all_time_conversions_for_this_data_column = _create_time_conversion_functions(
-            name=name
+        all_time_conversions_for_this_function = _create_time_conversion_functions(
+            source_name=source_name,
+            ttsim_object=ttsim_object,
+            time_unit_pattern=time_unit_pattern,
+            all_time_units=all_time_units,
         )
-        for der_name, der_func in all_time_conversions_for_this_data_column.items():
-            # Skip if the function already exists or the data column exists
-            if der_name in converted_functions or der_name in data:
+        for der_name, der_func in all_time_conversions_for_this_function.items():
+            if der_name in converted_ttsim_objects or der_name in data:
                 continue
             else:
-                converted_functions[der_name] = der_func
+                converted_ttsim_objects[der_name] = der_func
 
-    return converted_functions
+    return converted_ttsim_objects
 
 
 def _create_time_conversion_functions(
-    name: str, func: PolicyFunction | None = None
+    source_name: str,
+    ttsim_object: TTSIMObject,
+    time_unit_pattern: re.Pattern,
+    all_time_units: list[str],
 ) -> dict[str, DerivedTimeConversionFunction]:
     result: dict[str, DerivedTimeConversionFunction] = {}
-    all_time_units = list(_TIME_UNITS)
-
-    time_unit_pattern = get_re_pattern_for_time_units_and_groupings(
-        supported_groupings=SUPPORTED_GROUPINGS,
-        supported_time_units=all_time_units,
-    )
-
-    match = time_unit_pattern.fullmatch(name)
+    match = time_unit_pattern.fullmatch(source_name)
     base_name = match.group("base_name")
     time_unit = match.group("time_unit") or ""
     aggregation = match.group("aggregation") or ""
-
-    dependencies = set(inspect.signature(func).parameters) if func else set()
+    dependencies = (
+        set(inspect.signature(ttsim_object).parameters) if ttsim_object else set()
+    )
 
     if match and time_unit:
         missing_time_units = [unit for unit in all_time_units if unit != time_unit]
         for missing_time_unit in missing_time_units:
             new_name = (
-                f"{base_name}_{missing_time_unit}{aggregation}"
+                f"{base_name}_{missing_time_unit}_{aggregation}"
                 if aggregation
                 else f"{base_name}_{missing_time_unit}"
             )
@@ -485,21 +495,23 @@ def _create_time_conversion_functions(
             result[new_name] = DerivedTimeConversionFunction(
                 leaf_name=dt.tree_path_from_qual_name(new_name)[-1],
                 function=_create_function_for_time_unit(
-                    name,
-                    _time_conversion_functions[f"{time_unit}_to_{missing_time_unit}"],
+                    source=source_name,
+                    converter=_time_conversion_functions[
+                        f"{time_unit}_to_{missing_time_unit}"
+                    ],
                 ),
-                source=name,
-                start_date=func.start_date,
-                end_date=func.end_date,
+                source=source_name,
+                start_date=ttsim_object.start_date,
+                end_date=ttsim_object.end_date,
             )
 
     return result
 
 
 def _create_function_for_time_unit(
-    function_name: str, converter: Callable[[float], float]
+    source: str, converter: Callable[[float], float]
 ) -> Callable[[float], float]:
-    @rename_arguments(mapper={"x": function_name})
+    @rename_arguments(mapper={"x": source})
     def func(x: float) -> float:
         return converter(x)
 

tests/ttsim/test_shared.py

@@ -6,6 +6,7 @@
     all_variations_of_base_name,
     create_tree_from_path_and_value,
     get_name_of_group_by_id,
+    get_re_pattern_for_some_base_name,
     get_re_pattern_for_time_units_and_groupings,
     insert_path_and_value,
     merge_trees,
@@ -379,3 +380,27 @@ def test_get_re_pattern_for_time_units_and_groupings(
     assert match.group("base_name") == expected_base_name
     assert match.group("time_unit") == expected_time_unit
     assert match.group("aggregation") == expected_aggregation
+
+
+@pytest.mark.parametrize(
+    (
+        "base_name",
+        "supported_time_units",
+        "supported_groupings",
+        "expected_match",
+    ),
+    [
+        ("foo", ["m", "y"], ["hh"], "foo_m_hh"),
+        ("foo", ["m", "y"], ["hh", "x"], "foo_m"),
+        ("foo", ["m", "y"], ["hh", "x"], "foo_hh"),
+    ],
+)
+def test_get_re_pattern_for_some_base_name(
+    base_name, supported_time_units, supported_groupings, expected_match
+):
+    re_pattern = get_re_pattern_for_some_base_name(
+        base_name=base_name,
+        supported_time_units=supported_time_units,
+        supported_groupings=supported_groupings,
+    )
+    assert re_pattern.fullmatch(expected_match)

tests/ttsim/test_time_conversion.py

@@ -280,34 +280,6 @@ def test_should_create_functions_for_other_time_units_for_functions(
         for expected_name in expected:
             assert expected_name in time_conversion_functions
 
-    @pytest.mark.parametrize(
-        ("name", "expected"),
-        [
-            ("test_y", ["test_m", "test_q", "test_w", "test_d"]),
-            ("test_y_hh", ["test_m_hh", "test_q_hh", "test_w_hh", "test_d_hh"]),
-            ("test_y_sn", ["test_m_sn", "test_q_sn", "test_w_sn", "test_d_sn"]),
-            ("test_q", ["test_y", "test_m", "test_w", "test_d"]),
-            ("test_q_hh", ["test_y_hh", "test_m_hh", "test_w_hh", "test_d_hh"]),
-            ("test_q_sn", ["test_y_sn", "test_m_sn", "test_w_sn", "test_d_sn"]),
-            ("test_m", ["test_y", "test_q", "test_w", "test_d"]),
-            ("test_m_hh", ["test_y_hh", "test_q_hh", "test_w_hh", "test_d_hh"]),
-            ("test_m_sn", ["test_y_sn", "test_q_sn", "test_w_sn", "test_d_sn"]),
-            ("test_w", ["test_y", "test_q", "test_m", "test_d"]),
-            ("test_w_hh", ["test_y_hh", "test_q_hh", "test_m_hh", "test_d_hh"]),
-            ("test_w_sn", ["test_y_sn", "test_q_sn", "test_m_sn", "test_d_sn"]),
-            ("test_d", ["test_y", "test_q", "test_m", "test_w"]),
-            ("test_d_hh", ["test_y_hh", "test_q_hh", "test_m_hh", "test_w_hh"]),
-            ("test_d_sn", ["test_y_sn", "test_q_sn", "test_m_sn", "test_w_sn"]),
-        ],
-    )
-    def test_should_create_functions_for_other_time_units_for_data_cols(
-        self, name: str, expected: list[str]
-    ) -> None:
-        time_conversion_functions = create_time_conversion_functions({}, {name: None})
-
-        for expected_name in expected:
-            assert expected_name in time_conversion_functions
-
     def test_should_not_create_functions_automatically_that_exist_already(self) -> None:
         time_conversion_functions = create_time_conversion_functions(
             {"test1_d": policy_function(leaf_name="test1_d")(lambda: 1)},