krons 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

{kronos/core → krons/core/base}/pile.py

@@ -12,11 +12,11 @@ from uuid import UUID
 from pydantic import Field, PrivateAttr, field_serializer, field_validator
 from typing_extensions import override
 
-from kronos.errors import ExistsError, NotFoundError
-from kronos.protocols import Containable, Deserializable, Serializable, implements
-from kronos.types import Unset, UnsetType, is_unset
-from kronos.utils import extract_types, load_type_from_string, synchronized
-from kronos.utils.concurrency import Lock as AsyncLock
+from krons.core.types import Unset, UnsetType, is_unset
+from krons.errors import ExistsError, NotFoundError
+from krons.protocols import Containable, Deserializable, Serializable, implements
+from krons.utils import extract_types, load_type_from_string, synchronized
+from krons.utils.concurrency import Lock as AsyncLock
 
 from .element import Element
 from .progression import Progression
@@ -59,7 +59,9 @@ class Pile(Element, Generic[T]):
     @property
     def progression(self) -> Progression:
         """Read-only copy of progression order."""
-        return Progression(order=list(self._progression.order), name=self._progression.name)
+        return Progression(
+            order=list(self._progression.order), name=self._progression.name
+        )
 
     item_type: set[type] | None = Field(
         default=None,
@@ -104,7 +106,9 @@ class Pile(Element, Generic[T]):
             NotFoundError: If order contains UUID not in items
             TypeError: If item type validation fails
         """
-        super().__init__(**{"item_type": item_type, "strict_type": strict_type, **kwargs})
+        super().__init__(
+            **{"item_type": item_type, "strict_type": strict_type, **kwargs}
+        )
 
         if items:
             for item in items:
@@ -128,10 +132,14 @@ class Pile(Element, Generic[T]):
     def to_dict(
         self,
         mode: Literal["python", "json", "db"] = "python",
-        created_at_format: (Literal["datetime", "isoformat", "timestamp"] | UnsetType) = Unset,
+        created_at_format: (
+            Literal["datetime", "isoformat", "timestamp"] | UnsetType
+        ) = Unset,
         meta_key: str | UnsetType = Unset,
         item_meta_key: str | UnsetType = Unset,
-        item_created_at_format: (Literal["datetime", "isoformat", "timestamp"] | UnsetType) = Unset,
+        item_created_at_format: (
+            Literal["datetime", "isoformat", "timestamp"] | UnsetType
+        ) = Unset,
         **kwargs: Any,
     ) -> dict[str, Any]:
         """Serialize pile with items in progression order.
@@ -350,7 +358,9 @@ class Pile(Element, Generic[T]):
                 raise TypeError("Cannot mix int and UUID in list/tuple indexing")
             items = [self.get(uid) for uid in keys]
         else:
-            raise TypeError(f"list/tuple must contain only int or UUID, got {type(first)}")
+            raise TypeError(
+                f"list/tuple must contain only int or UUID, got {type(first)}"
+            )
 
         return Pile(
             items=items,
@@ -530,7 +540,9 @@ class Pile(Element, Generic[T]):
                 and item_type_data
                 and isinstance(item_type_data[0], str)
             ):
-                allowed_types = {load_type_from_string(type_str) for type_str in item_type_data}
+                allowed_types = {
+                    load_type_from_string(type_str) for type_str in item_type_data
+                }
             else:
                 allowed_types = extract_types(item_type_data)
 
@@ -549,7 +561,9 @@ class Pile(Element, Generic[T]):
                                 "(strict_type=True)"
                             )
                     else:
-                        if not any(issubclass(item_type_actual, t) for t in allowed_types):
+                        if not any(
+                            issubclass(item_type_actual, t) for t in allowed_types
+                        ):
                             raise TypeError(
                                 f"Item type {kron_class} is not a subclass of any allowed type {allowed_types}"
                             )

{kronos/core → krons/core/base}/processor.py

@@ -6,8 +6,8 @@ from __future__ import annotations
 import math
 from typing import TYPE_CHECKING, Any, ClassVar, Self
 
-from kronos.errors import ConfigurationError, NotFoundError, QueueFullError
-from kronos.utils import concurrency
+from krons.errors import ConfigurationError, NotFoundError, QueueFullError
+from krons.utils import concurrency
 
 from .event import Event, EventStatus
 from .flow import Flow
