From 5367fd3e44a69bef41b37b533b54f3911ff8a5ea Mon Sep 17 00:00:00 2001 From: Nijat Khanbabayev Date: Fri, 31 Oct 2025 16:27:37 -0400 Subject: [PATCH 1/3] Fixes for serialize_as_any in pydantic Signed-off-by: Nijat Khanbabayev --- ccflow/base.py | 84 ++++--------------- ccflow/callable.py | 43 +++++++++- ccflow/tests/test_base_serialize.py | 43 +--------- .../test_evaluation_context_serialization.py | 83 ++++++++++++++++++ pyproject.toml | 2 +- 5 files changed, 144 insertions(+), 111 deletions(-) create mode 100644 ccflow/tests/test_evaluation_context_serialization.py diff --git a/ccflow/base.py b/ccflow/base.py index a2f2609..8be9f4f 100644 --- a/ccflow/base.py +++ b/ccflow/base.py @@ -2,17 +2,14 @@ import collections.abc import copy -import inspect import logging import pathlib -import platform import sys import warnings -from types import GenericAlias, MappingProxyType -from typing import Any, Callable, ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union, get_args, get_origin +from types import MappingProxyType +from typing import Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar from omegaconf import DictConfig -from packaging import version from pydantic import ( BaseModel as PydanticBaseModel, ConfigDict, @@ -89,66 +86,7 @@ def get_registry_dependencies(self, types: Optional[Tuple["ModelType"]] = None) return deps -# Pydantic 2 has different handling of serialization. -# This requires some workarounds at the moment until the feature is added to easily get a mode that -# is compatible with Pydantic 1 -# This is done by adjusting annotations via a MetaClass for any annotation that includes a BaseModel, -# such that the new annotation contains SerializeAsAny -# https://docs.pydantic.dev/latest/concepts/serialization/#serializing-with-duck-typing -# https://github.com/pydantic/pydantic/issues/6423 -# https://github.com/pydantic/pydantic-core/pull/740 -# See https://github.com/pydantic/pydantic/issues/6381 for inspiration on implementation -# NOTE: For this logic to be removed, require https://github.com/pydantic/pydantic-core/pull/1478 -from pydantic._internal._model_construction import ModelMetaclass # noqa: E402 - -_IS_PY39 = version.parse(platform.python_version()) < version.parse("3.10") - - -def _adjust_annotations(annotation): - origin = get_origin(annotation) - args = get_args(annotation) - if not _IS_PY39: - from types import UnionType - - if origin is UnionType: - origin = Union - - if isinstance(annotation, GenericAlias) or (inspect.isclass(annotation) and issubclass(annotation, PydanticBaseModel)): - return SerializeAsAny[annotation] - elif origin and args: - # Filter out typing.Type and generic types - if origin is type or (inspect.isclass(origin) and issubclass(origin, Generic)): - return annotation - elif origin is ClassVar: # ClassVar doesn't accept a tuple of length 1 in py39 - return ClassVar[_adjust_annotations(args[0])] - else: - try: - return origin[tuple(_adjust_annotations(arg) for arg in args)] - except TypeError: - raise TypeError(f"Could not adjust annotations for {origin}") - else: - return annotation - - -class _SerializeAsAnyMeta(ModelMetaclass): - def __new__(self, name: str, bases: Tuple[type], namespaces: Dict[str, Any], **kwargs): - annotations: dict = namespaces.get("__annotations__", {}) - - for base in bases: - for base_ in base.__mro__: - if base_ is PydanticBaseModel: - annotations.update(base_.__annotations__) - - for field, annotation in annotations.items(): - if not field.startswith("__"): - annotations[field] = _adjust_annotations(annotation) - - namespaces["__annotations__"] = annotations - - return super().__new__(self, name, bases, namespaces, **kwargs) - - -class BaseModel(PydanticBaseModel, _RegistryMixin, metaclass=_SerializeAsAnyMeta): +class BaseModel(PydanticBaseModel, _RegistryMixin): """BaseModel is a base class for all pydantic models within the cubist flow framework. This gives us a way to add functionality to the framework, including @@ -182,6 +120,17 @@ def type_(self) -> PyObjectPath: ser_json_timedelta="float", ) + # https://docs.pydantic.dev/latest/concepts/serialization/#overriding-the-serialize_as_any-default-false + def model_dump(self, **kwargs) -> dict[str, Any]: + if not kwargs.get("serialize_as_any"): + kwargs["serialize_as_any"] = True + return super().model_dump(**kwargs) + + def model_dump_json(self, **kwargs) -> str: + if not kwargs.get("serialize_as_any"): + kwargs["serialize_as_any"] = True + return super().model_dump_json(**kwargs) + def __str__(self): # Because the standard string representation does not include class name return repr(self) @@ -251,7 +200,7 @@ def _base_model_validator(cls, v, handler, info): if isinstance(v, PydanticBaseModel): # Coerce from one BaseModel type to another (because it worked automatically in v1) - v = v.model_dump(exclude={"type_"}) + v = v.model_dump(serialize_as_any=True, exclude={"type_"}) return handler(v) @@ -376,7 +325,8 @@ def _validate_name(cls, v): @model_serializer(mode="wrap") def _registry_serializer(self, handler): values = handler(self) - values["models"] = self._models + models_serialized = {k: model.model_dump(serialize_as_any=True, by_alias=True) for k, model in self._models.items()} + values["models"] = models_serialized return values @property diff --git a/ccflow/callable.py b/ccflow/callable.py index 3cc1277..7ea16a4 100644 --- a/ccflow/callable.py +++ b/ccflow/callable.py @@ -17,7 +17,18 @@ from inspect import Signature, isclass, signature from typing import Any, ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar -from pydantic import BaseModel as PydanticBaseModel, ConfigDict, Field, InstanceOf, PrivateAttr, TypeAdapter, field_validator, model_validator +from pydantic import ( + BaseModel as PydanticBaseModel, + ConfigDict, + Field, + InstanceOf, + PrivateAttr, + SerializerFunctionWrapHandler, + TypeAdapter, + field_validator, + model_serializer, + model_validator, +) from typing_extensions import override from .base import ( @@ -426,6 +437,36 @@ def __call__(self) -> ResultType: else: return fn(self.context) + # When serialize_as_any=True, pydantic may detect repeated object ids in nested graphs + # (e.g., shared default lists) and raise a circular reference error during serialization. + # For computing cache keys, fall back to a minimal, stable representation if such an error occurs. + # This is similar to how we the pydantic docs here: + # https://docs.pydantic.dev/latest/concepts/forward_annotations/#cyclic-references + # handle cyclic references during serialization. + @model_serializer(mode="wrap") + def _serialize_model_evaluation_context(self, handler: SerializerFunctionWrapHandler): + try: + return handler(self) + except ValueError as exc: + msg = str(exc) + if "Circular reference" not in msg and "id repeated" not in msg: + raise + # Minimal, stable representation sufficient for cache-key tokenization + try: + model_repr = self.model.model_dump(mode="python", serialize_as_any=True, by_alias=True) + except Exception: + model_repr = repr(self.model) + try: + context_repr = self.context.model_dump(mode="python", serialize_as_any=True, by_alias=True) + except Exception: + context_repr = repr(self.context) + return dict( + fn=self.fn, + model=model_repr, + context=context_repr, + options=dict(self.options), + ) + class EvaluatorBase(_CallableModel, abc.ABC): """Base class for evaluators, which are higher-order models that evaluate ModelAndContext. diff --git a/ccflow/tests/test_base_serialize.py b/ccflow/tests/test_base_serialize.py index fbec5c2..69cc0c8 100644 --- a/ccflow/tests/test_base_serialize.py +++ b/ccflow/tests/test_base_serialize.py @@ -1,10 +1,8 @@ import pickle -import platform import unittest -from typing import Annotated, ClassVar, Dict, List, Optional, Type, Union +from typing import Annotated, Optional import numpy as np -from packaging import version from pydantic import BaseModel as PydanticBaseModel, ConfigDict, Field, ValidationError from ccflow import BaseModel, NDArray @@ -213,45 +211,6 @@ class C(PydanticBaseModel): # C implements the normal pydantic BaseModel whichhould allow extra fields. _ = C(extra_field1=1) - def test_serialize_as_any(self): - # https://docs.pydantic.dev/latest/concepts/serialization/#serializing-with-duck-typing - # https://github.com/pydantic/pydantic/issues/6423 - # This test could be removed once there is a different solution to the issue above - from pydantic import SerializeAsAny - from pydantic.types import constr - - if version.parse(platform.python_version()) >= version.parse("3.10"): - pipe_union = A | int - else: - pipe_union = Union[A, int] - - class MyNestedModel(BaseModel): - a1: A - a2: Optional[Union[A, int]] - a3: Dict[str, Optional[List[A]]] - a4: ClassVar[A] - a5: Type[A] - a6: constr(min_length=1) - a7: pipe_union - - target = { - "a1": SerializeAsAny[A], - "a2": Optional[Union[SerializeAsAny[A], int]], - "a4": ClassVar[SerializeAsAny[A]], - "a5": Type[A], - "a6": constr(min_length=1), # Uses Annotation - "a7": Union[SerializeAsAny[A], int], - } - target["a3"] = dict[str, Optional[list[SerializeAsAny[A]]]] - annotations = MyNestedModel.__annotations__ - self.assertEqual(str(annotations["a1"]), str(target["a1"])) - self.assertEqual(str(annotations["a2"]), str(target["a2"])) - self.assertEqual(str(annotations["a3"]), str(target["a3"])) - self.assertEqual(str(annotations["a4"]), str(target["a4"])) - self.assertEqual(str(annotations["a5"]), str(target["a5"])) - self.assertEqual(str(annotations["a6"]), str(target["a6"])) - self.assertEqual(str(annotations["a7"]), str(target["a7"])) - def test_pickle_consistency(self): model = MultiAttributeModel(z=1, y="test", x=3.14, w=True) serialized = pickle.dumps(model) diff --git a/ccflow/tests/test_evaluation_context_serialization.py b/ccflow/tests/test_evaluation_context_serialization.py new file mode 100644 index 0000000..53cfe2a --- /dev/null +++ b/ccflow/tests/test_evaluation_context_serialization.py @@ -0,0 +1,83 @@ +import json +from datetime import date + +from ccflow import DateContext +from ccflow.callable import ModelEvaluationContext +from ccflow.evaluators import GraphEvaluator, LoggingEvaluator, MultiEvaluator +from ccflow.tests.evaluators.util import NodeModel + +# NOTE: for these tests, round-tripping via JSON does not work +# because the ModelEvaluationContext just has an InstanceOf validation check +# and so we do not actually construct a full MEC on load. + + +def _make_nested_mec(model): + ctx = DateContext(date=date(2022, 1, 1)) + mec = model.__call__.get_evaluation_context(model, ctx) + assert isinstance(mec, ModelEvaluationContext) + # ensure nested: outer model is an evaluator, inner is a ModelEvaluationContext + assert isinstance(mec.context, ModelEvaluationContext) + return mec + + +def test_mec_model_dump_basic(): + m = NodeModel() + mec = _make_nested_mec(m) + + d = mec.model_dump() + assert isinstance(d, dict) + assert "fn" in d and "model" in d and "context" in d and "options" in d + + s = mec.model_dump_json() + parsed = json.loads(s) + assert parsed["fn"] == d["fn"] + # Also verify mode-specific dumps + d_py = mec.model_dump(mode="python") + assert isinstance(d_py, dict) + d_json = mec.model_dump(mode="json") + assert isinstance(d_json, dict) + json.dumps(d_json) + + +def test_mec_model_dump_diamond_graph(): + n0 = NodeModel() + n1 = NodeModel(deps_model=[n0]) + n2 = NodeModel(deps_model=[n0]) + root = NodeModel(deps_model=[n1, n2]) + + mec = _make_nested_mec(root) + + d = mec.model_dump() + assert isinstance(d, dict) + assert set(["fn", "model", "context", "options"]).issubset(d.keys()) + + s = mec.model_dump_json() + json.loads(s) + # verify mode dumps + d_py = mec.model_dump(mode="python") + assert isinstance(d_py, dict) + d_json = mec.model_dump(mode="json") + assert isinstance(d_json, dict) + json.dumps(d_json) + + +def test_mec_model_dump_with_multi_evaluator(): + m = NodeModel() + _ = LoggingEvaluator() # ensure import/validation + evaluator = MultiEvaluator(evaluators=[LoggingEvaluator(), GraphEvaluator()]) + + # Simulate how Flow builds evaluation context with a custom evaluator + ctx = DateContext(date=date(2022, 1, 1)) + mec = ModelEvaluationContext(model=evaluator, context=m.__call__.get_evaluation_context(m, ctx)) + + d = mec.model_dump() + assert isinstance(d, dict) + assert "fn" in d and "model" in d and "context" in d + s = mec.model_dump_json() + json.loads(s) + # verify mode dumps + d_py = mec.model_dump(mode="python") + assert isinstance(d_py, dict) + d_json = mec.model_dump(mode="json") + assert isinstance(d_json, dict) + json.dumps(d_json) diff --git a/pyproject.toml b/pyproject.toml index d456cee..4c3667a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -44,7 +44,7 @@ dependencies = [ "orjson", "pandas", "pyarrow", - "pydantic>=2.6,<3", + "pydantic>=2.35,<3", "smart_open", "tenacity", ] From d6aa3ed7b186d578fcf42f31ea3ff4b8480a3611 Mon Sep 17 00:00:00 2001 From: Nijat Khanbabayev Date: Fri, 31 Oct 2025 16:37:37 -0400 Subject: [PATCH 2/3] Use pydantic>=2.12 for serialize as any Signed-off-by: Nijat Khanbabayev --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 4c3667a..4fac3f0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -44,7 +44,7 @@ dependencies = [ "orjson", "pandas", "pyarrow", - "pydantic>=2.35,<3", + "pydantic>=2.12,<3", "smart_open", "tenacity", ] From 1ac3bd8420bf81fa52ae5aeb77f83691029e574a Mon Sep 17 00:00:00 2001 From: Nijat Khanbabayev Date: Fri, 21 Nov 2025 13:48:47 -0500 Subject: [PATCH 3/3] Use polymorphic_serialization flag and small cleanup Signed-off-by: Nijat Khanbabayev --- .copier-answers.yaml | 4 +- .gitignore | 8 + ccflow/__init__.py | 9 +- ccflow/base.py | 33 +- ccflow/callable.py | 286 +++++++++----- ccflow/compose.py | 119 ++++++ ccflow/examples/etl/__init__.py | 25 ++ ccflow/examples/etl/__main__.py | 39 ++ ccflow/examples/etl/config/__init__.py | 0 ccflow/examples/etl/config/base.yaml | 32 ++ ccflow/examples/etl/config/extract/rest.yaml | 8 + ccflow/examples/etl/config/load/db.yaml | 4 + .../examples/etl/config/transform/links.yaml | 9 + ccflow/examples/etl/explain.py | 13 + ccflow/examples/etl/models.py | 76 ++++ ccflow/exttypes/polars.py | 13 +- ccflow/result/__init__.py | 1 + ccflow/result/list.py | 12 + ccflow/tests/config/conf_from_python.yaml | 23 ++ ccflow/tests/data/__init__.py | 4 + ccflow/tests/data/python_object_samples.py | 33 ++ ccflow/tests/examples/test_etl.py | 50 +++ ccflow/tests/exttypes/test_polars.py | 102 +++-- ccflow/tests/test_callable.py | 372 +++++++++++++++--- .../test_evaluation_context_serialization.py | 4 - ccflow/tests/utils/test_compose.py | 230 +++++++++++ ccflow/tests/utils/test_compose_hydra.py | 82 ++++ ccflow/tests/utils/test_hydra.py | 18 +- ccflow/utils/hydra.py | 164 +++++++- docs/img/wiki/etl/explain1.png | Bin 0 -> 235701 bytes docs/img/wiki/etl/explain2.png | Bin 0 -> 96452 bytes docs/wiki/Configuration.md | 11 + docs/wiki/ETL.md | 363 +++++++++++++++++ docs/wiki/Installation.md | 2 +- docs/wiki/_Sidebar.md | 1 + pyproject.toml | 18 +- 36 files changed, 1925 insertions(+), 243 deletions(-) create mode 100644 ccflow/compose.py create mode 100644 ccflow/examples/etl/__init__.py create mode 100644 ccflow/examples/etl/__main__.py create mode 100644 ccflow/examples/etl/config/__init__.py create mode 100644 ccflow/examples/etl/config/base.yaml create mode 100644 ccflow/examples/etl/config/extract/rest.yaml create mode 100644 ccflow/examples/etl/config/load/db.yaml create mode 100644 ccflow/examples/etl/config/transform/links.yaml create mode 100644 ccflow/examples/etl/explain.py create mode 100644 ccflow/examples/etl/models.py create mode 100644 ccflow/result/list.py create mode 100644 ccflow/tests/config/conf_from_python.yaml create mode 100644 ccflow/tests/data/__init__.py create mode 100644 ccflow/tests/data/python_object_samples.py create mode 100644 ccflow/tests/examples/test_etl.py create mode 100644 ccflow/tests/utils/test_compose.py create mode 100644 ccflow/tests/utils/test_compose_hydra.py create mode 100644 docs/img/wiki/etl/explain1.png create mode 100644 docs/img/wiki/etl/explain2.png create mode 100644 docs/wiki/ETL.md diff --git a/.copier-answers.yaml b/.copier-answers.yaml index aab677d..9fdab22 100644 --- a/.copier-answers.yaml +++ b/.copier-answers.yaml @@ -1,5 +1,5 @@ # Changes here will be overwritten by Copier -_commit: f812aaa +_commit: 973c39c _src_path: https://github.com/python-project-templates/base.git add_docs: false add_extension: python @@ -9,5 +9,5 @@ github: Point72 project_description: ccflow is a collection of tools for workflow configuration, orchestration, and dependency injection project_name: ccflow -python_version_primary: '3.9' +python_version_primary: '3.11' team: Point72, L.P. diff --git a/.gitignore b/.gitignore index b177881..80b552b 100644 --- a/.gitignore +++ b/.gitignore @@ -157,3 +157,11 @@ ccflow/labextension # Rust target + +# Examples +outputs +raw.html +extracted.csv +etl.db +lobsters.html +lobsters.csv diff --git a/ccflow/__init__.py b/ccflow/__init__.py index bb74cf6..7de6a95 100644 --- a/ccflow/__init__.py +++ b/ccflow/__init__.py @@ -1,11 +1,16 @@ -__version__ = "0.6.8" +__version__ = "0.7.0" + +# Import exttypes early so modules that import `from ccflow import PyObjectPath` during +# initialization find it (avoids circular import issues with functions that import utilities +# which, in turn, import `ccflow`). +from .exttypes import * # noqa: I001 from .arrow import * from .base import * +from .compose 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 * diff --git a/ccflow/base.py b/ccflow/base.py index 8be9f4f..30df80c 100644 --- a/ccflow/base.py +++ b/ccflow/base.py @@ -30,7 +30,6 @@ log = logging.getLogger(__name__) __all__ = ( - "model_alias", "BaseModel", "ModelRegistry", "ModelType", @@ -118,19 +117,10 @@ def type_(self) -> PyObjectPath: # where the default behavior is just to drop the mis-named value. This prevents that extra="forbid", ser_json_timedelta="float", + # Polymorphic serialization is the behavior of allowing a subclass of a model (or Pydantic dataclass) to override serialization so that the subclass' serialization is used, rather than the original model types's serialization. This will expose all the data defined on the subclass in the serialized payload. + polymorphic_serialization=True, ) - # https://docs.pydantic.dev/latest/concepts/serialization/#overriding-the-serialize_as_any-default-false - def model_dump(self, **kwargs) -> dict[str, Any]: - if not kwargs.get("serialize_as_any"): - kwargs["serialize_as_any"] = True - return super().model_dump(**kwargs) - - def model_dump_json(self, **kwargs) -> str: - if not kwargs.get("serialize_as_any"): - kwargs["serialize_as_any"] = True - return super().model_dump_json(**kwargs) - def __str__(self): # Because the standard string representation does not include class name return repr(self) @@ -200,7 +190,7 @@ def _base_model_validator(cls, v, handler, info): if isinstance(v, PydanticBaseModel): # Coerce from one BaseModel type to another (because it worked automatically in v1) - v = v.model_dump(serialize_as_any=True, exclude={"type_"}) + v = v.model_dump(exclude={"type_"}) return handler(v) @@ -272,20 +262,6 @@ def _is_config_subregistry(value): return False -def model_alias(model_name: str) -> BaseModel: - """Function to alias a BaseModel by name in the root registry. - - Useful for configs in hydra where we want a config object to point directly to another config object. - - Args: - model_name: The name of the underlying model to point to in the registry - Example: - _target_: ccflow.model_alias - model_name: foo - """ - return BaseModel.model_validate(model_name) - - ModelType = TypeVar("ModelType", bound=BaseModel) @@ -325,8 +301,7 @@ def _validate_name(cls, v): @model_serializer(mode="wrap") def _registry_serializer(self, handler): values = handler(self) - models_serialized = {k: model.model_dump(serialize_as_any=True, by_alias=True) for k, model in self._models.items()} - values["models"] = models_serialized + values["models"] = self._models return values @property diff --git a/ccflow/callable.py b/ccflow/callable.py index 7ea16a4..6183148 100644 --- a/ccflow/callable.py +++ b/ccflow/callable.py @@ -15,7 +15,7 @@ import logging from functools import lru_cache, wraps from inspect import Signature, isclass, signature -from typing import Any, ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar +from typing import Any, ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union, get_args, get_origin from pydantic import ( BaseModel as PydanticBaseModel, @@ -23,10 +23,8 @@ Field, InstanceOf, PrivateAttr, - SerializerFunctionWrapHandler, TypeAdapter, field_validator, - model_serializer, model_validator, ) from typing_extensions import override @@ -90,6 +88,50 @@ class _CallableModel(BaseModel, abc.ABC): ) meta: MetaData = Field(default_factory=MetaData) + @classmethod + def _check_context_type(cls, context_type): + type_call_arg = _cached_signature(cls.__call__).parameters["context"].annotation + + # If optional type, extract inner type + if get_origin(type_call_arg) is Optional or (get_origin(type_call_arg) is Union and type(None) in get_args(type_call_arg)): + type_call_arg = [t for t in get_args(type_call_arg) if t is not type(None)][0] + + if ( + not isinstance(type_call_arg, TypeVar) + and type_call_arg is not Signature.empty + and (not isclass(type_call_arg) or not issubclass(type_call_arg, context_type)) + and (not isclass(context_type) or not issubclass(context_type, type_call_arg)) + ): + err_msg_type_mismatch = f"The context_type {context_type} must match the type of the context accepted by __call__ {type_call_arg}" + raise ValueError(err_msg_type_mismatch) + + @classmethod + def _check_result_type(cls, result_type): + type_call_return = _cached_signature(cls.__call__).return_annotation + + # If union, check all types + if get_origin(type_call_return) is Union and get_args(type_call_return): + types_call_return = [t for t in get_args(type_call_return) if t is not type(None)] + else: + types_call_return = [type_call_return] + + all_bad = True + for type_call_return in types_call_return: + if ( + not isinstance(type_call_return, TypeVar) + and type_call_return is not Signature.empty + and (not isclass(type_call_return) or not issubclass(type_call_return, result_type)) + and (not isclass(result_type) or not issubclass(result_type, type_call_return)) + ): + # Don't invert logic so that we match context above + pass + else: + all_bad = False + + if all_bad: + err_msg_type_mismatch = f"The result_type {result_type} must match the return type of __call__ {type_call_return}" + raise ValueError(err_msg_type_mismatch) + @model_validator(mode="after") def _check_signature(self): sig_call = _cached_signature(self.__class__.__call__) @@ -105,10 +147,17 @@ def _check_signature(self): type_deps_arg = _cached_signature(self.__class__.__deps__).parameters["context"].annotation if type_call_arg is not type_deps_arg: err_msg_type_mismatch = ( - f"The type of the context accepted by __deps__ {type_deps_arg} must match that accepted by __call__ {type_call_arg}!" + f"The type of the context accepted by __deps__ {type_deps_arg} must match that accepted by __call__ {type_call_arg}" ) raise ValueError(err_msg_type_mismatch) + # If context_type or result_type are overridden or + # come from generic type, ensure they match the signature + if hasattr(self, "context_type"): + self._check_context_type(self.context_type) + if hasattr(self, "result_type"): + self._check_result_type(self.result_type) + return self @abc.abstractmethod @@ -228,9 +277,13 @@ def get_evaluation_context(model: CallableModelType, context: ContextType, as_di def wrapper(model, context=Signature.empty, *, _options: Optional[FlowOptions] = None, **kwargs): if not isinstance(model, CallableModel): raise TypeError(f"Can only decorate methods on CallableModels (not {type(model)}) with the flow decorator.") - if not isclass(model.context_type) or not issubclass(model.context_type, ContextBase): + if (not isclass(model.context_type) or not issubclass(model.context_type, ContextBase)) and not ( + get_origin(model.context_type) is Union and type(None) in get_args(model.context_type) + ): raise TypeError(f"Context type {model.context_type} must be a subclass of ContextBase") - if not isclass(model.result_type) or not issubclass(model.result_type, ResultBase): + if (not isclass(model.result_type) or not issubclass(model.result_type, ResultBase)) and not ( + get_origin(model.result_type) is Union and all(isclass(t) and issubclass(t, ResultBase) for t in get_args(model.result_type)) + ): raise TypeError(f"Result type {model.result_type} must be a subclass of ResultBase") if self._deps and fn.__name__ != "__deps__": raise ValueError("Can only apply Flow.deps decorator to __deps__") @@ -248,7 +301,11 @@ def wrapper(model, context=Signature.empty, *, _options: Optional[FlowOptions] = # Type coercion on input. We do this here (rather than relying on ModelEvaluationContext) as it produces a nicer traceback/error message if not isinstance(context, model.context_type): - context = model.context_type.model_validate(context) + if get_origin(model.context_type) is Union and type(None) in get_args(model.context_type): + model_context_type = [t for t in get_args(model.context_type) if t is not type(None)][0] + else: + model_context_type = model.context_type + context = model_context_type.model_validate(context) if fn != getattr(model.__class__, fn.__name__).__wrapped__: # This happens when super().__call__ is used when implementing a CallableModel that derives from another one. @@ -396,7 +453,8 @@ class ModelEvaluationContext( fn: str = Field("__call__", strict=True) options: Dict[str, Any] = Field(default_factory=dict) model: InstanceOf[_CallableModel] - context: InstanceOf[ContextBase] + context: Union[InstanceOf[ContextBase], None] + # Using InstanceOf instead of the actual type will limit Pydantic's validation of the field to instance checking # Otherwise, the validation will re-run fully despite the models already being validated on construction # TODO: Make the instance check compatible with the generic types instead of the base type @@ -431,42 +489,15 @@ def __call__(self) -> ResultType: elif hasattr(result, "_lazy_is_delayed"): object.__setattr__(result, "_lazy_validation_requested", True) elif hasattr(self.model, "result_type"): - result = self.model.result_type.model_validate(result) + result_type = self.model.result_type + if not isclass(result_type) or not issubclass(result_type, ResultBase): + raise TypeError(f"Model result_type {result_type} is not a subclass of ResultBase") + result = result_type.model_validate(result) return result else: return fn(self.context) - # When serialize_as_any=True, pydantic may detect repeated object ids in nested graphs - # (e.g., shared default lists) and raise a circular reference error during serialization. - # For computing cache keys, fall back to a minimal, stable representation if such an error occurs. - # This is similar to how we the pydantic docs here: - # https://docs.pydantic.dev/latest/concepts/forward_annotations/#cyclic-references - # handle cyclic references during serialization. - @model_serializer(mode="wrap") - def _serialize_model_evaluation_context(self, handler: SerializerFunctionWrapHandler): - try: - return handler(self) - except ValueError as exc: - msg = str(exc) - if "Circular reference" not in msg and "id repeated" not in msg: - raise - # Minimal, stable representation sufficient for cache-key tokenization - try: - model_repr = self.model.model_dump(mode="python", serialize_as_any=True, by_alias=True) - except Exception: - model_repr = repr(self.model) - try: - context_repr = self.context.model_dump(mode="python", serialize_as_any=True, by_alias=True) - except Exception: - context_repr = repr(self.context) - return dict( - fn=self.fn, - model=model_repr, - context=context_repr, - options=dict(self.options), - ) - class EvaluatorBase(_CallableModel, abc.ABC): """Base class for evaluators, which are higher-order models that evaluate ModelAndContext. @@ -532,9 +563,26 @@ def context_type(self) -> Type[ContextType]: """ typ = _cached_signature(self.__class__.__call__).parameters["context"].annotation if typ is Signature.empty: - raise TypeError("Must either define a type annotation for context on __call__ or implement 'context_type'") - if not issubclass(typ, ContextBase): - raise TypeError(f"Context type declared in signature of __call__ must be a subclass of ContextBase. Received {typ}.") + if isinstance(self, CallableModelGenericType) and hasattr(self, "_context_generic_type"): + typ = self._context_generic_type + else: + raise TypeError("Must either define a type annotation for context on __call__ or implement 'context_type'") + elif ( + isinstance(self, CallableModelGenericType) and hasattr(self, "_context_generic_type") and not issubclass(typ, self._context_generic_type) + ): + raise TypeError( + f"Context type annotation {typ} on __call__ does not match context_type {self._context_generic_type} defined by CallableModelGenericType" + ) + + # If optional type, extract inner type + if get_origin(typ) is Optional or (get_origin(typ) is Union and type(None) in get_args(typ)): + type_to_check = [t for t in get_args(typ) if t is not type(None)][0] + else: + type_to_check = typ + + # Ensure subclass of ContextBase + if not isclass(type_to_check) or not issubclass(type_to_check, ContextBase): + raise TypeError(f"Context type declared in signature of __call__ must be a subclass of ContextBase. Received {type_to_check}.") return typ @@ -547,8 +595,37 @@ def result_type(self) -> Type[ResultType]: """ typ = _cached_signature(self.__class__.__call__).return_annotation if typ is Signature.empty: - raise TypeError("Must either define a return type annotation on __call__ or implement 'result_type'") - if not issubclass(typ, ResultBase): + if isinstance(self, CallableModelGenericType) and hasattr(self, "_result_generic_type"): + typ = self._result_generic_type + else: + raise TypeError("Must either define a return type annotation on __call__ or implement 'result_type'") + elif isinstance(self, CallableModelGenericType) and hasattr(self, "_result_generic_type"): + if get_origin(typ) is Union and get_origin(self._result_generic_type) is Union: + if set(get_args(typ)) != set(get_args(self._result_generic_type)): + raise TypeError( + f"Return type annotation {typ} on __call__ does not match result_type {self._result_generic_type} defined by CallableModelGenericType" + ) + elif get_origin(typ) is Union: + raise NotImplementedError( + "Return type annotation on __call__ is a Union, but result_type defined by CallableModelGenericType is not a Union. This case is not yet supported." + ) + elif get_origin(self._result_generic_type) is Union: + raise NotImplementedError( + "Return type annotation on __call__ is not a Union, but result_type defined by CallableModelGenericType is a Union. This case is not yet supported." + ) + elif not issubclass(typ, self._result_generic_type): + raise TypeError( + f"Return type annotation {typ} on __call__ does not match result_type {self._result_generic_type} defined by CallableModelGenericType" + ) + + # If union type, extract inner type + if get_origin(typ) is Union: + raise TypeError( + "Model __call__ signature result type cannot be a Union type without a concrete property. Please define a property 'result_type' on the model." + ) + + # Ensure subclass of ResultBase + if not isclass(typ) or not issubclass(typ, ResultBase): raise TypeError(f"Return type declared in signature of __call__ must be a subclass of ResultBase (i.e. GenericResult). Received {typ}.") return typ @@ -586,78 +663,103 @@ def result_type(self) -> Type[ResultType]: return self.model.result_type -class CallableModelGenericType(CallableModel, Generic[ContextType, ResultType]): +class CallableModelGeneric(CallableModel, Generic[ContextType, ResultType]): """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]] + _context_generic_type: ClassVar[Type[ContextType]] + _result_generic_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 + def __setstate__(self, state): + self._determine_context_result() + super().__setstate__(state) - 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)}") + @classmethod + def __pydantic_init_subclass__(cls, **kwargs): + super().__pydantic_init_subclass__(**kwargs) + cls._determine_context_result() + @classmethod + def _determine_context_result(cls): # Extract the generic types from the class definition - if not hasattr(cls, "_context_type") or not hasattr(cls, "_result_type"): + if not hasattr(cls, "_context_generic_type") or not hasattr(cls, "_result_generic_type"): new_context_type = None new_result_type = None - for base in cls.__mro__[1:]: - if issubclass(base, CallableModelGenericType): + + for base in cls.__mro__: + if issubclass(base, CallableModelGeneric): # 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 new_context_type is None and hasattr(base, "_context_generic_type") and issubclass(base._context_generic_type, ContextBase): + new_context_type = base._context_generic_type + if ( + new_result_type is None + and hasattr(base, "_result_generic_type") + and ( + issubclass(base._result_generic_type, ResultBase) + or ( + get_origin(base._result_generic_type) is Union + and all(isclass(t) and issubclass(t, ResultBase) for t in get_args(base._result_generic_type)) + ) + ) + ): + new_result_type = base._result_generic_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): + if len(base.__pydantic_generic_metadata__["args"]) >= 2: + # Assume order is ContextType, ResultType + arg0, arg1 = base.__pydantic_generic_metadata__["args"][:2] + if new_context_type is None and isinstance(arg0, type) and issubclass(arg0, ContextBase): + new_context_type = arg0 + if new_result_type is None and ( + (isinstance(arg1, type) and issubclass(arg1, ResultBase)) + or (get_origin(arg1) is Union and all(isclass(t) and issubclass(t, ResultBase) for t in get_args(arg1))) + ): # NOTE: ContextBase inherits from ResultBase, so order matters here! - new_result_type = arg + new_result_type = arg1 + else: + 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)) + or (get_origin(arg) is Union and all(isclass(t) and issubclass(t, ResultBase) for t in get_args(arg))) + ): + # 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 + cls._context_generic_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 + cls._result_generic_type = new_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) + elif isinstance(m, cls): + 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)}") subtypes = cls.__pydantic_generic_metadata__["args"] if subtypes: TypeAdapter(Type[subtypes[0]]).validate_python(m.context_type) TypeAdapter(Type[subtypes[1]]).validate_python(m.result_type) + return m + + +CallableModelGenericType = CallableModelGeneric diff --git a/ccflow/compose.py b/ccflow/compose.py new file mode 100644 index 0000000..c35809a --- /dev/null +++ b/ccflow/compose.py @@ -0,0 +1,119 @@ +from typing import Any, Dict, Optional, Type, Union + +from .base import BaseModel +from .exttypes.pyobjectpath import _TYPE_ADAPTER as PyObjectPathTA + +__all__ = ( + "model_alias", + "from_python", + "update_from_template", +) + + +def model_alias(model_name: str) -> BaseModel: + """Return a model by alias from the registry. + + Hydra-friendly: `_target_: ccflow.compose.model_alias` with `model_name`. + + Args: + model_name: Alias string registered in the model registry. Typically a + short name that maps to a configured BaseModel. + + Returns: + A ``BaseModel`` instance resolved from the registry by ``model_name``. + """ + return BaseModel.model_validate(model_name) + + +def from_python(py_object_path: str, indexer: Optional[list] = None) -> Any: + """Hydra-friendly: resolve and return any Python object by import path. + + Optionally accepts ``indexer``, a list of keys that will be applied in + order to index into the resolved object. No safety checks are performed; + indexing errors will propagate. + + Args: + py_object_path: Dotted import path to a Python object, e.g. + ``mypkg.module.OBJECT`` or ``mypkg.module.ClassName``. + indexer: Optional list of keys to apply in order to index into the + resolved object (e.g., strings for dict keys or integers for list + indexes). + + Returns: + The resolved Python object, or the value obtained after applying all + ``indexer`` keys to the resolved object. + + Example YAML usage: + some_value: + _target_: ccflow.compose.from_python + py_object_path: mypkg.module.OBJECT + + nested_value: + _target_: ccflow.compose.from_python + py_object_path: mypkg.module.NESTED + indexer: ["a", "b"] + """ + obj = PyObjectPathTA.validate_python(py_object_path).object + if indexer: + for key in indexer: + obj = obj[key] + return obj + + +def update_from_template( + base: Optional[Union[str, Dict[str, Any], BaseModel]] = None, + *, + target_class: Optional[Union[str, Type]] = None, + update: Optional[Dict[str, Any]] = None, +) -> Any: + """Generic update helper that constructs an instance from a base and updates. + + Args: + base: Either a registry alias string, a dict, or a Pydantic BaseModel. If BaseModel, it is converted + to a shallow dict via ``dict(base)`` to preserve nested object identity. + target_class: Optional path to the target class to construct. May be a + string import path or the type itself. If None and ``base`` is a + BaseModel, returns an instance of ``base.__class__``. If None and + ``base`` is a dict, returns the updated dict. + update: Optional dict of updates to apply. + + Returns: + Instance of ``target_class`` if provided; otherwise an instance of the same + class as ``base`` when base is a BaseModel; or the updated dict when base + is a dict. + """ + # Determine base dict and default target + default_target = None + if isinstance(base, str): + # Allow passing alias name directly; resolve from registry + base = model_alias(base) + if isinstance(base, BaseModel): + base_dict = dict(base) + default_target = base.__class__ + elif isinstance(base, dict): + base_dict = dict(base) + elif base is None: + base_dict = {} + else: + raise TypeError("base must be a dict, BaseModel, or None") + + # Merge updates: explicit dict first, then kwargs + if update: + base_dict.update(update) + + # Resolve target class if provided as string path + target = None + if target_class is not None: + if isinstance(target_class, str): + target = PyObjectPathTA.validate_python(target_class).object + else: + target = target_class + else: + target = default_target + + if target is None: + # No target: return dict update for dict base + return base_dict + + # Construct instance of target with updated fields + return target(**base_dict) diff --git a/ccflow/examples/etl/__init__.py b/ccflow/examples/etl/__init__.py new file mode 100644 index 0000000..991a1a6 --- /dev/null +++ b/ccflow/examples/etl/__init__.py @@ -0,0 +1,25 @@ +from pathlib import Path +from typing import List, Optional + +from ccflow import RootModelRegistry, load_config as load_config_base + +__all__ = ("load_config",) + + +def load_config( + config_dir: str = "", + config_name: str = "", + overrides: Optional[List[str]] = None, + *, + overwrite: bool = True, + basepath: str = "", +) -> RootModelRegistry: + return load_config_base( + root_config_dir=str(Path(__file__).resolve().parent / "config"), + root_config_name="base", + config_dir=config_dir, + config_name=config_name, + overrides=overrides, + overwrite=overwrite, + basepath=basepath, + ) diff --git a/ccflow/examples/etl/__main__.py b/ccflow/examples/etl/__main__.py new file mode 100644 index 0000000..73f13c9 --- /dev/null +++ b/ccflow/examples/etl/__main__.py @@ -0,0 +1,39 @@ +import hydra + +from ccflow.utils.hydra import cfg_run + +__all__ = ("main",) + + +@hydra.main(config_path="config", config_name="base", version_base=None) +def main(cfg): + cfg_run(cfg) + + +# Extract step: +# python -m ccflow.examples.etl +callable=extract +context=[] +# Change url, as example of context override: +# python -m ccflow.examples.etl +callable=extract +context=["http://lobste.rs"] +# Change file name, as example of callable override: +# python -m ccflow.examples.etl +callable=extract +context=["http://lobste.rs"] ++extract.publisher.name=lobsters + +# Transform step: +# python -m ccflow.examples.etl +callable=transform +context=[] +# python -m ccflow.examples.etl +callable=transform +context=[] ++transform.model.file=lobsters.html ++transform.publisher.name=lobsters + +# Load step: +# python -m ccflow.examples.etl +callable=load +context=[] +# python -m ccflow.examples.etl +callable=load +context=[] ++load.file=lobsters.csv ++load.db_file=":memory:" + +# View SQLite DB: +# sqlite3 etl.db +# .tables +# select * from links; +# .quit + +# [project.scripts] +# etl = "ccflow.examples.etl:main" +# etl-explain = "ccflow.examples.etl:explain" + +if __name__ == "__main__": + main() diff --git a/ccflow/examples/etl/config/__init__.py b/ccflow/examples/etl/config/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/ccflow/examples/etl/config/base.yaml b/ccflow/examples/etl/config/base.yaml new file mode 100644 index 0000000..77c4421 --- /dev/null +++ b/ccflow/examples/etl/config/base.yaml @@ -0,0 +1,32 @@ +extract: + _target_: ccflow.PublisherModel + model: + _target_: ccflow.examples.etl.models.RestModel + publisher: + _target_: ccflow.publishers.GenericFilePublisher + name: raw + suffix: .html + field: value + +transform: + _target_: ccflow.PublisherModel + model: + _target_: ccflow.examples.etl.models.LinksModel + file: ${extract.publisher.name}${extract.publisher.suffix} + publisher: + _target_: ccflow.publishers.GenericFilePublisher + name: extracted + suffix: .csv + field: value + +load: + _target_: ccflow.examples.etl.models.DBModel + file: ${transform.publisher.name}${transform.publisher.suffix} + db_file: etl.db + table: links + +# Alternative multi-file approach +# defaults: +# - extract: rest +# - transform: links +# - load: db diff --git a/ccflow/examples/etl/config/extract/rest.yaml b/ccflow/examples/etl/config/extract/rest.yaml new file mode 100644 index 0000000..302638f --- /dev/null +++ b/ccflow/examples/etl/config/extract/rest.yaml @@ -0,0 +1,8 @@ +_target_: ccflow.PublisherModel +model: + _target_: ccflow.examples.etl.models.RestModel +publisher: + _target_: ccflow.publishers.GenericFilePublisher + name: raw + suffix: .html +field: value diff --git a/ccflow/examples/etl/config/load/db.yaml b/ccflow/examples/etl/config/load/db.yaml new file mode 100644 index 0000000..83792a2 --- /dev/null +++ b/ccflow/examples/etl/config/load/db.yaml @@ -0,0 +1,4 @@ +_target_: ccflow.examples.etl.models.DBModel +file: ${transform.publisher.name}${transform.publisher.suffix} +db_file: etl.db +table: links diff --git a/ccflow/examples/etl/config/transform/links.yaml b/ccflow/examples/etl/config/transform/links.yaml new file mode 100644 index 0000000..3678309 --- /dev/null +++ b/ccflow/examples/etl/config/transform/links.yaml @@ -0,0 +1,9 @@ +_target_: ccflow.PublisherModel +model: + _target_: ccflow.examples.etl.models.LinksModel + file: ${extract.publisher.name}${extract.publisher.suffix} +publisher: + _target_: ccflow.publishers.GenericFilePublisher + name: extracted + suffix: .csv +field: value diff --git a/ccflow/examples/etl/explain.py b/ccflow/examples/etl/explain.py new file mode 100644 index 0000000..d3ea35d --- /dev/null +++ b/ccflow/examples/etl/explain.py @@ -0,0 +1,13 @@ +from ccflow.utils.hydra import cfg_explain_cli + +from .__main__ import main + +__all__ = ("explain",) + + +def explain(): + cfg_explain_cli(config_path="config", config_name="base", hydra_main=main) + + +if __name__ == "__main__": + explain() diff --git a/ccflow/examples/etl/models.py b/ccflow/examples/etl/models.py new file mode 100644 index 0000000..3b434d6 --- /dev/null +++ b/ccflow/examples/etl/models.py @@ -0,0 +1,76 @@ +import sqlite3 +from csv import DictReader, DictWriter +from io import StringIO +from typing import Optional + +from bs4 import BeautifulSoup +from httpx import Client +from pydantic import Field + +from ccflow import CallableModel, ContextBase, Flow, GenericResult, NullContext + +__all__ = ("RestModel", "LinksModel", "DBModel", "SiteContext") + + +class SiteContext(ContextBase): + """An example of a context object, passed into and between callable models from the command line.""" + + site: str = Field(default="https://en.wikipedia.org/wiki/Main_Page") + + +class RestModel(CallableModel): + """Example callable model that fetches a URL and returns the HTML content.""" + + @Flow.call + def __call__(self, context: Optional[SiteContext] = None) -> GenericResult[str]: + context = context or SiteContext() + resp = Client().get(context.site, headers={"User-Agent": "Safari/537.36"}, follow_redirects=True) + resp.raise_for_status() + + return GenericResult[str](value=resp.text) + + +class LinksModel(CallableModel): + """Example callable model that transforms HTML content into CSV of links.""" + + file: str + + @Flow.call + def __call__(self, context: Optional[NullContext] = None) -> GenericResult[str]: + context = context or NullContext() + + with open(self.file, "r") as f: + html = f.read() + + # Use beautifulsoup to convert links into csv of name, url + soup = BeautifulSoup(html, "html.parser") + links = [{"name": a.text, "url": href} for a in soup.find_all("a", href=True) if (href := a["href"]).startswith("http")] + + io = StringIO() + writer = DictWriter(io, fieldnames=["name", "url"]) + writer.writeheader() + writer.writerows(links) + output = io.getvalue() + return GenericResult[str](value=output) + + +class DBModel(CallableModel): + """Example callable model that loads CSV data into a SQLite database.""" + + file: str + db_file: str = Field(default="etl.db") + table: str = Field(default="links") + + @Flow.call + def __call__(self, context: Optional[NullContext] = None) -> GenericResult[str]: + context = context or NullContext() + + conn = sqlite3.connect(self.db_file) + cursor = conn.cursor() + cursor.execute(f"CREATE TABLE IF NOT EXISTS {self.table} (name TEXT, url TEXT)") + with open(self.file, "r") as f: + reader = DictReader(f) + for row in reader: + cursor.execute(f"INSERT INTO {self.table} (name, url) VALUES (?, ?)", (row["name"], row["url"])) + conn.commit() + return GenericResult[str](value="Data loaded into database") diff --git a/ccflow/exttypes/polars.py b/ccflow/exttypes/polars.py index a833bb0..cdff883 100644 --- a/ccflow/exttypes/polars.py +++ b/ccflow/exttypes/polars.py @@ -1,18 +1,17 @@ import math from io import StringIO -from typing import Any +from typing import Annotated, Any import numpy as np import orjson import polars as pl from packaging import version -from pydantic import TypeAdapter from typing_extensions import Self __all__ = ("PolarsExpression",) -class PolarsExpression(pl.Expr): +class _PolarsExprPydanticAnnotation: """Provides a polars expressions from a string""" @classmethod @@ -68,10 +67,6 @@ def _validate(cls, value: Any) -> Self: raise ValueError(f"Supplied value '{value}' cannot be converted to a Polars expression") - @classmethod - def validate(cls, value: Any) -> Self: - """Try to convert/validate an arbitrary value to a PolarsExpression.""" - return _TYPE_ADAPTER.validate_python(value) - -_TYPE_ADAPTER = TypeAdapter(PolarsExpression) +# Public annotated type for Polars expressions +PolarsExpression = Annotated[pl.Expr, _PolarsExprPydanticAnnotation] diff --git a/ccflow/result/__init__.py b/ccflow/result/__init__.py index bb87dd2..cd38fca 100644 --- a/ccflow/result/__init__.py +++ b/ccflow/result/__init__.py @@ -1,2 +1,3 @@ from .dict import * from .generic import * +from .list import * diff --git a/ccflow/result/list.py b/ccflow/result/list.py new file mode 100644 index 0000000..5ac7f2e --- /dev/null +++ b/ccflow/result/list.py @@ -0,0 +1,12 @@ +from typing import Generic, List, TypeVar + +from ..base import ResultBase + +__all__ = ("ListResult",) + + +V = TypeVar("V") + + +class ListResult(ResultBase, Generic[V]): + value: List[V] diff --git a/ccflow/tests/config/conf_from_python.yaml b/ccflow/tests/config/conf_from_python.yaml new file mode 100644 index 0000000..8cb1c5d --- /dev/null +++ b/ccflow/tests/config/conf_from_python.yaml @@ -0,0 +1,23 @@ +shared_model: + _target_: ccflow.compose.from_python + py_object_path: ccflow.tests.data.python_object_samples.SHARED_MODEL + +consumer: + _target_: ccflow.tests.data.python_object_samples.Consumer + shared: shared_model + tag: consumer1 + +# Demonstrate from_python returning a dict (non-BaseModel) +holder: + _target_: ccflow.tests.data.python_object_samples.SharedHolder + name: holder1 + cfg: + _target_: ccflow.compose.from_python + py_object_path: ccflow.tests.data.python_object_samples.SHARED_CFG + +# Use update_from_template to update a field while preserving shared identity +consumer_updated: + _target_: ccflow.compose.update_from_template + base: consumer + update: + tag: consumer2 diff --git a/ccflow/tests/data/__init__.py b/ccflow/tests/data/__init__.py new file mode 100644 index 0000000..c4b4eb5 --- /dev/null +++ b/ccflow/tests/data/__init__.py @@ -0,0 +1,4 @@ +"""Shared test data modules. + +Import sample configs using module-level objects in `python_object_samples`. +""" diff --git a/ccflow/tests/data/python_object_samples.py b/ccflow/tests/data/python_object_samples.py new file mode 100644 index 0000000..8739f25 --- /dev/null +++ b/ccflow/tests/data/python_object_samples.py @@ -0,0 +1,33 @@ +"""Sample python objects for testing from_python and identity preservation.""" + +from typing import Dict + +from ccflow import BaseModel + +# Module-level objects +SHARED_CFG: Dict[str, int] = {"x": 1, "y": 2} +OTHER_CFG: Dict[str, int] = {"x": 10, "y": 20} +"""Dict samples; identity for dicts is not guaranteed by Pydantic.""" + +NESTED_CFG = { + "db": {"host": "seed.local", "port": 7000, "name": "seed"}, + "meta": {"env": "dev"}, +} + + +class SharedHolder(BaseModel): + name: str + cfg: Dict[str, int] + + +class SharedModel(BaseModel): + val: int = 0 + + +# Module-level instance to be resolved via from_python +SHARED_MODEL = SharedModel(val=42) + + +class Consumer(BaseModel): + shared: SharedModel + tag: str = "" diff --git a/ccflow/tests/examples/test_etl.py b/ccflow/tests/examples/test_etl.py new file mode 100644 index 0000000..546f92f --- /dev/null +++ b/ccflow/tests/examples/test_etl.py @@ -0,0 +1,50 @@ +from tempfile import NamedTemporaryFile +from unittest.mock import patch + +from ccflow.examples.etl.__main__ import main +from ccflow.examples.etl.explain import explain +from ccflow.examples.etl.models import DBModel, LinksModel, RestModel, SiteContext + + +class TestEtl: + def test_rest_model(self): + rest = RestModel() + context = SiteContext(site="https://en.wikipedia.org/wiki/Main_Page") + result = rest(context) + assert result.value is not None + assert "Wikipedia" in result.value + + def test_links_model(self): + with NamedTemporaryFile(suffix=".html") as file: + file.write(b""" + + + Page 1 + Page 2 + + + """) + file.flush() + links = LinksModel(file=file.name) + result = links() + assert result.value is not None + assert "name,url" in result.value # Check for CSV header + + def test_db_model(self): + with NamedTemporaryFile(suffix=".csv", mode="w+", delete=False) as file: + file.write("name,url\nPage 1,https://example.com/page1\nPage 2,https://example.com/page2\n") + file.flush() + db = DBModel(file=file.name, db_file=":memory:", table="links") + result = db() + assert result.value == "Data loaded into database" + + def test_cli(self): + with patch("ccflow.examples.etl.__main__.cfg_run") as mock_cfg_run: + with patch("sys.argv", ["etl", "+callable=extract", "+context=[]"]): + main() + mock_cfg_run.assert_called_once() + + def test_explain(self): + with patch("ccflow.examples.etl.explain.cfg_explain_cli") as mock_cfg_explain: + explain() + mock_cfg_explain.assert_called_once() diff --git a/ccflow/tests/exttypes/test_polars.py b/ccflow/tests/exttypes/test_polars.py index 4704e83..e2afb9c 100644 --- a/ccflow/tests/exttypes/test_polars.py +++ b/ccflow/tests/exttypes/test_polars.py @@ -1,56 +1,84 @@ import math -from unittest import TestCase import numpy as np import polars as pl +import pytest import scipy from packaging import version -from pydantic import TypeAdapter +from pydantic import TypeAdapter, ValidationError +from ccflow import BaseModel from ccflow.exttypes.polars import PolarsExpression -class TestPolarsExpression(TestCase): - def test_expression(self): - expression = pl.col("Col1") + pl.col("Col2") - self.assertEqual(PolarsExpression.validate(expression).meta.serialize(), expression.meta.serialize()) +def test_expression_passthrough(): + adapter = TypeAdapter(PolarsExpression) + expression = pl.col("Col1") + pl.col("Col2") + result = adapter.validate_python(expression) + assert result.meta.serialize() == expression.meta.serialize() - def test_expression_deserialization(self): - expression = PolarsExpression.validate("pl.col('Col1') + pl.col('Col2')") - expected_result = pl.col("Col1") + pl.col("Col2") - self.assertEqual(expression.meta.serialize(), expected_result.meta.serialize()) +def test_expression_from_string(): + adapter = TypeAdapter(PolarsExpression) + expected_result = pl.col("Col1") + pl.col("Col2") + expression = adapter.validate_python("pl.col('Col1') + pl.col('Col2')") + assert expression.meta.serialize() == expected_result.meta.serialize() - def test_expression_complex(self): - expression = PolarsExpression.validate( - "col('Col1') + (sp.linalg.det(numpy.eye(2, dtype=int)) - 1 ) * math.pi * c('Col2') + polars.col('Col2')" - ) - expected_result = pl.col("Col1") + (scipy.linalg.det(np.eye(2, dtype=int)) - 1) * math.pi * pl.col("Col2") + pl.col("Col2") - self.assertEqual( - PolarsExpression.validate(expression).meta.serialize(), - expected_result.meta.serialize(), - ) +def test_expression_complex(): + adapter = TypeAdapter(PolarsExpression) + expected_result = pl.col("Col1") + (scipy.linalg.det(np.eye(2, dtype=int)) - 1) * math.pi * pl.col("Col2") + pl.col("Col2") + expression = adapter.validate_python("col('Col1') + (sp.linalg.det(numpy.eye(2, dtype=int)) - 1 ) * math.pi * c('Col2') + polars.col('Col2')") + assert expression.meta.serialize() == expected_result.meta.serialize() - def test_validation_failure(self): - with self.assertRaises(ValueError): - PolarsExpression.validate(None) - with self.assertRaises(ValueError): - PolarsExpression.validate("pl.DataFrame()") +def test_validation_failure(): + adapter = TypeAdapter(PolarsExpression) + with pytest.raises(ValidationError): + adapter.validate_python(None) + with pytest.raises(ValidationError): + adapter.validate_python("pl.DataFrame()") - def test_validation_eval_failure(self): - with self.assertRaises(ValueError): - PolarsExpression.validate("invalid_statement") - def test_json_serialization(self): - expression = pl.col("Col1") + pl.col("Col2") - json_result = TypeAdapter(PolarsExpression).dump_json(expression) - if version.parse(pl.__version__) < version.parse("1.0.0"): - self.assertEqual(json_result.decode("utf-8"), expression.meta.serialize()) - else: - # polars serializes into a binary format by default. - self.assertEqual(json_result.decode("utf-8"), expression.meta.serialize(format="json")) +def test_validation_eval_failure(): + adapter = TypeAdapter(PolarsExpression) + with pytest.raises(ValidationError): + adapter.validate_python("invalid_statement") - expected_result = TypeAdapter(PolarsExpression).validate_json(json_result) - self.assertEqual(expected_result.meta.serialize(), expression.meta.serialize()) + +def test_json_serialization_roundtrip(): + adapter = TypeAdapter(PolarsExpression) + expression = pl.col("Col1") + pl.col("Col2") + json_result = adapter.dump_json(expression) + if version.parse(pl.__version__) < version.parse("1.0.0"): + assert json_result.decode("utf-8") == expression.meta.serialize() + else: + assert json_result.decode("utf-8") == expression.meta.serialize(format="json") + + expected_result = adapter.validate_json(json_result) + assert expected_result.meta.serialize() == expression.meta.serialize() + + +def test_model_field_and_dataframe_filter(): + class DummyExprModel(BaseModel): + expr: PolarsExpression + + m = DummyExprModel(expr="pl.col('x') > 10") + assert isinstance(m.expr, pl.Expr) + + df = pl.DataFrame({"x": [5, 10, 11, 20], "y": [1, 2, 3, 4]}) + filtered = df.filter(m.expr) + assert filtered.select("x").to_series().to_list() == [11, 20] + + +def test_model_field_and_dataframe_with_columns(): + class DummyExprModel(BaseModel): + expr: PolarsExpression + + raw_expr = 'pl.col("x").rolling_max(window_size=2)' + m = DummyExprModel(expr=raw_expr) + assert isinstance(m.expr, pl.Expr) + + df = pl.DataFrame({"x": [5, 19, 17, 13, 8, 20], "y": [1, 2, 3, 4, 5, 6]}) + transformed = df.select(m.expr) + assert transformed.to_series().to_list() == [None, 19, 19, 17, 13, 20] diff --git a/ccflow/tests/test_callable.py b/ccflow/tests/test_callable.py index 2d3488e..6920190 100644 --- a/ccflow/tests/test_callable.py +++ b/ccflow/tests/test_callable.py @@ -1,7 +1,10 @@ -from typing import Generic, List, TypeVar +from pickle import dumps as pdumps, loads as ploads +from typing import Generic, List, Optional, Tuple, Type, TypeVar, Union from unittest import TestCase +import ray from pydantic import ValidationError +from ray.cloudpickle import dumps as rcpdumps, loads as rcploads from ccflow import ( CallableModel, @@ -47,6 +50,13 @@ def __call__(self, context: MyContext) -> MyResult: return MyResult(x=self.i, y=context.a) +class MyCallableOptionalContext(CallableModel): + @Flow.call + def __call__(self, context: Optional[MyContext] = None) -> MyResult: + context = context or MyContext(a="default") + return MyResult(x=1, y=context.a) + + class MyCallableChild(MyCallable): pass @@ -95,35 +105,96 @@ def __call__(self, context: MyContext) -> MyContext: return context -class BadModel1(CallableModel): +class BadModelNoContextNoResult(CallableModel): @Flow.call def __call__(self, context): return None -class BadModel2(CallableModel): +class BadModelNeedRealTypes(CallableModel): @Flow.call def __call__(self, context: ContextType) -> ResultType: return None -class BadModel3(CallableModel): +class BadModelMissingFlowCallDecorator(CallableModel): + """Model missing Flow.call decorator""" + + def __call__(self, context: MyContext) -> MyResult: + return MyResult(x=1, y="foo") + + +class BadModelMissingFlowDepsDecorator(CallableModel): + """Model missing Flow.deps decorator""" + + def __deps__(self, context: MyContext) -> GraphDepList: + return [] + + @Flow.call def __call__(self, context: MyContext) -> MyResult: return MyResult(x=1, y="foo") -class BadModel4(CallableModel): +class BadModelMissingContextArg(CallableModel): @Flow.call def __call__(self, custom_arg: MyContext) -> MyResult: return custom_arg -class BadModel5(CallableModel): +class BadModelDoubleContextArg(CallableModel): @Flow.call def __call__(self, context: MyContext, context2: MyContext) -> MyResult: return context +class BadModelMismatchedContextAndCall(CallableModel): + """Model with mismatched context_type and __call__ annotation""" + + @property + def context_type(self): + return NullContext + + @property + def result_type(self): + return MyResult + + @Flow.call + def __call__(self, context: MyContext) -> MyResult: + return context + + +class BadModelGenericMismatchedContextAndCall(CallableModelGenericType[NullContext, MyResult]): + """Model with mismatched context_type and __call__ annotation""" + + @Flow.call + def __call__(self, context: MyContext) -> MyResult: + return context + + +class BadModelMismatchedResultAndCall(CallableModel): + """Model with mismatched result_type and __call__ annotation""" + + @property + def context_type(self): + return NullContext + + @property + def result_type(self): + return GenericResult + + @Flow.call + def __call__(self, context: NullContext) -> MyResult: + return context + + +class BadModelGenericMismatchedResultAndCall(CallableModelGenericType[NullContext, GenericResult]): + """Model with mismatched result_type and __call__ annotation""" + + @Flow.call + def __call__(self, context: NullContext) -> MyResult: + return context + + class MyWrapper(WrapperModel[MyCallable]): """This wrapper model specifically takes a MyCallable instance for 'model'""" @@ -146,6 +217,125 @@ class MyTest(ContextBase): c: MyContext +TContext = TypeVar("TContext", bound=ContextBase) +TResult = TypeVar("TResult", bound=ResultBase) + + +class MyCallableBase(CallableModelGenericType[TContext, TResult]): + pass + + +class MyCallableImpl(MyCallableBase[NullContext, GenericResult[int]]): + pass + + +class MyCallableFromGeneric(MyCallableImpl): + @Flow.call + def __call__(self, context: NullContext) -> GenericResult[int]: + return GenericResult[int](value=42) + + +class MyNullContext(NullContext): ... + + +class MyCallableFromGenericNullContext(MyCallableImpl): + @Flow.call + def __call__(self, context: MyNullContext) -> GenericResult[int]: + return GenericResult[int](value=42) + + +class BaseGeneric(CallableModelGenericType[ContextType, ResultType], Generic[ContextType, ResultType]): ... + + +class NextGeneric(BaseGeneric[ContextType, ResultType], Generic[ContextType, ResultType]): ... + + +class PartialGeneric(NextGeneric[NullContext, ResultType], Generic[ResultType]): ... + + +class LastGeneric(PartialGeneric[GenericResult[int]]): + @Flow.call + def __call__(self, context: NullContext) -> GenericResult[int]: + return GenericResult[int](value=42) + + +class PartialGenericReversed(NextGeneric[ContextType, GenericResult[int]], Generic[ContextType]): ... + + +class LastGenericReversed(PartialGenericReversed[NullContext]): + @Flow.call + def __call__(self, context: NullContext) -> GenericResult[int]: + return GenericResult[int](value=42) + + +class AResult(ResultBase): + a: int + + +class BResult(ResultBase): + b: str + + +class UnionReturn(CallableModel): + @property + def result_type(self) -> Type[ResultType]: + return AResult + + @Flow.call + def __call__(self, context: NullContext) -> Union[AResult, BResult]: + # Return one branch of the Union + return AResult(a=1) + + +class BadModelUnionReturnNoProperty(CallableModel): + @Flow.call + def __call__(self, context: NullContext) -> Union[AResult, BResult]: + # Return one branch of the Union + return AResult(a=1) + + +class UnionReturnGeneric(CallableModelGenericType[NullContext, Union[AResult, BResult]]): + @property + def result_type(self) -> Type[ResultType]: + return AResult + + @Flow.call + def __call__(self, context: NullContext) -> Union[AResult, BResult]: + # Return one branch of the Union + return AResult(a=1) + + +class BadModelUnionReturnGeneric(CallableModelGenericType[NullContext, Union[AResult, BResult]]): + @Flow.call + def __call__(self, context: NullContext) -> Union[AResult, BResult]: + # Return one branch of the Union + return AResult(a=1) + + +class MyGenericContext(ContextBase, Generic[TContext]): + value: TContext + + +class ModelMixedGenericsEnforceContextMatch(CallableModel, Generic[TContext, TResult]): + model: CallableModelGenericType[TContext, TResult] + + @property + def context_type(self) -> Type[ContextType]: + return MyGenericContext[self.model.context_type] + + @property + def result_type(self) -> Type[ResultType]: + return GenericResult[self.model.result_type] + + @Flow.deps + def __deps__(self, context: MyGenericContext[TContext]) -> List[Tuple[CallableModelGenericType[TContext, TResult], List[ContextType]]]: + return [] + + @Flow.call + def __call__(self, context: MyGenericContext[TContext]) -> TResult: + return GenericResult(value=None) + + class TestContext(TestCase): def test_immutable(self): x = MyContext(a="foo") @@ -215,6 +405,13 @@ def test_signature(self): self.assertRaises(TypeError, m, context, a="foo") self.assertRaises(TypeError, m, context=context, a="foo") + def test_signature_optional_context(self): + m = MyCallableOptionalContext() + context = MyContext(a="foo") + target = m(context) + self.assertEqual(m(context=context), target) + self.assertEqual(m().y, "default") + def test_inheritance(self): m = MyCallableChild(i=5) self.assertEqual(m(MyContext(a="foo")), MyResult(x=5, y="foo")) @@ -245,22 +442,32 @@ def test_copy_on_validate(self): self.assertEqual(m.ll, m2.ll) def test_types(self): - m = BadModel1() - self.assertRaises(TypeError, lambda: m.context_type) - self.assertRaises(TypeError, lambda: m.result_type) + error = "Must either define a type annotation for context on __call__ or implement 'context_type'" + self.assertRaisesRegex(TypeError, error, BadModelNoContextNoResult) - m = BadModel2() - self.assertRaises(TypeError, lambda: m.context_type) - self.assertRaises(TypeError, lambda: m.result_type) + error = "Context type declared in signature of __call__ must be a subclass of ContextBase. Received ~ContextType" + self.assertRaisesRegex(TypeError, error, BadModelNeedRealTypes) error = "__call__ function of CallableModel must be wrapped with the Flow.call decorator" - self.assertRaisesRegex(ValueError, error, BadModel3) + self.assertRaisesRegex(ValueError, error, BadModelMissingFlowCallDecorator) + + error = "__deps__ function of CallableModel must be wrapped with the Flow.deps decorator" + self.assertRaisesRegex(ValueError, error, BadModelMissingFlowDepsDecorator) error = "__call__ method must take a single argument, named 'context'" - self.assertRaisesRegex(ValueError, error, BadModel4) + self.assertRaisesRegex(ValueError, error, BadModelMissingContextArg) error = "__call__ method must take a single argument, named 'context'" - self.assertRaisesRegex(ValueError, error, BadModel5) + self.assertRaisesRegex(ValueError, error, BadModelDoubleContextArg) + + error = "The context_type must match the type of the context accepted by __call__ " + self.assertRaisesRegex(ValueError, error, BadModelMismatchedContextAndCall) + + error = "The result_type must match the return type of __call__ " + self.assertRaisesRegex(ValueError, error, BadModelMismatchedResultAndCall) + + error = "Model __call__ signature result type cannot be a Union type without a concrete property. Please define a property 'result_type' on the model." + self.assertRaisesRegex(TypeError, error, BadModelUnionReturnNoProperty) def test_identity(self): # Make sure that an "identity" mapping works @@ -271,6 +478,16 @@ def test_identity(self): self.assertEqual(ident(context), context) self.assertIsNot(ident(context), context) + def test_context_call_match_enforcement_generic_base(self): + # This should not raise + _ = ModelMixedGenericsEnforceContextMatch(model=IdentityCallable()) + + def test_union_return(self): + m = UnionReturn() + result = m(NullContext()) + self.assertIsInstance(result, AResult) + self.assertEqual(result.a, 1) + class TestWrapperModel(TestCase): def test_wrapper(self): @@ -340,58 +557,80 @@ def __call__(self, context): self.assertEqual(m(NullContext()).value, 42) def test_use_as_base_class_inheritance(self): - TContext = TypeVar("TContext", bound=ContextBase) - TResult = TypeVar("TResult", bound=ResultBase) - - class MyCallableBase(CallableModelGenericType[TContext, TResult]): - pass - - class MyCallableImpl(MyCallableBase[NullContext, GenericResult[int]]): - pass - - class MyCallable(MyCallableImpl): - @Flow.call - def __call__(self, context: NullContext) -> GenericResult[int]: - return GenericResult[int](value=42) - - class DateRangeImplAnalyticDirect(MyCallableBase[NullContext, GenericResult[int]]): - @Flow.call - def __call__(self, context: NullContext) -> GenericResult[int]: - return GenericResult[int](value=42) - - m2 = MyCallable() + m2 = MyCallableFromGeneric() self.assertEqual(m2.context_type, NullContext) self.assertEqual(m2.result_type, GenericResult[int]) res2 = m2(NullContext()) self.assertEqual(res2.value, 42) + # test pickling + for dump, load in [(pdumps, ploads), (rcpdumps, rcploads)]: + dumped = dump(m2, protocol=5) + m3 = load(dumped) + self.assertEqual(m3.context_type, NullContext) + self.assertEqual(m3.result_type, GenericResult[int]) + res3 = m3(NullContext()) + self.assertEqual(res3.value, 42) + + def test_align_annotation_and_context_class(self): + m2 = MyCallableFromGenericNullContext() + self.assertEqual(m2.context_type, MyNullContext) + self.assertEqual(m2.result_type, GenericResult[int]) + res2 = m2(NullContext()) + self.assertEqual(res2.value, 42) + + # test pickling + for dump, load in [(pdumps, ploads), (rcpdumps, rcploads)]: + dumped = dump(m2, protocol=5) + m3 = load(dumped) + self.assertEqual(m3.context_type, MyNullContext) + self.assertEqual(m3.result_type, GenericResult[int]) + res3 = m3(NullContext()) + self.assertEqual(res3.value, 42) + def test_use_as_base_class_mixed_annotations(self): - class Base(CallableModelGenericType[ContextType, ResultType], Generic[ContextType, ResultType]): ... + m = LastGeneric() - class Next(Base[ContextType, ResultType], Generic[ContextType, ResultType]): ... + # test pickling + for dump, load in [(pdumps, ploads), (rcpdumps, rcploads)]: + dumped = dump(m, protocol=5) + m2 = load(dumped) + self.assertEqual(m2.context_type, NullContext) + self.assertEqual(m2.result_type, GenericResult[int]) + res2 = m2(NullContext()) + self.assertEqual(res2.value, 42) - class Partial(Next[NullContext, ResultType], Generic[ResultType]): ... + # test ray + @ray.remote + def calc(x) -> int: + return x(NullContext()).value - class Last(Partial[GenericResult[int]]): - @Flow.call - def __call__(self, context: NullContext) -> GenericResult[int]: - return GenericResult[int](value=42) + with ray.init(num_cpus=1): + res = ray.get(calc.remote(m)) - Last() + self.assertEqual(res, 42) def test_use_as_base_class_mixed_annotations_reversed(self): - class Base(CallableModelGenericType[ContextType, ResultType], Generic[ContextType, ResultType]): ... + m = LastGenericReversed() - class Next(Base[ContextType, ResultType], Generic[ContextType, ResultType]): ... + # test pickling + for dump, load in [(pdumps, ploads), (rcpdumps, rcploads)]: + dumped = dump(m, protocol=5) + m2 = load(dumped) + self.assertEqual(m2.context_type, NullContext) + self.assertEqual(m2.result_type, GenericResult[int]) + res2 = m2(NullContext()) + self.assertEqual(res2.value, 42) - class Partial(Next[ContextType, GenericResult[int]], Generic[ContextType]): ... + # test ray + @ray.remote + def calc(x) -> int: + return x(NullContext()).value - class Last(Partial[NullContext]): - @Flow.call - def __call__(self, context: NullContext) -> GenericResult[int]: - return GenericResult[int](value=42) + with ray.init(num_cpus=1): + res = ray.get(calc.remote(m)) - Last() + self.assertEqual(res, 42) def test_use_as_base_class_conflict(self): class MyCallable(CallableModelGenericType[NullContext, GenericResult[int]]): @@ -402,6 +641,35 @@ def __call__(self, context: NullContext) -> GenericResult[float]: with self.assertRaises(TypeError): MyCallable() + def test_types_generic(self): + error = "Context type annotation on __call__ does not match context_type defined by CallableModelGenericType" + self.assertRaisesRegex(TypeError, error, BadModelGenericMismatchedContextAndCall) + + error = "Return type annotation on __call__ does not match result_type defined by CallableModelGenericType" + self.assertRaisesRegex(TypeError, error, BadModelGenericMismatchedResultAndCall) + + error = "Model __call__ signature result type cannot be a Union type without a concrete property. Please define a property 'result_type' on the model." + self.assertRaisesRegex(TypeError, error, BadModelUnionReturnGeneric) + + def test_union_return_generic(self): + m = UnionReturnGeneric() + result = m(NullContext()) + self.assertIsInstance(result, AResult) + self.assertEqual(result.a, 1) + + def test_generic_validates_assignment(self): + class MyCallable(CallableModelGenericType[NullContext, GenericResult[int]]): + x: int = 1 + + @Flow.call + def __call__(self, context: NullContext) -> GenericResult[int]: + self.x = 5 + assert self.x == 5 + return GenericResult[float](value=self.x) + + m = MyCallable() + self.assertEqual(m(NullContext()).value, 5) + class TestCallableModelDeps(TestCase): def test_basic(self): @@ -466,7 +734,7 @@ def test_bad_annotation(self): MyCallableParent_bad_annotation(my_callable=m) msg = e.exception.errors()[0]["msg"] - target = "Value error, The type of the context accepted by __deps__ ~ContextType must match that accepted by __call__ !" + target = "Value error, The type of the context accepted by __deps__ ~ContextType must match that accepted by __call__ " self.assertEqual(msg, target) diff --git a/ccflow/tests/test_evaluation_context_serialization.py b/ccflow/tests/test_evaluation_context_serialization.py index 53cfe2a..cc6abb6 100644 --- a/ccflow/tests/test_evaluation_context_serialization.py +++ b/ccflow/tests/test_evaluation_context_serialization.py @@ -6,10 +6,6 @@ from ccflow.evaluators import GraphEvaluator, LoggingEvaluator, MultiEvaluator from ccflow.tests.evaluators.util import NodeModel -# NOTE: for these tests, round-tripping via JSON does not work -# because the ModelEvaluationContext just has an InstanceOf validation check -# and so we do not actually construct a full MEC on load. - def _make_nested_mec(model): ctx = DateContext(date=date(2022, 1, 1)) diff --git a/ccflow/tests/utils/test_compose.py b/ccflow/tests/utils/test_compose.py new file mode 100644 index 0000000..013a6bf --- /dev/null +++ b/ccflow/tests/utils/test_compose.py @@ -0,0 +1,230 @@ +from pydantic import Field + +from ccflow import BaseModel, ModelRegistry +from ccflow.compose import from_python, update_from_template + + +class DB(BaseModel): + host: str = Field(default="localhost") + port: int = Field(default=5432) + name: str = Field(default="default_db") + + +class Parent(BaseModel): + name: str = Field(default="default_name") + version: str = Field(default="0.0") + enabled: bool = Field(default=False) + child: DB + + +def setup_module(_): + ModelRegistry.root().clear() + r = ModelRegistry.root() + r.add("db_default", DB()) + r.add("db_other", DB(host="override.local", port=6543, name="other_db")) + r.add("parent", Parent(child=DB(name="child"))) + + +def teardown_module(_): + ModelRegistry.root().clear() + + +def test_update_from_template_returns_model_and_updates(): + # alias + update helper + base = BaseModel.model_validate("db_default") + m2 = update_from_template(base=base, update={"host": "h", "port": 100}) + assert isinstance(m2, DB) + assert m2.host == "h" + assert m2.port == 100 + + +def test_update_from_template_equivalent(): + base = BaseModel.model_validate("db_default") + m = update_from_template(base=base, update={"name": "x"}) + assert isinstance(m, DB) + assert m.name == "x" + + +def test_update_from_template_preserves_shared_identity_on_update(): + # Identity of nested fields preserved when using shallow dict update + class Shared(BaseModel): + val: int = 1 + + class A(BaseModel): + s: Shared + x: int = 0 + + shared = Shared(val=5) + base = A(s=shared, x=10) + ModelRegistry.root().add("baseA", base, overwrite=True) + updated = update_from_template(base=BaseModel.model_validate("baseA"), update={"x": 11}) + assert isinstance(updated, A) + assert updated.x == 11 + assert updated.s is shared + + +def test_model_alias_resolve_by_name(): + base = ModelRegistry.root()["db_default"] + out = BaseModel.model_validate("db_default") + assert out is base + + +def test_update_from_template_with_no_changes_returns_diff_object(): + base = ModelRegistry.root()["db_default"] + out = update_from_template(base=base) + assert out is not base + + +def test_update_from_template_applies_multiple_updates(): + out = update_from_template(base=BaseModel.model_validate("db_default"), update={"host": "u.local", "port": 9999, "name": "u"}) + assert out.host == "u.local" + assert out.port == 9999 + assert out.name == "u" + + +def test_update_from_template_does_not_affect_original(): + base = ModelRegistry.root()["db_default"] + out = update_from_template(base=base, update={"name": "changed"}) + assert base.name != out.name + + +def test_update_from_template_handles_empty_update(): + out = update_from_template(base=BaseModel.model_validate("db_default"), update={}) + assert isinstance(out, DB) + + +def test_update_from_template_hydra_like_call_with_model_alias_base(): + # Simulate Hydra instantiate of function target using args + update + from hydra.utils import instantiate + + cfg = { + "_target_": "ccflow.compose.update_from_template", + "base": {"_target_": "ccflow.compose.model_alias", "model_name": "db_other"}, + "update": {"port": 7654}, + } + out = instantiate(cfg, _convert_="all") + assert out.port == 7654 + assert out.host == "override.local" + + +def test_from_python_hydra_like(): + obj = from_python("ccflow.tests.data.python_object_samples.SHARED_CFG") + assert isinstance(obj, dict) + assert obj == {"x": 1, "y": 2} + + +def test_update_from_template_preserves_type_and_fields(): + base = ModelRegistry.root()["db_default"] + out = update_from_template(base=base, update={"name": "new"}) + assert isinstance(out, DB) + assert out.host == base.host + + +def test_update_from_template_multiple_fields(): + out = update_from_template(base=BaseModel.model_validate("db_default"), update={"name": "m", "host": "m.local", "port": 1111}) + assert out.name == "m" + assert out.host == "m.local" + assert out.port == 1111 + + +def test_update_from_template_multiple_calls_independent_instances(): + base = ModelRegistry.root()["db_default"] + a = update_from_template(base=base, update={"name": "a"}) + b = update_from_template(base=base, update={"name": "b"}) + assert a.name == "a" + assert b.name == "b" + assert base.name != a.name and base.name != b.name + + +def test_from_python_with_indexer_resolves_nested_dict(): + obj = from_python( + "ccflow.tests.data.python_object_samples.NESTED_CFG", + indexer=["db"], + ) + assert isinstance(obj, dict) + assert obj == {"host": "seed.local", "port": 7000, "name": "seed"} + + +def test_update_from_template_hydra_chain_with_from_python_indexer_target_class(): + from hydra.utils import instantiate + + cfg = { + "_target_": "ccflow.compose.update_from_template", + "base": { + "_target_": "ccflow.compose.from_python", + "py_object_path": "ccflow.tests.data.python_object_samples.NESTED_CFG", + "indexer": ["db"], + }, + "update": {"port": 7654}, + "target_class": "ccflow.tests.utils.test_compose.DB", + } + out = instantiate(cfg, _convert_="all") + assert isinstance(out, DB) + assert out.host == "seed.local" + assert out.port == 7654 + assert out.name == "seed" + + +def test_update_from_template_with_base_as_string_alias_preserves_identity(): + base_parent = ModelRegistry.root()["parent"] + updated = update_from_template(base="parent", update={"version": "1.0"}) + assert isinstance(updated, Parent) + assert updated.version == "1.0" + # child identity preserved via shallow copy + assert updated.child is base_parent.child + + +def test_update_from_template_with_dict_base_returns_updated_dict_without_target(): + src = {"a": 1} + out = update_from_template(base=src, update={"b": 2}) + assert isinstance(out, dict) + assert out == {"a": 1, "b": 2} + assert out is not src + + +def test_update_from_template_with_dict_base_and_type_target_class(): + out = update_from_template(base={"host": "x", "port": 1, "name": "n"}, target_class=DB, update={"port": 2}) + assert isinstance(out, DB) + assert out.host == "x" + assert out.port == 2 + assert out.name == "n" + + +def test_update_from_template_with_none_base_and_type_target_class(): + out = update_from_template(base=None, target_class=DB, update={"host": "h", "port": 9, "name": "n"}) + assert isinstance(out, DB) + assert out.host == "h" and out.port == 9 and out.name == "n" + + +def test_update_from_template_with_none_base_without_target_returns_dict(): + out = update_from_template(base=None, update={"x": 1}) + assert isinstance(out, dict) + assert out == {"x": 1} + + +def test_update_from_template_with_empty_update_on_dict_and_none(): + out1 = update_from_template(base={"a": 1}, update={}) + assert out1 == {"a": 1} + out2 = update_from_template(base=None, update={}) + assert out2 == {} + + +def test_update_from_template_invalid_base_type_raises(): + import pytest + + with pytest.raises(TypeError): + update_from_template(base=[1, 2, 3], update={"x": 1}) + + +def test_update_from_template_with_base_model_and_explicit_target_class(): + class DB2(BaseModel): + host: str + port: int + name: str + + base_db = ModelRegistry.root()["db_default"] + out = update_from_template(base=base_db, target_class=DB2, update={"name": "changed"}) + assert isinstance(out, DB2) + assert out.host == base_db.host + assert out.port == base_db.port + assert out.name == "changed" diff --git a/ccflow/tests/utils/test_compose_hydra.py b/ccflow/tests/utils/test_compose_hydra.py new file mode 100644 index 0000000..c5ceea6 --- /dev/null +++ b/ccflow/tests/utils/test_compose_hydra.py @@ -0,0 +1,82 @@ +import os + +import pytest + +from ccflow import BaseModel, ModelRegistry + + +def _config_path(name: str) -> str: + return os.path.join(os.path.dirname(__file__), "..", "config", name) + + +@pytest.fixture +def registry(): + ModelRegistry.root().clear() + yield ModelRegistry.root() + ModelRegistry.root().clear() + + +def test_hydra_conf_registry_reference_identity(): + # Config supplies registry names for nested BaseModel arguments; identity should be preserved + from ccflow.tests.data.python_object_samples import Consumer, SharedHolder, SharedModel + + path = _config_path("conf_from_python.yaml") + cfg = ModelRegistry.root().create_config_from_path(path=path) + ModelRegistry.root().load_config(cfg, overwrite=True) + + shared = ModelRegistry.root()["shared_model"] + consumer = ModelRegistry.root()["consumer"] + consumer_updated = ModelRegistry.root()["consumer_updated"] + + assert isinstance(shared, SharedModel) + assert isinstance(consumer, Consumer) + # Identity: consumer.shared should be the same instance as registry shared_model + assert consumer.shared is shared + # update_from_template preserves shared identity and applies field updates + assert consumer_updated.shared is shared + assert consumer_updated.tag == "consumer2" + + # Also check dict-returning from_python works and holder is constructed + holder = ModelRegistry.root()["holder"] + assert isinstance(holder, SharedHolder) + assert isinstance(holder.cfg, dict) + + +def test_update_from_template_shared_identity(): + # Ensure shared sub-fields remain identical objects when alias-update is used + from hydra.utils import instantiate + + ModelRegistry.root().clear() + + class Shared(BaseModel): + val: int = 1 + + class A(BaseModel): + s: Shared + x: int = 0 + + # Register a base object and a shared object by name + shared = Shared(val=5) + base = A(s=shared, x=10) + ModelRegistry.root().add("shared", shared, overwrite=True) + ModelRegistry.root().add("base", base, overwrite=True) + + # Compose a config that uses update_from_template to update only a primitive field + cfg = { + "updated": { + "_target_": "ccflow.compose.update_from_template", + "base": {"_target_": "ccflow.compose.model_alias", "model_name": "base"}, + "update": {"x": 99}, + } + } + + # Hydra instantiate calls the function, which uses model_copy(update=...) + obj = instantiate(cfg["updated"], _convert_="all") + assert isinstance(obj, A) + assert obj.x == 99 + # Ensure the shared sub-field refers to the same object as in the registry + assert obj.s is shared + + # Additional: Using update_from_template without changing shared should preserve identity + obj2 = instantiate(cfg["updated"], _convert_="all") + assert obj2.s is shared diff --git a/ccflow/tests/utils/test_hydra.py b/ccflow/tests/utils/test_hydra.py index c7f5b3b..06e2d9d 100644 --- a/ccflow/tests/utils/test_hydra.py +++ b/ccflow/tests/utils/test_hydra.py @@ -2,8 +2,9 @@ from pathlib import Path import pytest +from hydra import compose, initialize -from ccflow.utils.hydra import get_args_parser, load_config +from ccflow.utils.hydra import get_args_parser_default, load_config @pytest.fixture @@ -195,7 +196,7 @@ def mock_args(mocker, basepath, request): def test_cfg_explain_cli_args(mock_args, request): """Test that the mocking of the argparse args works correctly in isolation""" - parser = get_args_parser() + parser = get_args_parser_default() if mock_args == "--gui": parser.add_argument("--port", type=int, default=8080, help="Port for the GUI") args = parser.parse_args() @@ -210,7 +211,7 @@ def test_cfg_explain_cli(mock_args, mocker, capsys): from ccflow.utils.hydra import cfg_explain_cli if mock_args == "--gui": - parser = get_args_parser() + parser = get_args_parser_default() parser.add_argument("--port", type=int, default=8080, help="Port for the GUI") cfg_explain_cli(args_parser=parser, ui_launcher=lambda cfg, port, **kwargs: print(f"Launching UI on port {port}")) captured = capsys.readouterr() @@ -218,3 +219,14 @@ def test_cfg_explain_cli(mock_args, mocker, capsys): else: cfg_explain_cli() + + +def test_cfg_run_cli(mocker, capsys): + """Test cfg_run cli entrypoint using the ETL example config""" + from ccflow.utils.hydra import cfg_run + + # We'll load up the model registry using the normal hydra functions + with initialize(version_base=None, config_path="../../examples/etl/config"): + cfg = compose(config_name="base", overrides=["+callable=extract", "+context=[]"]) + # Now run it + cfg_run(cfg) diff --git a/ccflow/utils/hydra.py b/ccflow/utils/hydra.py index 2d4d702..70da1b0 100644 --- a/ccflow/utils/hydra.py +++ b/ccflow/utils/hydra.py @@ -2,14 +2,34 @@ import inspect import os from dataclasses import dataclass +from logging import getLogger from pathlib import Path from pprint import pprint +from textwrap import dedent from typing import Any, Callable, Dict, List, Optional from hydra._internal.defaults_list import DefaultsList -from omegaconf import DictConfig, OmegaConf +from omegaconf import DictConfig, ListConfig, OmegaConf -__all__ = ("load_config",) +try: + import panel as pn +except ImportError: + pn = None + +from ..base import ModelRegistry +from ..callable import FlowOptions, FlowOptionsOverride + +_log = getLogger(__name__) + +__all__ = ( + "ConfigLoadResult", + "load_config", + "get_args_parser_default", + "get_args_parser_default_ui", + "ui_launcher_default", + "cfg_explain_cli", + "cfg_run", +) @dataclass @@ -217,7 +237,7 @@ def yaml_load(*args, **kwargs): return result -def get_args_parser() -> argparse.ArgumentParser: +def get_args_parser_default() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(add_help=True, description="Hydra Config Audit Tool") parser.add_argument( "overrides", @@ -260,6 +280,63 @@ def get_args_parser() -> argparse.ArgumentParser: return parser +def get_args_parser_default_ui() -> argparse.ArgumentParser: + parser = get_args_parser_default() + parser.add_argument( + "--address", + type=str, + default="127.0.0.1", + help="Address to bind the server to.", + ) + parser.add_argument( + "--port", + type=int, + default=8080, + help="Port to bind the server to.", + ) + parser.add_argument( + "--allow-websocket-origin", + type=str, + nargs="+", + default=["*"], + help=dedent("""\ + Allow websocket connections from the specified origin. + This is useful when running the server behind a reverse proxy. + If not specified, only connections from the same origin will be allowed. + Multiple origins can be specified by separating them with a comma. + """), + ) + parser.add_argument( + "--basic-auth", + help=dedent("""\ + Enable basic authentication for the server. + The value should be in the format 'username:password'. + """), + type=str, + default=None, + ) + parser.add_argument("--cookie-secret", type=str, default="secret", help="Cookie secret for the server.") + parser.epilog = dedent("""\ + This will launch the server that can be used to view the configuration. + The server will be accessible at http://
: by default. + You can specify the address and port using the --address and --port arguments. + You can also specify the allowed websocket origins using the --allow-websocket-origin argument. + You can enable basic authentication using the --basic-auth argument. + You can specify the cookie secret using the --cookie-secret argument. + """) + return parser + + +def ui_launcher_default(cfg, **kwargs): + if pn is None: + raise ImportError("Panel is not installed. Please install panel to use the UI.") + pn.extension() + pn.extension("jsoneditor") + app = pn.widgets.JSONEditor(value=cfg, width=1200, mode="view") + app.servable() + pn.serve(app, **kwargs) + + def cfg_explain_cli( config_path: str = "", config_name: str = "", @@ -276,9 +353,13 @@ def cfg_explain_cli( args_parser: An optionally extended version of the argparser returned by `get_args_parser` to add UI arguments ui_launcher: A callable that takes the config dict and the parsed args and launches a custom display. """ - parser = args_parser or get_args_parser() + parser = args_parser or get_args_parser_default_ui() args = parser.parse_args() + if not args.no_gui and args_parser is None: + parser = get_args_parser_default_ui() + args = parser.parse_args() + if args.config_path: root_config_dir = args.config_path elif hydra_main and config_path: @@ -308,8 +389,81 @@ def cfg_explain_cli( pprint(merged_cfg, width=120, indent=2) elif ui_launcher is not None: ui_launcher(merged_cfg, **vars(args)) + elif pn is not None: + ui_launcher_default(merged_cfg, **vars(args)) + else: + raise ValueError("Cannot launch UI, no ui_launcher provided and/or panel not installed. Use --no-gui to print the results.") + + +def _load_model_registry(cfg: DictConfig): + registry = ModelRegistry.root() + registry.load_config(cfg=cfg, overwrite=True) + + +def _run_get(cfg: DictConfig): + registry = ModelRegistry.root() + out = registry[cfg["get"]] + try: + _log.info(out.model_dump(by_alias=True)) + except TypeError: + ... + return out + + +def _run_model(cfg: DictConfig, log_results: bool = True): + registry = ModelRegistry.root() + + if "callable" not in cfg: + raise ValueError("No callable specified in the configuration.") + + callable = cfg["callable"] + if not isinstance(callable, str): + # TODO allow instantiation + raise ValueError("Only string callables are supported at the moment.") + + if callable not in registry: + raise ValueError(f"Callable '{callable}' not found in the model registry. Available callables: {list(registry.keys())}") + + # Pull out the model + model = registry[cfg["callable"]] + + if "context" not in cfg: + # TODO check if context is necessary + raise ValueError("No context specified in the configuration.") + + # Pull out the context + context = cfg["context"] + + # If the context is a DictConfig or ListConfig, convert to a standard dict or list + if isinstance(context, (DictConfig, ListConfig)): + context = OmegaConf.to_container(context, resolve=True) + + # Run the model within the flow options override context + global_options = registry.get("/cli/global", FlowOptions()) + model_options = registry.get("/cli/model", FlowOptions()) + with FlowOptionsOverride(options=global_options): + with FlowOptionsOverride(options=model_options): + out = model(context) + + # Log the results + if log_results: + try: + _log.info(out.model_dump(by_alias=True)) + except TypeError: + ... + return out + + +def cfg_run( + cfg: DictConfig, +): + if not OmegaConf.is_config(cfg): + cfg = OmegaConf.create(cfg) + _load_model_registry(cfg) + if "get" in cfg: + _run_get(cfg) else: - raise ValueError("Cannot launch UI, no ui_launcher provided. Use --no-gui to print the results.") + return _run_model(cfg) if __name__ == "__main__": diff --git a/docs/img/wiki/etl/explain1.png b/docs/img/wiki/etl/explain1.png new file mode 100644 index 0000000000000000000000000000000000000000..d99055aeaa6a4095a2dcd89cb8ce4a15bc405786 GIT binary patch literal 235701 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%0D@t<$iXq~qs+ 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 literal 0 HcmV?d00001 diff --git a/docs/img/wiki/etl/explain2.png b/docs/img/wiki/etl/explain2.png new file mode 100644 index 0000000000000000000000000000000000000000..99955efc3725f1ca1253d0e525f1c81eba477cc3 GIT binary patch literal 96452 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 Separator: / ``` +### Registry Helpers + +ccflow.compose offers small, focused helpers for interacting with the registry and Python-backed defaults: + +- `model_alias(model_name)`: resolve a model instance by string name from the active registry. +- `update_from_template(base, update=None, target_class=None)`: construct a new instance or dict by shallow-copying `base` and applying updates. + - If `base` is a registry alias, you can pass either the alias string directly (e.g., `base: "my_model"`) or use `_target_: ccflow.compose.model_alias` form. + - If `base` is a dict, returns the updated dict. If `target_class` is provided (type or import path), constructs that type with the updated fields. + - Shallow copy ensures nested BaseModel identity is preserved. +- `from_python(py_object_path, indexer=None)`: resolve any Python object by import path. Optionally provide `indexer` (a list of keys) to index into the object in order; no safety checks are performed and indexing errors will propagate. + ## Using Configuration With the ability to define arbitrarily complex configuration structures following the examples above, now arises the question of how best to use all that config information. diff --git a/docs/wiki/ETL.md b/docs/wiki/ETL.md new file mode 100644 index 0000000..11a4d78 --- /dev/null +++ b/docs/wiki/ETL.md @@ -0,0 +1,363 @@ +- [Building an ETL System](#building-an-etl-system) + - [Background](#background) + - [Models](#models) + - [Context](#context) + - [Extract](#extract) + - [CLI](#cli) + - [Configuration](#configuration) + - [Remaining Models](#remaining-models) + - [Transform](#transform) + - [Load](#load) + - [Full Configuration](#full-configuration) + - [Running](#running) + - [Visualizing](#visualizing) + - [Appendix - Multiple Files](#appendix---multiple-files) + +# Building an ETL System + +Let's take what we learned in [Workflows](Workflows) and build an end-to-end [ETL](https://en.wikipedia.org/wiki/Extract,_transform,_load) system with `ccflow`. + +The goal is to construct a set of [Callable Models](Workflows#callable-models) into which we can pass [Contexts](Workflows#context) and get back [Results](Workflows#result-type), and to define our workflows via static configuration files using [hydra](https://hydra.cc). + +In order to generically operate on the data that communicated between steps of the workflow, `ccflow` defines a base class for the results that a step returns. +These are also child classes of `BaseModel` so one gets all the type validation and serialization features of pydantic models for free. Insisting on a base class for all result types also allows +the framework to perform additional magic (such as delayed evaluation). + +Some result types are provided with `ccflow`, but it is straightforward to define your own. + +## Background + +Let's start with a simple set of tasks: + +- Extract a website's `html` content and save it +- Given a saved `.html` file, transform it into a `csv` file of link names and corresponding URLs +- Given a saved `.csv` file of names and URLs, load it into a queryable sqlite database + +This is a toy example, but we will use it to put the concepts in [Workflows](Workflows) to practice. +Additionally, we will grow our understanding of [hydra](https://hydra.cc) with a concrete example. + +> [!NOTE] +> Source code is available in-source, in [ccflow/examples/etl](https://github.com/Point72/ccflow/tree/main/ccflow/examples/etl). + +## Models + +We'll define a single [Context](Workflows#context) as the argument to our first model. +This is not strictly necessary, but we'll use it as an example of a context. +In general, contexts are very useful for storing global reference data, like the current date being processed in a backfill pipeline. + +### Context + +```python +from ccflow import ContextBase +from pydantic import Field + +class SiteContext(ContextBase): + site: str = Field(default="https://en.wikipedia.org/wiki/Main_Page") +``` + +This class has a single attribute, `site`. +When we finish writing our ETL CLI, we will be able to pass in different contexts at runtime: + +```bash +etl-cli +context=[] # use default wikipedia +etl-cli +context=["http://lobste.rs"] # query lobste.rs instead +``` + +### Extract + +For the `extract` stage of our ETL pipeline, let's write a basic model to query a website over REST and return the `HTML` content: + +```python +from typing import Optional +from httpx import Client +from ccflow import CallableModel, Flow, GenericResult, NullContext + + +class RestModel(CallableModel): + @Flow.call + def __call__(self, context: Optional[SiteContext] = None) -> GenericResult[str]: + context = context or SiteContext() + resp = Client().get(context.site, follow_redirects=True) + return GenericResult[str](value=resp.text) +``` + +There are a few key elements here: + +- **CallableModel**: Our class inherits from `CallableModel`, which means it is expected to execute given a context and return a result in a `@Flow.call` decorated `__call__` method +- **SiteContext**\*: Our class will take a specific flavor of context, defined above +- **GenericResult[str]**: Our class returns a `GenericResult`, which, as the name suggests, is just a generic container of a `value` (in this case, a `str`). We could've made this a custom result type as well, allowing greater type safety around our pipeline. + +When we execute our `RestModel`, it will take in a `SiteContext` instance, make an `HTTP` request to the site, and return the string `html` result. + +Before we move on to our other models, let's get this stage working with a CLI. + +## CLI + +`ccflow` provides some helper functions for linking together [hydra](https://hydra.cc) with our Callable models framework. + +```python +import hydra +from ccflow.utils.hydra import cfg_run, cfg_explain_cli + + +@hydra.main(config_path="config", config_name="base", version_base=None) +def main(cfg): + cfg_run(cfg) + +def explain(): + cfg_explain_cli(config_path="config", config_name="base", hydra_main=main) +``` + +The first function here takes a `hydra` configuration hierarchy, and tries to execute the top level `callable` attribute. +When we write the configuration files for our `RestModel`, we'll see how this links together. + +The second function here launches a helpful UI to browse the `hydra` configuration hierarchy we've constructed. + +> [!NOTE] +> These can be run directly from `ccflow`: +> `python -m ccflow.examples.etl` and `python -m ccflow.examples.etl.explain` + +## Configuration + +`hydra` is driven by `yaml` files, so let's write one of these for our ETL examples. + +**ccflow/examples/etl/config/base.yaml**. + +```yaml +extract: + _target_: ccflow.PublisherModel + model: + _target_: ccflow.examples.etl.models.RestModel + publisher: + _target_: ccflow.publishers.GenericFilePublisher + name: raw + suffix: .html + field: value +``` + +Our config here defines a key `extract` as a `PublisherModel`, which is itself a `CallableModel` that will execute the given `model` subkey and generate results using the corresponding `publisher` subkey. + +This isn't strictly necessary for our example, as we could've just written the file ourselves from the `RestModel`, but it's a good example of leveraging the same callable models in multiple places (in this case, a `GenericFilePublisher`). + +We can now execute this with the CLI we created above: + +```bash +python -m ccflow.examples.etl +callable=extract +context=[] +``` + +This will load our configuration and call `/extract` (a `PublisherModel`). +`PublisherModel` will itself call `RestModel`, and then feed the results to `GenericFilePublisher`. +The end result should be the extracted result as a file called `raw.html` containing the `HTML` content (as configured on the \`GenericFilePublisher). + +We can run the same CLI with a different context to extract a different website: + +```bash + python -m ccflow.examples.etl +callable=extract +context=["http://lobste.rs"] +``` + +We can even leverage hydra's [override grammar](https://hydra.cc/docs/advanced/override_grammar/basic/) to make tweaks at any layer of our configuration hierarchy: + +```bash +# Change the GenericFilePublisher's output file name to lobsters, generating lobsters.html instead of raw.html +python -m ccflow.examples.etl +callable=extract +context=["http://lobste.rs"] ++extract.publisher.name=lobsters +``` + +Let's implement the remaining steps of our pipeline as their own models + +## Remaining Models + +### Transform + +Our `LinksModel` will read an `HTML` file, extract all the links therein, and generate a `csv` string. + +```python +from csv import DictWriter +from io import StringIO +from bs4 import BeautifulSoup +from ccflow import CallableModel, Flow, GenericResult, NullContext + +class LinksModel(CallableModel): + file: str + + @Flow.call + def __call__(self, context: NullContext) -> GenericResult[str]: + with open(self.file, "r") as f: + html = f.read() + + # Use beautifulsoup to convert links into csv of name, url + soup = BeautifulSoup(html, "html.parser") + links = [{"name": a.text, "url": href} for a in soup.find_all("a", href=True) if (href := a["href"]).startswith("http")] + + io = StringIO() + writer = DictWriter(io, fieldnames=["name", "url"]) + writer.writeheader() + writer.writerows(links) + output = io.getvalue() + return GenericResult[str](value=output) +``` + +### Load + +Our `DBModel` will read a `csv` file and load it into a `SQLite` database. + +```python +import sqlite3 +from csv import DictReader +from pydantic import Field +from ccflow import CallableModel, Flow, GenericResult, NullContext + + +class DBModel(CallableModel): + file: str + db_file: str = Field(default="etl.db") + table: str = Field(default="links") + + @Flow.call + def __call__(self, context: NullContext) -> GenericResult[str]: + conn = sqlite3.connect(self.db_file) + cursor = conn.cursor() + cursor.execute(f"CREATE TABLE IF NOT EXISTS {self.table} (name TEXT, url TEXT)") + with open(self.file, "r") as f: + reader = DictReader(f) + for row in reader: + cursor.execute(f"INSERT INTO {self.table} (name, url) VALUES (?, ?)", (row["name"], row["url"])) + conn.commit() + return GenericResult[str](value="Data loaded into database") +``` + +## Full Configuration + +Let's register all of our models in the same configuration yaml: + +```yaml +extract: + _target_: ccflow.PublisherModel + model: + _target_: ccflow.examples.etl.models.RestModel + publisher: + _target_: ccflow.publishers.GenericFilePublisher + name: raw + suffix: .html + field: value + +transform: + _target_: ccflow.PublisherModel + model: + _target_: ccflow.examples.etl.models.LinksModel + file: ${extract.publisher.name}${extract.publisher.suffix} + publisher: + _target_: ccflow.publishers.GenericFilePublisher + name: extracted + suffix: .csv + field: value + +load: + _target_: ccflow.examples.etl.models.DBModel + file: ${transform.publisher.name}${transform.publisher.suffix} + db_file: etl.db + table: links +``` + +Our `transform` step will also use a `PublisherModel` to generate a `csv` file. +It will uses's `hydra`'s native support for [OmegaConf](https://omegaconf.readthedocs.io/en/2.3_branch/) interpolation to reference fields in other configuration blocks, e.g. `${extract.publisher.name}`. + +Our `load` does not require a publisher as it will optionally produce a `.db` file directly. + +> [!TIP] +> `hydra` provides a lot of utilities for breaking this config across multiple files and folders, +> providing defaults and overrides, etc. We will see an example of this below. + +## Running + +We've seen how to run our previous step with `+callable=extract`. +Our subsequent steps can be run similarly: + +```bash + +# Transform step: +python -m ccflow.examples.etl +callable=transform +context=[] + +# Transform step with overrides, read input lobsters.html and generate lobsters.csv +python -m ccflow.examples.etl +callable=transform +context=[] ++transform.model.file=lobsters.html ++transform.publisher.name=lobsters + +# Load step: +python -m ccflow.examples.etl +callable=load +context=[] + +# Load step with overrides, read input lobsters.csv and generate in-memory sqlite db +python -m ccflow.examples.etl +callable=load +context=[] ++load.file=lobsters.csv ++load.db_file=":memory:" +``` + +Similarly, we can tweak configurations as well + +## Visualizing + +`hydra` is reading `yaml` files and loading up the `ccflow` models into a single registry, which we can visualize in `JSON` form using the other CLI we wrote above: + +```bash +python -m ccflow.examples.etl.explain +``` + +This can be super helpful to see what fields are set to what values. + + + +We can also combine it with `hydra` overrides to ensure we're configuring everything correctly! + +```bash +python -m ccflow.examples.etl.explain ++extract.publisher.name=test +``` + + + +## Appendix - Multiple Files + +In `hydra`, its convenient to have things broken up across multiple files. +In our example above, we can do this as follows: + +**etl/config/base.yaml** + +```yaml +defaults: + - extract: rest + - transform: links + - load: db +``` + +**etl/config/extract/rest.yaml** + +```yaml +_target_: ccflow.PublisherModel +model: + _target_: ccflow.examples.etl.models.RestModel +publisher: + _target_: ccflow.publishers.GenericFilePublisher + name: raw + suffix: .html +field: value +``` + +**etl/config/transform/links.yaml** + +```yaml +_target_: ccflow.PublisherModel +model: + _target_: ccflow.examples.etl.models.LinksModel + file: ${extract.publisher.name}${extract.publisher.suffix} +publisher: + _target_: ccflow.publishers.GenericFilePublisher + name: extracted + suffix: .csv +field: value +``` + +**etl/config/load/db.yaml** + +```yaml +_target_: ccflow.examples.etl.models.DBModel +file: ${transform.publisher.name}${transform.publisher.suffix} +db_file: etl.db +table: links +``` + +In this organizational scheme, its easy to leveage `hydra` to provide a wide array of separate but interoperable functionality. +`hydra` has [much more documentation on this topic](https://hydra.cc/docs/tutorials/basic/your_first_app/config_groups/). diff --git a/docs/wiki/Installation.md b/docs/wiki/Installation.md index ae16626..ce3664d 100644 --- a/docs/wiki/Installation.md +++ b/docs/wiki/Installation.md @@ -1,6 +1,6 @@ ## Pre-requisites -You need Python >=3.9 on your machine to install `ccflow`. +You need Python >=3.10 on your machine to install `ccflow`. ## Install with `pip` diff --git a/docs/wiki/_Sidebar.md b/docs/wiki/_Sidebar.md index 30a0ae7..6b20b2f 100644 --- a/docs/wiki/_Sidebar.md +++ b/docs/wiki/_Sidebar.md @@ -19,6 +19,7 @@ Notes for editors: - [Configuration](Configuration) - [Workflows](Workflows) +- [ETL](ETL) **Developer Guide** diff --git a/pyproject.toml b/pyproject.toml index 4fac3f0..5233ff8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -8,8 +8,8 @@ authors = [{name = "Point72, L.P.", email = "OpenSource@point72.com"}] description = "ccflow is a collection of tools for workflow configuration, orchestration, and dependency injection" readme = "README.md" license = { text = "Apache-2.0" } -version = "0.6.8" -requires-python = ">=3.9" +version = "0.7.0" +requires-python = ">=3.10" keywords = [ "configuration", "flow", @@ -17,6 +17,7 @@ keywords = [ "hydra", "pydantic", ] + classifiers = [ "Development Status :: 4 - Beta", "License :: OSI Approved :: Apache Software License", @@ -24,7 +25,6 @@ classifiers = [ "Programming Language :: Python :: Implementation :: CPython", "Programming Language :: Python :: Implementation :: PyPy", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", @@ -44,7 +44,7 @@ dependencies = [ "orjson", "pandas", "pyarrow", - "pydantic>=2.12,<3", + "pydantic>=2.13,<3", "smart_open", "tenacity", ] @@ -66,9 +66,9 @@ develop = [ "check-manifest", "codespell>=2.4,<2.5", "hatchling", - "mdformat>=0.7.22,<0.8", + "mdformat>=0.7.22,<1.1", "mdformat-tables>=1", - "ruff>=0.6,<0.14", + "ruff>=0.9,<0.15", "toml", "twine", "uv", @@ -84,6 +84,8 @@ develop = [ "scipy", "xarray", # Test deps + "beautifulsoup4", + "httpx", "pytest", "pytest-asyncio", "pytest-cov", @@ -91,6 +93,8 @@ develop = [ "pytest-sugar", ] test = [ + "beautifulsoup4", + "httpx", "pytest", "pytest-asyncio", "pytest-cov", @@ -104,7 +108,7 @@ Repository = "https://github.com/Point72/ccflow" Homepage = "https://github.com/Point72/ccflow" [tool.bumpversion] -current_version = "0.6.8" +current_version = "0.7.0" commit = true tag = false commit_args = "-s"