Merge branch 'main' into nk/serialize_as_any_updates

Signed-off-by: Nijat Khanbabayev <[email protected]>

Author: NeejWeej

.copier-answers.yaml

@@ -1,5 +1,5 @@
 # Changes here will be overwritten by Copier
-_commit: a74894d
+_commit: f812aaa
 _src_path: https://github.com/python-project-templates/base.git
 add_docs: false
 add_extension: python

.github/workflows/build.yaml

@@ -27,8 +27,8 @@ jobs:
 
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-13]  # NOTE: use macos-13 as no standard csp wheels for arm64 3.9
-        python-version: [3.9]
+        os: [ubuntu-latest, macos-latest]
+        python-version: ['3.10']
 
     steps:
     - uses: actions/checkout@v5
@@ -53,7 +53,7 @@ jobs:
       run: make coverage
 
     - name: Upload test results (Python)
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v5
       with:
         name: py-test-results-${{ matrix.os }}-${{ matrix.python-version }}-
         path: junit.xml
@@ -74,7 +74,7 @@ jobs:
     - name: Twine check
       run: make dist
 
-    - uses: actions/upload-artifact@v4
+    - uses: actions/upload-artifact@v5
       with:
         name: dist-${{matrix.os}}
         path: dist

ccflow/__init__.py

@@ -1,11 +1,12 @@
-__version__ = "0.6.4"
+__version__ = "0.6.8"
 
 from .arrow import *
 from .base import *
 from .callable import *
 from .context import *
 from .enums import Enum
 from .exttypes import *
+from .global_state import *
 from .models import *
 from .object_config import *
 from .publisher import *

ccflow/base.py

@@ -310,7 +310,7 @@ def __init__(self, *args, **kwargs):
         models = {}
         if "models" in kwargs:
             models = kwargs.pop("models")
-            if not isinstance(models, dict):
+            if not isinstance(models, (dict, MappingProxyType)):
                 raise TypeError("models must be a dict")
         super(ModelRegistry, self).__init__(*args, **kwargs)
         for name, model in models.items():
@@ -352,6 +352,10 @@ def clear(self) -> Self:
             self.remove(name)
         return self
 
+    def clone(self, name: Optional[str] = None) -> Self:
+        """Shallow clone the registry (but not the models within it)."""
+        return ModelRegistry(name=name or self.name, models=self.models)
+
     def remove(self, name: str) -> None:
         """Remove a model from the registry.
 

ccflow/callable.py

@@ -587,19 +587,75 @@ def result_type(self) -> Type[ResultType]:
 
 
 class CallableModelGenericType(CallableModel, Generic[ContextType, ResultType]):
-    """Special type of callable model to use for type declarations, such that the
-    context and result type will be validated.
+    """Special type of callable model that provides context and result via
+    a generic type instead of annotations on __call__.
     """
 
+    _context_type: ClassVar[Type[ContextType]]
+    _result_type: ClassVar[Type[ResultType]]
+
+    @property
+    def context_type(self) -> Type[ContextType]:
+        return self._context_type
+
+    @property
+    def result_type(self) -> Type[ResultType]:
+        return self._result_type
+
     @model_validator(mode="wrap")
     def _validate_callable_model_generic_type(cls, m, handler, info):
         from ccflow.base import resolve_str
 
         if isinstance(m, str):
             m = resolve_str(m)
+        if isinstance(m, dict):
+            m = handler(m)
         # Raise ValueError (not TypeError) as per https://docs.pydantic.dev/latest/errors/errors/
         if not isinstance(m, CallableModel):
             raise ValueError(f"{m} is not a CallableModel: {type(m)}")