@@ -77,13 +77,19 @@ class Processor:
         if queue_capacity < 1:
             raise ValueError("Queue capacity must be greater than 0.")
         if queue_capacity > 10000:
-            raise ValueError("Queue capacity must be <= 10000 (prevent unbounded batches).")
+            raise ValueError(
+                "Queue capacity must be <= 10000 (prevent unbounded batches)."
+            )
 
         # Validate capacity_refresh_time (prevent hot loop or starvation)
         if capacity_refresh_time < 0.01:
-            raise ValueError("Capacity refresh time must be >= 0.01s (prevent CPU hot loop).")
+            raise ValueError(
+                "Capacity refresh time must be >= 0.01s (prevent CPU hot loop)."
+            )
         if capacity_refresh_time > 3600:
-            raise ValueError("Capacity refresh time must be <= 3600s (prevent starvation).")
+            raise ValueError(
+                "Capacity refresh time must be <= 3600s (prevent starvation)."
+            )
 
         # Validate concurrency_limit
         if concurrency_limit < 1:
@@ -105,7 +111,9 @@ class Processor:
         self.concurrency_limit = concurrency_limit
 
         # Priority queue: (priority, event_uuid) tuples, min-heap ordering
-        self.queue: concurrency.PriorityQueue[tuple[float, UUID]] = concurrency.PriorityQueue()
+        self.queue: concurrency.PriorityQueue[tuple[float, UUID]] = (
+            concurrency.PriorityQueue()
+        )
 
         self._available_capacity = queue_capacity
         self._execution_mode = False
@@ -231,7 +239,9 @@ class Processor:
                     self._denial_counts.pop(event_id, None)
 
                     if self.executor:
-                        await self.executor._update_progression(next_event, EventStatus.PROCESSING)
+                        await self.executor._update_progression(
+                            next_event, EventStatus.PROCESSING
+                        )
 
                     if next_event.streaming:
 
@@ -255,7 +265,9 @@ class Processor:
                                 if self.executor:
                                     await self.executor._update_progression(event)
 
-                        tg.start_soon(self._with_semaphore, invoke_and_update(next_event))
+                        tg.start_soon(
+                            self._with_semaphore, invoke_and_update(next_event)
+                        )
 
                     events_processed += 1
                     self._available_capacity -= 1
@@ -270,7 +282,9 @@ class Processor:
 
                     if denial_count >= 3:
                         if self.executor:
-                            await self.executor._update_progression(next_event, EventStatus.ABORTED)
+                            await self.executor._update_progression(
+                                next_event, EventStatus.ABORTED
+                            )
                         self._denial_counts.pop(event_id, None)
                     else:
                         backoff = denial_count * 1.0

{kronos/core → krons/core/base}/progression.py

@@ -9,8 +9,8 @@ from uuid import UUID
 
 from pydantic import Field, PrivateAttr, field_validator
 
-from kronos.errors import NotFoundError
-from kronos.protocols import Containable, implements
+from krons.errors import NotFoundError
+from krons.protocols import Containable, implements
 
 from .element import Element
 
@@ -177,7 +177,9 @@ class Progression(Element):
         """Set item(s) at index. Slice assignment requires list value."""
         if isinstance(index, slice):
             if not isinstance(value, list):
-                raise TypeError(f"Cannot assign {type(value).__name__} to slice, expected list")
+                raise TypeError(
+                    f"Cannot assign {type(value).__name__} to slice, expected list"
+                )
             new_uids = [self._coerce_id(v) for v in value]
             self.order[index] = new_uids
             self._rebuild_members()

{kronos → krons/core}/specs/__init__.py

@@ -4,7 +4,6 @@
 from .adapters.factory import AdapterType, get_adapter
 from .catalog import AuditSpecs, CommonSpecs, ContentSpecs
 from .operable import Operable
-from .phrase import CrudOperation, CrudPattern, Phrase, phrase
 from .protocol import SpecAdapter
 from .spec import CommonMeta, Spec
 
@@ -14,12 +13,8 @@ __all__ = (
     "CommonMeta",
     "CommonSpecs",
     "ContentSpecs",
-    "CrudOperation",
-    "CrudPattern",
     "Operable",
-    "Phrase",
     "Spec",
     "SpecAdapter",
     "get_adapter",
-    "phrase",
 )

