metaxy 0.0.0__py3-none-any.whl

metaxy/models/feature_spec.py

@@ -0,0 +1,105 @@
+from collections.abc import Mapping
+from functools import cached_property
+
+import pydantic
+
+from metaxy.models.constants import ALL_SYSTEM_COLUMNS
+from metaxy.models.field import FieldSpec, SpecialFieldDep
+from metaxy.models.types import FeatureKey, FieldKey
+
+
+class FeatureDep(pydantic.BaseModel):
+    """Feature dependency specification with optional column selection and renaming.
+
+    Attributes:
+        key: The feature key to depend on
+        columns: Optional tuple of column names to select from upstream feature.
+            - None (default): Keep all columns from upstream
+            - Empty tuple (): Keep only system columns (sample_uid, data_version, etc.)
+            - Tuple of names: Keep only specified columns (plus system columns)
+        rename: Optional mapping of old column names to new names.
+            Applied after column selection.
+
+    Examples:
+        >>> # Keep all columns (default behavior)
+        >>> FeatureDep(key=FeatureKey(["upstream"]))
+
+        >>> # Keep only specific columns
+        >>> FeatureDep(
+        ...     key=FeatureKey(["upstream"]),
+        ...     columns=("col1", "col2")
+        ... )
+
+        >>> # Rename columns to avoid conflicts
+        >>> FeatureDep(
+        ...     key=FeatureKey(["upstream"]),
+        ...     rename={"old_name": "new_name"}
+        ... )
+
+        >>> # Select and rename
+        >>> FeatureDep(
+        ...     key=FeatureKey(["upstream"]),
+        ...     columns=("col1", "col2"),
+        ...     rename={"col1": "upstream_col1"}
+        ... )
+    """
+
+    key: FeatureKey
+    columns: tuple[str, ...] | None = (
+        None  # None = all columns, () = only system columns
+    )
+    rename: dict[str, str] | None = None  # Column renaming mapping
+
+    @pydantic.model_validator(mode="after")
+    def validate_column_operations(self) -> "FeatureDep":
+        """Validate column selection and renaming operations."""
+        if self.rename is not None:
+            for new_name in self.rename.values():
+                if new_name in ALL_SYSTEM_COLUMNS:
+                    raise ValueError(
+                        f"Cannot rename column to system column name: {new_name}. "
+                        f"System columns: {ALL_SYSTEM_COLUMNS}"
+                    )
+        return self
+
+    def table_name(self) -> str:
+        """Get SQL-like table name for this feature spec."""
+        return self.key.table_name
+
+
+class FeatureSpec(pydantic.BaseModel):
+    key: FeatureKey
+    deps: list[FeatureDep] | None
+    fields: list[FieldSpec] = pydantic.Field(
+        default_factory=lambda: [
+            FieldSpec(
+                key=FieldKey(["default"]),
+                code_version=1,
+                deps=SpecialFieldDep.ALL,
+            )
+        ]
+    )
+    code_version: int = 1
+
+    @cached_property
+    def fields_by_key(self) -> Mapping[FieldKey, FieldSpec]:
+        return {c.key: c for c in self.fields}
+
+    def table_name(self) -> str:
+        """Get SQL-like table name for this feature spec."""
+        return self.key.table_name
+
+    @pydantic.model_validator(mode="after")
+    def validate_unique_field_keys(self) -> "FeatureSpec":
+        """Validate that all fields have unique keys."""
+        seen_keys: set[tuple[str, ...]] = set()
+        for field in self.fields:
+            # Convert to tuple for hashability in case it's a plain list
+            key_tuple = tuple(field.key)
+            if key_tuple in seen_keys:
+                raise ValueError(
+                    f"Duplicate field key found: {field.key}. "
+                    f"All fields must have unique keys."
+                )
+            seen_keys.add(key_tuple)
+        return self