+
+        # Extract the generic types from the class definition
+        if not hasattr(cls, "_context_type") or not hasattr(cls, "_result_type"):
+            new_context_type = None
+            new_result_type = None
+            for base in cls.__mro__[1:]:
+                if issubclass(base, CallableModelGenericType):
+                    # Found the generic base class, it should
+                    # have either generic parameters or context/result
+                    if new_context_type is None and hasattr(base, "_context_type") and issubclass(base._context_type, ContextBase):
+                        new_context_type = base._context_type
+                    if new_result_type is None and hasattr(base, "_result_type") and issubclass(base._result_type, ResultBase):
+                        new_result_type = base._result_type
+                    if base.__pydantic_generic_metadata__["args"]:
+                        for arg in base.__pydantic_generic_metadata__["args"]:
+                            if new_context_type is None and isinstance(arg, type) and issubclass(arg, ContextBase):
+                                new_context_type = arg
+                            elif new_result_type is None and isinstance(arg, type) and issubclass(arg, ResultBase):
+                                # NOTE: ContextBase inherits from ResultBase, so order matters here!
+                                new_result_type = arg
+                    if new_context_type and new_result_type:
+                        break
+            if new_context_type is not None:
+                # Validate that the model's context_type match
+                orig_context_typ = _cached_signature(cls.__call__).parameters["context"].annotation
+                if orig_context_typ is not Signature.empty and orig_context_typ != new_context_type:
+                    raise TypeError(
+                        f"Context type annotation {orig_context_typ} on __call__ does not match context_type {new_context_type} defined by CallableModelGenericType"
+                    )
+                # Set on class
+                cls._context_type = new_context_type
+
+            if new_result_type is not None:
+                # Validate that the model's result_type match
+                orig_return_typ = _cached_signature(cls.__call__).return_annotation
+                if orig_return_typ is not Signature.empty and orig_return_typ != new_result_type:
+                    raise TypeError(
+                        f"Return type annotation {orig_return_typ} on __call__ does not match result_type {new_result_type} defined by CallableModelGenericType"
+                    )
+
+                # Set on class
+                cls._result_type = new_result_type
+
         subtypes = cls.__pydantic_generic_metadata__["args"]
         if subtypes:
             TypeAdapter(Type[subtypes[0]]).validate_python(m.context_type)

ccflow/context.py

@@ -7,41 +7,60 @@
 
 from .base import ContextBase
 from .exttypes import Frequency
-from .validators import normalize_date
+from .validators import normalize_date, normalize_datetime
 
-__all__ = [
+__all__ = (
     "NullContext",
     "GenericContext",
     "DateContext",
     "DatetimeContext",
     "EntryTimeContext",
+    "SourceContext",
     "DateRangeContext",
+    "DatetimeRangeContext",
+    "SeededDateRangeContext",
+    "SeededDatetimeRangeContext",
     "VersionedDateContext",
+    "VersionedDatetimeContext",
     "VersionedDateRangeContext",
+    "VersionedDatetimeRangeContext",
     "FreqContext",
     "FreqDateContext",
+    "FreqDatetimeContext",
     "FreqDateRangeContext",
+    "FreqDatetimeRangeContext",
     "HorizonContext",
     "FreqHorizonContext",
     "FreqHorizonDateContext",
+    "FreqHorizonDatetimeContext",
     "FreqHorizonDateRangeContext",
-    "SeededDateRangeContext",
-    "SourceContext",
+    "FreqHorizonDatetimeRangeContext",
     "UniverseContext",
     "UniverseDateContext",
+    "UniverseDatetimeContext",
     "UniverseDateRangeContext",
+    "UniverseDatetimeRangeContext",
     "UniverseFrequencyDateRangeContext",
+    "UniverseFrequencyDatetimeRangeContext",
     "UniverseFrequencyHorizonDateRangeContext",
+    "UniverseFrequencyHorizonDatetimeRangeContext",
     "VersionedUniverseDateContext",
+    "VersionedUniverseDatetimeContext",
     "VersionedUniverseDateRangeContext",
+    "VersionedUniverseDatetimeRangeContext",
     "ModelContext",
     "ModelDateContext",
+    "ModelDatetimeContext",
     "ModelDateRangeContext",
+    "ModelDatetimeRangeContext",
     "ModelDateRangeSourceContext",
     "ModelFreqDateRangeContext",
+    "ModelFreqDatetimeRangeContext",
     "VersionedModelDateContext",
+    "VersionedModelDatetimeContext",
     "VersionedModelDateRangeContext",
-]
+    "VersionedModelDatetimeRangeContext",
+)
 
 _SEPARATOR = ","
 
@@ -100,6 +119,9 @@ def _date_context_validator(cls, v, handler, info):
 class DatetimeContext(ContextBase):
     dt: datetime
 
+    # validators
+    _normalize_dt = field_validator("dt", mode="before")(normalize_datetime)
+
     @model_validator(mode="wrap")
     def _datetime_context_validator(cls, v, handler, info):
         if cls is DatetimeContext and not isinstance(v, (DatetimeContext, dict)):
@@ -126,18 +148,38 @@ class DateRangeContext(ContextBase):
     _normalize_end = field_validator("end_date", mode="before")(normalize_date)
 
 
+class DatetimeRangeContext(ContextBase):
+    start_datetime: datetime
+    end_datetime: datetime
+
+    _normalize_start = field_validator("start_datetime", mode="before")(normalize_datetime)
+    _normalize_end = field_validator("end_datetime", mode="before")(normalize_datetime)
+
+
 class SeededDateRangeContext(DateRangeContext):
     seed: int = 1234
 
 