{kronos → krons/core}/specs/adapters/dataclass_field.py

@@ -17,14 +17,14 @@ from dataclasses import field as dc_field
 from dataclasses import fields
 from typing import TYPE_CHECKING, Any
 
-from kronos.types._sentinel import Unset, UnsetType, is_sentinel
+from krons.core.types._sentinel import Unset, UnsetType, is_sentinel
 
 from ..protocol import SpecAdapter
 from ..spec import Spec
 from ._utils import resolve_annotation_to_base_types
 
 if TYPE_CHECKING:
-    from kronos.types.base import DataClass, ModelConfig, Params
+    from krons.core.types.base import DataClass, ModelConfig, Params
 
     from ..operable import Operable
 
@@ -71,7 +71,9 @@ def _make_validator_method(validators: dict[str, list[Any]], is_frozen: bool) ->
                     errors.append(ValueError(f"Validation failed for '{fname}': {e}"))
 
         if errors:
-            raise ExceptionGroup(f"Field validation failed for {type(self).__name__}", errors)
+            raise ExceptionGroup(
+                f"Field validation failed for {type(self).__name__}", errors
+            )
 
     return _validate_with_field_validators
 
@@ -149,7 +151,7 @@ class DataClassSpecAdapter(SpecAdapter[dict[str, Any]]):
         Returns:
             Dynamically created dataclass with validators wired in
         """
-        from kronos.types.base import DataClass, Params
+        from krons.core.types.base import DataClass, Params
 
         use_specs = op.get_specs(include=include, exclude=exclude)
 
@@ -176,7 +178,9 @@ class DataClassSpecAdapter(SpecAdapter[dict[str, Any]]):
             annotations[field_name] = spec.annotation
 
             if "default_factory" in field_kwargs:
-                class_attrs[field_name] = dc_field(default_factory=field_kwargs["default_factory"])
+                class_attrs[field_name] = dc_field(
+                    default_factory=field_kwargs["default_factory"]
+                )
             elif "default" in field_kwargs:
                 class_attrs[field_name] = field_kwargs["default"]
 
@@ -221,15 +225,19 @@ class DataClassSpecAdapter(SpecAdapter[dict[str, Any]]):
         return instance.to_dict()
 
     @classmethod
-    def extract_specs(cls, structure: type[Params] | type[DataClass]) -> tuple[Spec, ...]:
+    def extract_specs(
+        cls, structure: type[Params] | type[DataClass]
+    ) -> tuple[Spec, ...]:
         """Extract Specs from DataClass/Params, preserving defaults and type modifiers.
 
         Raises:
             TypeError: If structure is not a DataClass or Params subclass
         """
-        from kronos.types.base import DataClass, Params
+        from krons.core.types.base import DataClass, Params
 
-        if not isinstance(structure, type) or not issubclass(structure, (DataClass, Params)):
+        if not isinstance(structure, type) or not issubclass(
+            structure, (DataClass, Params)
+        ):
             raise TypeError(
                 f"structure must be a DataClass or Params subclass, got {type(structure)}"
             )

{kronos → krons/core}/specs/adapters/pydantic_adapter.py

@@ -20,15 +20,21 @@ from pydantic.fields import FieldInfo
 from pydantic_core import PydanticUndefined
 from pydantic_core._pydantic_core import PydanticUndefinedType
 
-from kronos.specs.protocol import SpecAdapter
-from kronos.specs.spec import Spec
-from kronos.types._sentinel import Unset, UnsetType, is_sentinel, is_unset, not_sentinel
-from kronos.types.db_types import FKMeta, VectorMeta
+from krons.core.specs.protocol import SpecAdapter
+from krons.core.specs.spec import Spec
+from krons.core.types._sentinel import (
+    Unset,
+    UnsetType,
+    is_sentinel,
+    is_unset,
+    not_sentinel,
+)
+from krons.core.types.db_types import FKMeta, VectorMeta
 
 from ._utils import resolve_annotation_to_base_types
 
 if TYPE_CHECKING:
-    from kronos.specs.operable import Operable
+    from krons.core.specs.operable import Operable
 
 __all__ = ("PydanticSpecAdapter",)
 

{kronos → krons/core}/specs/adapters/sql_ddl.py

@@ -27,16 +27,22 @@ from enum import StrEnum
 from typing import TYPE_CHECKING, Annotated, Any, get_args, get_origin
 from uuid import UUID
 
-from kronos.types._sentinel import Unset, UnsetType, is_sentinel
-from kronos.types.db_types import FK, FKMeta, Vector, VectorMeta, extract_kron_db_meta
-from kronos.utils.sql import validate_identifier
+from krons.core.types._sentinel import Unset, UnsetType, is_sentinel
+from krons.core.types.db_types import (
+    FK,
+    FKMeta,
+    Vector,
+    VectorMeta,
+    extract_kron_db_meta,
+)
+from krons.utils.sql import validate_identifier
 
 from ..protocol import SpecAdapter
 from ._utils import resolve_annotation_to_base_types
 
 if TYPE_CHECKING:
-    from kronos.specs.operable import Operable
-    from kronos.specs.spec import Spec
+    from krons.core.specs.operable import Operable
+    from krons.core.specs.spec import Spec
 
 __all__ = (
     # Enums
@@ -414,9 +420,7 @@ class UniqueConstraintSpec:
         for col in self.columns:
             validate_identifier(col, "column name")
         cols = ", ".join(f'"{c}"' for c in self.columns)
-        return (
-            f'ALTER TABLE "{schema}"."{table_name}" ADD CONSTRAINT "{self.name}" UNIQUE ({cols});'
-        )
+        return f'ALTER TABLE "{schema}"."{table_name}" ADD CONSTRAINT "{self.name}" UNIQUE ({cols});'
 
 
 @dataclass(frozen=True, slots=True)
@@ -468,7 +472,9 @@ class TableSpec:
         col_lines = col_separator.join(col_defs)
 
         exists_clause = "IF NOT EXISTS " if if_not_exists else ""
-        return f"CREATE TABLE {exists_clause}{self.qualified_name} (\n    {col_lines}\n);"
+        return (
+            f"CREATE TABLE {exists_clause}{self.qualified_name} (\n    {col_lines}\n);"
+        )
 
     def to_full_ddl(self) -> list[str]:
         """Generate all DDL statements for this table.