metaxy/models/field.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+from pydantic import Field as PydanticField
+
+from metaxy.models.bases import FrozenBaseModel
+from metaxy.models.types import FeatureKey, FieldKey
+
+
+class SpecialFieldDep(Enum):
+    ALL = "__METAXY_ALL_DEP__"
+
+
+class FieldDep(FrozenBaseModel):
+    feature_key: FeatureKey
+    fields: list[FieldKey] | SpecialFieldDep = SpecialFieldDep.ALL
+
+
+class FieldSpec(FrozenBaseModel):
+    key: FieldKey = PydanticField(default_factory=lambda: FieldKey(["default"]))
+    code_version: int = 1
+
+    # field-level dependencies can be one of the following:
+    # - the default SpecialFieldDep.ALL to depend on all upstream features and all their fields
+    # - a list of FieldDep to depend on particular fields of specific features
+    deps: SpecialFieldDep | list[FieldDep] = SpecialFieldDep.ALL

metaxy/models/plan.py

@@ -0,0 +1,155 @@
+from collections.abc import Mapping
+from functools import cached_property
+
+from metaxy.models.bases import FrozenBaseModel
+from metaxy.models.feature_spec import FeatureKey, FeatureSpec
+from metaxy.models.field import (
+    FieldDep,
+    FieldKey,
+    FieldSpec,
+    SpecialFieldDep,
+)
+
+
+class FQFieldKey(FrozenBaseModel):
+    field: FieldKey
+    feature: FeatureKey
+
+    def to_string(self) -> str:
+        return f"{self.feature.to_string()}.{self.field.to_string()}"
+
+    def __repr__(self) -> str:
+        return self.to_string()
+
+    def __lt__(self, other: "FQFieldKey") -> bool:
+        """Enable sorting of FQFieldKey objects."""
+        return self.to_string() < other.to_string()
+
+    def __le__(self, other: "FQFieldKey") -> bool:
+        """Enable sorting of FQFieldKey objects."""
+        return self.to_string() <= other.to_string()
+
+    def __gt__(self, other: "FQFieldKey") -> bool:
+        """Enable sorting of FQFieldKey objects."""
+        return self.to_string() > other.to_string()
+
+    def __ge__(self, other: "FQFieldKey") -> bool:
+        """Enable sorting of FQFieldKey objects."""
+        return self.to_string() >= other.to_string()
+
+
+class FeaturePlan(FrozenBaseModel):
+    """Slice of the feature graph that includes a given feature and its parents"""
+
+    feature: FeatureSpec
+    deps: list[FeatureSpec] | None
+
+    @cached_property
+    def parent_features_by_key(self) -> Mapping[FeatureKey, FeatureSpec]:
+        return {feature.key: feature for feature in self.deps or []}
+
+    @cached_property
+    def all_parent_fields_by_key(self) -> Mapping[FQFieldKey, FieldSpec]:
+        res: dict[FQFieldKey, FieldSpec] = {}
+
+        for feature in self.deps or []:
+            for field in feature.fields:
+                res[FQFieldKey(field=field.key, feature=feature.key)] = field
+
+        return res
+
+    @cached_property
+    def parent_fields_by_key(self) -> Mapping[FQFieldKey, FieldSpec]:
+        res: dict[FQFieldKey, FieldSpec] = {}
+
+        for field in self.feature.fields:
+            res.update(self.get_parent_fields_for_field(field.key))
+
+        return res
+
+    def get_parent_fields_for_field(
+        self, key: FieldKey
+    ) -> Mapping[FQFieldKey, FieldSpec]:
+        res = {}
+
+        field = self.feature.fields_by_key[key]
+
+        if field.deps == SpecialFieldDep.ALL:
+            # we depend on all upstream features and their fields
+            for feature in self.deps or []:
+                for field in feature.fields:
+                    res[FQFieldKey(field=field.key, feature=feature.key)] = field
+        elif isinstance(field.deps, list):
+            for field_dep in field.deps:
+                if field_dep.fields == SpecialFieldDep.ALL:
+                    # we depend on all fields of the corresponding upstream feature
+                    for parent_field in self.parent_features_by_key[
+                        field_dep.feature_key
+                    ].fields:
+                        res[
+                            FQFieldKey(
+                                field=parent_field.key,
+                                feature=field_dep.feature_key,
+                            )
+                        ] = parent_field
+
+                elif isinstance(field_dep, FieldDep):
+                    #
+                    for field_key in field_dep.fields:
+                        fq_key = FQFieldKey(
+                            field=field_key,
+                            feature=field_dep.feature_key,
+                        )
+                        res[fq_key] = self.all_parent_fields_by_key[fq_key]
+                else:
+                    raise ValueError(f"Unsupported dependency type: {type(field_dep)}")
+        else:
+            raise TypeError(f"Unsupported dependencies type: {type(field.deps)}")
+
+        return res
+
+    @cached_property
+    def field_dependencies(
+        self,
+    ) -> Mapping[FieldKey, Mapping[FeatureKey, list[FieldKey]]]:
+        """Get dependencies for each field in this feature.
+
+        Returns a mapping from field key to its upstream dependencies.
+        Each dependency maps an upstream feature key to a list of field keys
+        that this field depends on.
+
+        This is the format needed by DataVersionResolver.
+
+        Returns:
+            Mapping of field keys to their dependency specifications.
+            Format: {field_key: {upstream_feature_key: [upstream_field_keys]}}
+        """
+        result: dict[FieldKey, dict[FeatureKey, list[FieldKey]]] = {}
+
+        for field in self.feature.fields:
+            field_deps: dict[FeatureKey, list[FieldKey]] = {}
+
+            if field.deps == SpecialFieldDep.ALL:
+                # Depend on all upstream features and all their fields
+                for upstream_feature in self.deps or []:
+                    field_deps[upstream_feature.key] = [
+                        c.key for c in upstream_feature.fields
+                    ]
+            elif isinstance(field.deps, list):
+                # Specific dependencies defined
+                for field_dep in field.deps:
+                    feature_key = field_dep.feature_key
+
+                    if field_dep.fields == SpecialFieldDep.ALL:
+                        # All fields from this upstream feature
+                        upstream_feature_spec = self.parent_features_by_key[feature_key]
+                        field_deps[feature_key] = [
+                            c.key for c in upstream_feature_spec.fields
+                        ]
+                    elif isinstance(field_dep.fields, list):
+                        # Specific fields
+                        field_deps[feature_key] = field_dep.fields
+
+            result[field.key] = field_deps
+
+        return result