+class SeededDatetimeRangeContext(DatetimeRangeContext):
+    seed: int = 1234
+
+
 class VersionedDateContext(DateContext, EntryTimeContext):
     pass
 
 
+class VersionedDatetimeContext(DatetimeContext, EntryTimeContext):
+    pass
+
+
 class VersionedDateRangeContext(DateRangeContext, EntryTimeContext):
     pass
 
 
+class VersionedDatetimeRangeContext(DatetimeRangeContext, EntryTimeContext):
+    pass
+
+
 class FreqContext(ContextBase):
     freq: Frequency
 
@@ -146,10 +188,18 @@ class FreqDateContext(DateContext, FreqContext):
     pass
 
 
+class FreqDatetimeContext(DatetimeContext, FreqContext):
+    pass
+
+
 class FreqDateRangeContext(DateRangeContext, FreqContext):
     pass
 
 
+class FreqDatetimeRangeContext(DatetimeRangeContext, FreqContext):
+    pass
+
+
 class HorizonContext(ContextBase):
     horizon: Frequency
 
@@ -162,10 +212,18 @@ class FreqHorizonDateContext(DateContext, HorizonContext, FreqContext):
     pass
 
 
+class FreqHorizonDatetimeContext(DatetimeContext, HorizonContext, FreqContext):
+    pass
+
+
 class FreqHorizonDateRangeContext(DateRangeContext, HorizonContext, FreqContext):
     pass
 
 
+class FreqHorizonDatetimeRangeContext(DatetimeRangeContext, HorizonContext, FreqContext):
+    pass
+
+
 class UniverseContext(ContextBase):
     universe: str
 
@@ -174,26 +232,50 @@ class UniverseDateContext(DateContext, UniverseContext):
     pass
 
 
+class UniverseDatetimeContext(DatetimeContext, UniverseContext):
+    pass
+
+
 class UniverseDateRangeContext(DateRangeContext, UniverseContext):
     pass
 
 
+class UniverseDatetimeRangeContext(DatetimeRangeContext, UniverseContext):
+    pass
+
+
 class UniverseFrequencyDateRangeContext(DateRangeContext, FreqContext, UniverseContext):
     pass
 
 
+class UniverseFrequencyDatetimeRangeContext(DatetimeRangeContext, FreqContext, UniverseContext):
+    pass
+
+
 class UniverseFrequencyHorizonDateRangeContext(DateRangeContext, HorizonContext, FreqContext, UniverseContext):
     pass
 
 
+class UniverseFrequencyHorizonDatetimeRangeContext(DatetimeRangeContext, HorizonContext, FreqContext, UniverseContext):
+    pass
+
+
 class VersionedUniverseDateContext(VersionedDateContext, UniverseContext):
     pass
 
 
+class VersionedUniverseDatetimeContext(VersionedDatetimeContext, UniverseContext):
+    pass
+
+
 class VersionedUniverseDateRangeContext(VersionedDateRangeContext, UniverseContext):
     pass
 
 
+class VersionedUniverseDatetimeRangeContext(VersionedDatetimeRangeContext, UniverseContext):
+    pass
+
+
 class ModelContext(ContextBase):
     model: str
 
@@ -202,10 +284,18 @@ class ModelDateContext(DateContext, ModelContext):
     pass
 
 
+class ModelDatetimeContext(DatetimeContext, ModelContext):
+    pass
+
+
 class ModelDateRangeContext(DateRangeContext, ModelContext):
     pass
 
 
+class ModelDatetimeRangeContext(DatetimeRangeContext, ModelContext):
+    pass
+
+
 class ModelDateRangeSourceContext(SourceContext, ModelDateRangeContext):
     pass
 
@@ -214,9 +304,21 @@ class ModelFreqDateRangeContext(FreqDateRangeContext, ModelContext):
     pass
 
 
+class ModelFreqDatetimeRangeContext(FreqDatetimeRangeContext, ModelContext):
+    pass
+
+
 class VersionedModelDateContext(VersionedDateContext, ModelContext):
     pass
 
 
+class VersionedModelDatetimeContext(VersionedDatetimeContext, ModelContext):
+    pass
+
+
 class VersionedModelDateRangeContext(VersionedDateRangeContext, ModelContext):
     pass
+
+
+class VersionedModelDatetimeRangeContext(VersionedDatetimeRangeContext, ModelContext):
+    pass