@@ -672,7 +678,7 @@ class SchemaSpec:
         Returns:
             SchemaSpec with version hash computed from table definitions.
         """
-        from kronos.utils import compute_hash
+        from krons.utils import compute_hash
 
         tables = [
             TableSpec.from_operable(op, name, schema=schema)

{kronos → krons/core}/specs/catalog/__init__.py

@@ -9,14 +9,14 @@ Pre-defined Specs for common database patterns:
 - **CommonSpecs**: name, slug, status, email, phone, tenant_id, settings
 
 Usage:
-    from kronos.specs.catalog import ContentSpecs, AuditSpecs
+    from krons.core.specs.catalog import ContentSpecs, AuditSpecs
 
     content_specs = ContentSpecs.get_specs(dim=1536)
     audit_specs = AuditSpecs.get_specs(use_uuid=True)
     all_specs = content_specs + audit_specs
 
 For custom Specs, use the factories directly:
-    from kronos.specs.factory import create_embedding_spec, create_content_spec
+    from krons.core.specs.factory import create_embedding_spec, create_content_spec
 
     my_embedding = create_embedding_spec("embedding", dim=1536)
     my_content = create_content_spec("payload", content_type=MyModel)

{kronos → krons/core}/specs/catalog/_audit.py

@@ -10,9 +10,9 @@ from uuid import UUID
 
 from pydantic import BaseModel, Field
 
-from kronos.specs.operable import Operable
-from kronos.specs.spec import Spec
-from kronos.utils import now_utc
+from krons.core.specs.operable import Operable
+from krons.core.specs.spec import Spec
+from krons.utils import now_utc
 
 
 class AuditSpecs(BaseModel):

{kronos → krons/core}/specs/catalog/_common.py

@@ -10,8 +10,8 @@ from uuid import UUID
 
 from pydantic import BaseModel
 
-from kronos.specs.operable import Operable
-from kronos.specs.spec import Spec
+from krons.core.specs.operable import Operable
+from krons.core.specs.spec import Spec
 
 
 class CommonSpecs(BaseModel):

{kronos → krons/core}/specs/catalog/_content.py

@@ -11,11 +11,11 @@ from uuid import UUID, uuid4
 
 from pydantic import BaseModel, Field
 
-from kronos.specs.operable import Operable
-from kronos.specs.spec import Spec
-from kronos.types._sentinel import Unset, UnsetType
-from kronos.types.db_types import VectorMeta
-from kronos.utils import now_utc
+from krons.core.specs.operable import Operable
+from krons.core.specs.spec import Spec
+from krons.core.types._sentinel import Unset, UnsetType
+from krons.core.types.db_types import VectorMeta
+from krons.utils import now_utc
 
 
 class ContentSpecs(BaseModel):

{kronos → krons/core}/specs/catalog/_enforcement.py

@@ -10,10 +10,10 @@ from typing import Any
 
 from pydantic import BaseModel, Field, field_validator
 
-from kronos.specs.operable import Operable
-from kronos.specs.spec import Spec
-from kronos.types.base import Enum
-from kronos.utils import now_utc
+from krons.core.specs.operable import Operable
+from krons.core.specs.spec import Spec
+from krons.core.types.base import Enum
+from krons.utils import now_utc
 
 __all__ = (
     "EnforcementLevel",

{kronos → krons/core}/specs/factory.py

@@ -8,14 +8,14 @@ from __future__ import annotations
 from datetime import datetime
 from uuid import UUID, uuid4
 
-from kronos.specs.spec import Spec, not_sentinel
-from kronos.types import UnsetType
-from kronos.types._sentinel import Unset
-from kronos.types.base import is_sentinel
+from krons.core.specs.spec import Spec, not_sentinel
+from krons.core.types import UnsetType
+from krons.core.types._sentinel import Unset
+from krons.core.types.base import is_sentinel
 
 
 def create_datetime_spec(name: str, *, use_default: bool) -> Spec:
-    from kronos.utils._utils import coerce_created_at, now_utc
+    from krons.utils._utils import coerce_created_at, now_utc
 
     return Spec(
         datetime,
@@ -26,7 +26,7 @@ def create_datetime_spec(name: str, *, use_default: bool) -> Spec:
 
 
 def create_uuid_spec(name: str, *, use_default: bool) -> Spec:
-    from kronos.utils._utils import to_uuid
+    from krons.utils._utils import to_uuid
 
     return Spec(
         UUID,
@@ -74,7 +74,7 @@ def create_embedding_spec(
             return Spec(list[float], name=name, default_factory=list)
         return Spec(list[float], name=name)
 
-    from kronos.specs.adapters.sql_ddl import Vector
+    from krons.core.specs.adapters.sql_ddl import Vector
 
     return Spec(Vector[dim], name=name)
 

{kronos → krons/core}/specs/operable.py

@@ -6,8 +6,14 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Self
 
-from kronos.protocols import Allowable, Hashable, implements
-from kronos.types._sentinel import MaybeUnset, Unset, UnsetType, is_unset, not_sentinel
+from krons.core.types._sentinel import (
+    MaybeUnset,
+    Unset,
+    UnsetType,
+    is_unset,
+    not_sentinel,
+)
+from krons.protocols import Allowable, Hashable, implements
 
 from .adapters.factory import AdapterType, get_adapter
 from .protocol import SpecAdapter
@@ -311,4 +317,4 @@ class Operable:
         Returns:
             Dict representation of the instance
         """