metaxy/models/types.py

@@ -0,0 +1,157 @@
+from typing import Any, TypeAlias
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import core_schema
+
+FEATURE_KEY_SEPARATOR = "/"
+FIELD_KEY_SEPARATOR = "/"
+
+
+class FeatureKey(list):  # pyright: ignore[reportMissingTypeArgument]
+    """
+    Feature key as a list of strings.
+
+    Hashable for use as dict keys in registries.
+
+    Parts cannot contain forward slashes (/) or double underscores (__).
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        # Validate that no part contains "/" or "__"
+        for part in self:
+            if not isinstance(part, str):
+                raise ValueError(
+                    f"FeatureKey parts must be strings, got {type(part).__name__}"
+                )
+            if "/" in part:
+                raise ValueError(
+                    f"FeatureKey part '{part}' cannot contain forward slashes (/). "
+                    f"Forward slashes are reserved as the separator in to_string(). "
+                    f"Use underscores or hyphens instead."
+                )
+            if "__" in part:
+                raise ValueError(
+                    f"FeatureKey part '{part}' cannot contain double underscores (__). "
+                    f"Use single underscores or hyphens instead."
+                )
+
+    def to_string(self) -> str:
+        return FEATURE_KEY_SEPARATOR.join(self)
+
+    def __repr__(self) -> str:
+        return self.to_string()
+
+    def __hash__(self):  # pyright: ignore[reportIncompatibleVariableOverride]
+        return hash(tuple(self))
+
+    def __eq__(self, other):
+        if isinstance(other, FeatureKey):
+            return list.__eq__(self, other)
+        return list.__eq__(self, other)
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        """Pydantic schema that preserves FeatureKey type."""
+        # python_schema = core_schema.is_instance_schema(cls)
+
+        list_of_str_schema = core_schema.list_schema(core_schema.str_schema())
+
+        return core_schema.no_info_wrap_validator_function(
+            cls._validate,
+            list_of_str_schema,
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda x: list(x)
+            ),
+        )
+
+    @classmethod
+    def _validate(cls, value, handler):
+        """Validate and wrap in FeatureKey."""
+        if isinstance(value, cls):
+            return value
+        # Let the list schema validate first
+        validated = handler(value)
+        # Wrap in FeatureKey
+        return cls(validated)
+
+    @property
+    def table_name(self) -> str:
+        """Get SQL-like table name for this feature key."""
+        return "__".join(self)
+
+
+class FieldKey(list):  # pyright: ignore[reportMissingTypeArgument]
+    """
+    Field key as a list of strings.
+
+    Hashable for use as dict keys in registries.
+
+    Parts cannot contain forward slashes (/) or double underscores (__).
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # pyrefly: ignore[not-iterable]
+        # Validate that no part contains "/" or "__"
+        for part in self:
+            if not isinstance(part, str):
+                raise ValueError(
+                    f"FieldKey parts must be strings, got {type(part).__name__}"
+                )
+            if "/" in part:
+                raise ValueError(
+                    f"FieldKey part '{part}' cannot contain forward slashes (/). "
+                    f"Forward slashes are reserved as the separator in to_string(). "
+                    f"Use underscores or hyphens instead."
+                )
+            if "__" in part:
+                raise ValueError(
+                    f"FieldKey part '{part}' cannot contain double underscores (__). "
+                    f"Use single underscores or hyphens instead."
+                )
+
+    def to_string(self) -> str:
+        return FIELD_KEY_SEPARATOR.join(self)
+
+    def __repr__(self) -> str:
+        return self.to_string()
+
+    def __hash__(self):  # pyright: ignore[reportIncompatibleVariableOverride]
+        return hash(tuple(self))
+
+    def __eq__(self, other):
+        if isinstance(other, FieldKey):
+            return list.__eq__(self, other)
+        return list.__eq__(self, other)
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        """Pydantic schema that preserves FieldKey type."""
+        # python_schema = core_schema.is_instance_schema(cls)
+
+        list_of_str_schema = core_schema.list_schema(core_schema.str_schema())
+
+        return core_schema.no_info_wrap_validator_function(
+            cls._validate,
+            list_of_str_schema,
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda x: list(x)
+            ),
+        )
+
+    @classmethod
+    def _validate(cls, value, handler):
+        """Validate and wrap in FieldKey."""
+        if isinstance(value, cls):
+            return value
+        # Let the list schema validate first
+        validated = handler(value)
+        # Wrap in FieldKey
+        return cls(validated)
+
+
+FeatureDepMetadata: TypeAlias = dict[str, Any]

metaxy-0.0.0.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.3
+Name: metaxy
+Version: 0.0.0
+Summary: Add your description here
+Author: Daniel Gafni
+Author-email: Daniel Gafni <danielgafni16@gmail.com>
+Requires-Dist: cyclopts==4.0.0b1
+Requires-Dist: narwhals>=2.9.0
+Requires-Dist: polars>=1.33.1
+Requires-Dist: polars-hash>=0.5.1
+Requires-Dist: pydantic>=2.11.9
+Requires-Dist: pydantic-settings>=2.11.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: tomli>=2.3.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pygraphviz>=1.14 ; extra == 'graphviz'
+Requires-Dist: pyarrow>=18.0.0 ; extra == 'ibis'
+Requires-Dist: ibis-framework>=11.0.0 ; extra == 'ibis'
+Requires-Dist: mermaid-py>=0.8.0 ; extra == 'mermaid'
+Requires-Dist: sqlmodel>=0.0.27 ; extra == 'sqlmodel'
+Requires-Python: >=3.10
+Provides-Extra: graphviz
+Provides-Extra: ibis
+Provides-Extra: mermaid
+Provides-Extra: sqlmodel
+Description-Content-Type: text/markdown
+
+# Metaxy
+
+## Overview
+
+**Metaxy** is a declarative metadata management system for multi-modal data and machine learning pipelines. Metaxy allows statically defining graphs of features with versioned **fields** -- logical components like `audio`, `frames` for `.mp4` files and **columns** for feature metadata stored in Metaxy's metadata store. With this in place, Metaxy provides:
+
+- **Sample-level data versioning**: Track field and column lineage, compute versions as hashes of upstream versions for each sample
+- **Incremental computation**: Automatically detect which samples need recomputation when upstream fields change
+- **Migration system**: When feature code changes without changing outputs (refactoring, graph restructuring), Metaxy can reconcile metadata versions without recomputing expensive features
+- **Storage flexibility**: Pluggable backends (DuckDB, ClickHouse, PostgreSQL, SQLite, in-memory) with native SQL optimization where possible
+- **Big Metadata**: Metaxy is designed with large-scale distributed systems in mind and can handle large amounts of metadata efficiently.
+
+Metaxy is designed for production data and ML systems where data and features evolve over time, and you need to track what changed, why, and whether expensive recomputation is actually necessary.
+
+## Data Versioning
+
+To demonstrate how Metaxy handles data versioning, let's consider a video processing pipeline:
+
+```py
+from metaxy import (
+    Feature,
+    FeatureDep,
+    FeatureKey,
+    FeatureSpec,
+    FieldDep,
+    FieldKey,
+    FieldSpec,
+)
+
+
+class Video(
+    Feature,
+    spec=FeatureSpec(
+        key=FeatureKey(["example", "video"]),
+        deps=None,  # Root feature
+        fields=[
+            FieldSpec(
+                key=FieldKey(["audio"]),
+                code_version=1,
+            ),
+            FieldSpec(
+                key=FieldKey(["frames"]),
+                code_version=1,
+            ),
+        ],
+    ),
+):
+    """Video metadata feature (root)."""
+
+    frames: int
+    duration: float
+    size: int
+
+
+class Crop(
+    Feature,
+    spec=FeatureSpec(
+        key=FeatureKey(["example", "crop"]),
+        deps=[FeatureDep(key=Video.spec.key)],
+        fields=[
+            FieldSpec(
+                key=FieldKey(["audio"]),
+                code_version=1,
+                deps=[
+                    FieldDep(
+                        feature_key=Video.spec.key,
+                        fields=[FieldKey(["audio"])],
+                    )
+                ],
+            ),
+            FieldSpec(
+                key=FieldKey(["frames"]),
+                code_version=1,
+                deps=[
+                    FieldDep(
+                        feature_key=Video.spec.key,
+                        fields=[FieldKey(["frames"])],
+                    )
+                ],
+            ),
+        ],
+    ),
+):
+    pass  # omit columns for the sake of simplicity
+
+
+class FaceDetection(
+    Feature,
+    spec=FeatureSpec(
+        key=FeatureKey(["example", "face_detection"]),
+        deps=[
+            FeatureDep(
+                key=Crop.spec.key,
+            )
+        ],
+        fields=[
+            FieldSpec(
+                key=FieldKey(["faces"]),
+                code_version=1,
+                deps=[
+                    FieldDep(
+                        feature_key=Crop.spec.key,
+                        fields=[FieldKey(["frames"])],
+                    )
+                ],
+            ),
+        ],
+    ),
+):
+    pass
+
+
+class SpeechToText(
+    Feature,
+    spec=FeatureSpec(
+        key=FeatureKey(["overview", "stt"]),
+        deps=[
+            FeatureDep(
+                key=Video.spec.key,
+            )
+        ],
+        fields=[
+            FieldSpec(
+                key=FieldKey(["transcription"]),
+                code_version=1,
+                deps=[
+                    FieldDep(
+                        feature_key=Video.spec.key,
+                        fields=[FieldKey(["audio"])],
+                    )
+                ],
+            ),
+        ],
+    ),
+):
+    pass
+```
+
+When provided with this Python module, `metaxy graph render --format mermaid` (that's handy, right?) produces the following graph:
+
+```mermaid
+---
+title: Feature Graph
+---
+flowchart TB
+    %% Snapshot version: 8468950d
+    %%{init: {'flowchart': {'htmlLabels': true, 'curve': 'basis'}, 'themeVariables': {'fontSize': '14px'}}}%%
+        example_video["<div style="text-align:left"><b>example/video</b><br/><small>(v: bc9ca835)</small><br/><font
+color="#999">---</font><br/>• audio <small>(v: 22742381)</small><br/>• frames <small>(v: 794116a9)</small></div>"]
+        example_crop["<div style="text-align:left"><b>example/crop</b><br/><small>(v: 3ac04df8)</small><br/><font
+color="#999">---</font><br/>• audio <small>(v: 76c8bdc9)</small><br/>• frames <small>(v: abc79017)</small></div>"]
+        example_face_detection["<div style="text-align:left"><b>example/face_detection</b><br/><small>(v: 1ac83b07)</small><br/><font
+color="#999">---</font><br/>• faces <small>(v: 2d75f0bd)</small></div>"]
+        example_stt["<div style="text-align:left"><b>example/stt</b><br/><small>(v: c83a754a)</small><br/><font
+color="#999">---</font><br/>• transcription <small>(v: ac412b3c)</small></div>"]
+        example_video --> example_crop
+        example_crop --> example_face_detection
+        example_video --> example_stt
+```
+
+Now imagine the `audio` logical field (don't mix up with metadata columns!) of the very first `Video` feature has been changed. Perhaps it has been cleaned or denoised.
+
+```diff
+         key=FeatureKey(["example", "video"]),
+         deps=None,  # Root feature
+         fields=[
+             FieldSpec(
+                 key=FieldKey(["audio"]),
+-                code_version=1,
++                code_version=2,
+             ),
+```
+
+In this case we'd typically want to recompute the downstream `Crop`, `SpeechToText`  and `Embeddings` features, but not the `FaceDetection` feature, since it only depends on `frames` and not on `audio`.
+
+`metaxy graph diff` reveals exactly that:
+
+```mermaid
+---
+title: Merged Graph Diff
+---
+flowchart TB
+    %%{init: {'flowchart': {'htmlLabels': true, 'curve': 'basis'}, 'themeVariables': {'fontSize': '14px'}}}%%
+
+    example_video["<div style="text-align:left"><b>example/video</b><br/><font color="#CC0000">bc9ca8</font> → <font
+color="#00AA00">6db302</font><br/><font color="#999">---</font><br/>- <font color="#FFAA00">audio</font> (<font
+color="#CC0000">227423</font> → <font color="#00AA00">09c839</font>)<br/>- frames (794116)</div>"]
+    style example_video stroke:#FFA500,stroke-width:3px
+    example_crop["<div style="text-align:left"><b>example/crop</b><br/><font color="#CC0000">3ac04d</font> → <font
+color="#00AA00">54dc7f</font><br/><font color="#999">---</font><br/>- <font color="#FFAA00">audio</font> (<font
+color="#CC0000">76c8bd</font> → <font color="#00AA00">f3130c</font>)<br/>- frames (abc790)</div>"]
+    style example_crop stroke:#FFA500,stroke-width:3px
+    example_face_detection["<div style="text-align:left"><b>example/face_detection</b><br/>1ac83b<br/><font
+color="#999">---</font><br/>- faces (2d75f0)</div>"]
+    example_stt["<div style="text-align:left"><b>example/stt</b><br/><font color="#CC0000">c83a75</font> → <font
+color="#00AA00">066d34</font><br/><font color="#999">---</font><br/>- <font color="#FFAA00">transcription</font> (<font
+color="#CC0000">ac412b</font> → <font color="#00AA00">058410</font>)</div>"]
+    style example_stt stroke:#FFA500,stroke-width:3px
+
+    example_video --> example_crop
+    example_crop --> example_face_detection
+    example_video --> example_stt
+```
+
+The versions of `audio` fields through the graph as well as the whole `FaceDetection` feature stayed the same!
+
+We can use Metaxy's static graph analysis to identify which features need to be recomputed when a new version of a feature is introduced. In addition to feature and field level versions, Metaxy can also compute a sample-level version (may be different for each sample in the one million dataset you have) ahead of computations through the whole graph. This enables exciting features such as processing cost prediction and automatic migrations for metadata.
+
+## Development
+
+Setting up the environment:
+
+```shell
+uv sync --all-extras
+uv run prek install
+```
+
+## Examples
+
+See [examples](examples/README.md).