-        return self.adapter.dump_instance(instance, self)
+        return self.adapter.dump_instance(instance)

{kronos → krons/core}/specs/protocol.py

@@ -24,7 +24,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
-from kronos.types._sentinel import Unset, UnsetType
+from krons.core.types._sentinel import Unset, UnsetType
 
 if TYPE_CHECKING:
     from .operable import Operable
@@ -126,7 +126,9 @@ class SpecAdapter(ABC, Generic[F]):
         Raises:
             NotImplementedError: If adapter doesn't support instance creation
         """
-        raise NotImplementedError(f"{cls.__name__} does not support instance validation")
+        raise NotImplementedError(
+            f"{cls.__name__} does not support instance validation"
+        )
 
     @classmethod
     def dump_instance(cls, instance: Any, **kwargs) -> dict[str, Any]:

{kronos → krons/core}/specs/spec.py

@@ -11,16 +11,16 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Annotated, Any, Self
 
-from kronos.protocols import Hashable, implements
-from kronos.types._sentinel import (
+from krons.core.types._sentinel import (
     MaybeUndefined,
     Undefined,
     is_sentinel,
     is_undefined,
     not_sentinel,
 )
-from kronos.types.base import Enum, Meta
-from kronos.utils.concurrency import is_coro_func
+from krons.core.types.base import Enum, Meta
+from krons.protocols import Hashable, implements
+from krons.utils.concurrency import is_coro_func
 
 # Global cache for annotated types with bounded size
 _MAX_CACHE_SIZE = int(os.environ.get("kron_FIELD_CACHE_SIZE", "10000"))
@@ -64,13 +64,17 @@ class CommonMeta(Enum):
         errors: list[Exception] = []
 
         if kw.get("default") and kw.get("default_factory"):
-            errors.append(ValueError("Cannot provide both 'default' and 'default_factory'"))
+            errors.append(
+                ValueError("Cannot provide both 'default' and 'default_factory'")
+            )
         if (_df := kw.get("default_factory")) and not callable(_df):
             errors.append(ValueError("'default_factory' must be callable"))
         if _val := kw.get("validator"):
             _val = [_val] if not isinstance(_val, list) else _val
             if not all(callable(v) for v in _val):
-                errors.append(ValueError("Validators must be a list of functions or a function"))
+                errors.append(
+                    ValueError("Validators must be a list of functions or a function")
+                )
 
         if errors:
             raise ExceptionGroup("Metadata validation failed", errors)
@@ -81,7 +85,7 @@ class CommonMeta(Enum):
     ) -> tuple[Meta, ...]:
         """Prepare metadata tuple from args/kw. Validates no duplicates, constraints."""
         # Lazy import to avoid circular dependency
-        from kronos.utils._to_list import to_list
+        from krons.utils._to_list import to_list
 
         seen_keys = set()
         metas = []
@@ -192,7 +196,9 @@ class Spec:
                 or isinstance(base_type, types.UnionType)
             )
             if not is_valid_type:
-                raise ValueError(f"base_type must be a type or type annotation, got {base_type}")
+                raise ValueError(
+                    f"base_type must be a type or type annotation, got {base_type}"
+                )
 
         if kw.get("default_factory") and is_coro_func(kw["default_factory"]):
             import warnings
@@ -389,7 +395,9 @@ class Spec:
 
         return spec
 
-    def with_validator(self, validator: Callable[..., Any] | list[Callable[..., Any]]) -> Self:
+    def with_validator(
+        self, validator: Callable[..., Any] | list[Callable[..., Any]]
+    ) -> Self:
         """Return new Spec with validator function(s) attached."""
         return self.with_updates(validator=validator)
 
@@ -407,7 +415,7 @@ class Spec:
         if not is_undefined(fk):
             from uuid import UUID
 
-            from kronos.types.db_types import FKMeta
+            from krons.core.types.db_types import FKMeta
 
             t_ = Annotated[UUID, FKMeta(fk)]  # type: ignore[valid-type]
         if self.is_listable:
@@ -431,7 +439,9 @@ class Spec:
                 _annotated_cache.move_to_end(cache_key)
                 return _annotated_cache[cache_key]
 
-            actual_type = Any if is_sentinel(self.base_type, {"none"}) else self.base_type
+            actual_type = (
+                Any if is_sentinel(self.base_type, {"none"}) else self.base_type
+            )
             current_metadata = self.metadata
 
             # Resolve FK target (explicit or Observable base_type)
@@ -440,7 +450,7 @@ class Spec:
             if not is_undefined(resolved_fk):
                 from uuid import UUID
 
-                from kronos.types.db_types import FKMeta
+                from krons.core.types.db_types import FKMeta
 
                 actual_type = UUID  # FK fields are UUID references
                 extra_annotations.append(FKMeta(resolved_fk))
@@ -475,7 +485,9 @@ class Spec:
             exclude = set()
         if exclude_common:
             exclude = exclude | set(CommonMeta.allowed())
-        return {meta.key: meta.value for meta in self.metadata if meta.key not in exclude}
+        return {
+            meta.key: meta.value for meta in self.metadata if meta.key not in exclude
+        }
 
 
 def _is_observable(cls: type) -> bool: