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

{kronos → krons}/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.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.types.base import DataClass, ModelConfig, Params
 
     from ..operable import Operable
 
@@ -149,7 +149,7 @@ class DataClassSpecAdapter(SpecAdapter[dict[str, Any]]):
         Returns:
             Dynamically created dataclass with validators wired in
         """
-        from kronos.types.base import DataClass, Params
+        from krons.types.base import DataClass, Params
 
         use_specs = op.get_specs(include=include, exclude=exclude)
 
@@ -227,7 +227,7 @@ class DataClassSpecAdapter(SpecAdapter[dict[str, Any]]):
         Raises:
             TypeError: If structure is not a DataClass or Params subclass
         """
-        from kronos.types.base import DataClass, Params
+        from krons.types.base import DataClass, Params
 
         if not isinstance(structure, type) or not issubclass(structure, (DataClass, Params)):
             raise TypeError(

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

@@ -20,15 +20,15 @@ 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.specs.protocol import SpecAdapter
+from krons.specs.spec import Spec
+from krons.types._sentinel import Unset, UnsetType, is_sentinel, is_unset, not_sentinel
+from krons.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.specs.operable import Operable
 
 __all__ = ("PydanticSpecAdapter",)
 

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

@@ -27,16 +27,16 @@ 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.types._sentinel import Unset, UnsetType, is_sentinel
+from krons.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.specs.operable import Operable
+    from krons.specs.spec import Spec
 
 __all__ = (
     # Enums
@@ -672,7 +672,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}/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.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.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}/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.specs.operable import Operable
+from krons.specs.spec import Spec
+from krons.utils import now_utc
 
 
 class AuditSpecs(BaseModel):

{kronos → krons}/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.specs.operable import Operable
+from krons.specs.spec import Spec
 
 
 class CommonSpecs(BaseModel):

{kronos → krons}/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.specs.operable import Operable
+from krons.specs.spec import Spec
+from krons.types._sentinel import Unset, UnsetType
+from krons.types.db_types import VectorMeta
+from krons.utils import now_utc
 
 
 class ContentSpecs(BaseModel):

{kronos → krons}/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.specs.operable import Operable
+from krons.specs.spec import Spec
+from krons.types.base import Enum
+from krons.utils import now_utc
 
 __all__ = (
     "EnforcementLevel",

{kronos → krons}/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.specs.spec import Spec, not_sentinel
+from krons.types import UnsetType
+from krons.types._sentinel import Unset
+from krons.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.specs.adapters.sql_ddl import Vector
 
     return Spec(Vector[dim], name=name)
 

{kronos → krons}/specs/operable.py

@@ -6,8 +6,8 @@ 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.protocols import Allowable, Hashable, implements
+from krons.types._sentinel import MaybeUnset, Unset, UnsetType, is_unset, not_sentinel
 
 from .adapters.factory import AdapterType, get_adapter
 from .protocol import SpecAdapter

{kronos → krons}/specs/phrase.py

@@ -6,7 +6,7 @@ A Phrase wraps an async handler with:
 - Validation via Operable
 
 Usage with decorator (custom handler):
-    from kronos.specs import Operable, phrase
+    from krons.specs import Operable, phrase
 
     consent_operable = Operable([
         Spec("subject_id", UUID),
@@ -25,7 +25,7 @@ Usage with decorator (custom handler):
     result = await verify_consent({"subject_id": id, "scope": "background"}, ctx)
 
 Usage with CrudPattern (declarative):
-    from kronos.specs import Operable, phrase, CrudPattern
+    from krons.specs import Operable, phrase, CrudPattern
 
     def check_has_consent(row):
         return {"has_consent": row["status"] in {"active"} if row else False}
@@ -50,8 +50,8 @@ from enum import Enum
 from types import MappingProxyType
 from typing import Any
 
-from kronos.types import Unset, is_unset
-from kronos.utils.sql import validate_identifier
+from krons.types import Unset, is_unset
+from krons.utils.sql import validate_identifier
 
 from .operable import Operable
 

{kronos → krons}/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.types._sentinel import Unset, UnsetType
 
 if TYPE_CHECKING:
     from .operable import Operable

{kronos → krons}/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.protocols import Hashable, implements
+from krons.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.types.base import Enum, Meta
+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"))
@@ -81,7 +81,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 = []
@@ -407,7 +407,7 @@ class Spec:
         if not is_undefined(fk):
             from uuid import UUID
 
-            from kronos.types.db_types import FKMeta
+            from krons.types.db_types import FKMeta
 
             t_ = Annotated[UUID, FKMeta(fk)]  # type: ignore[valid-type]
         if self.is_listable:
@@ -440,7 +440,7 @@ class Spec:
             if not is_undefined(resolved_fk):
                 from uuid import UUID
 
-                from kronos.types.db_types import FKMeta
+                from krons.types.db_types import FKMeta
 
                 actual_type = UUID  # FK fields are UUID references
                 extra_annotations.append(FKMeta(resolved_fk))

{kronos → krons}/types/base.py

@@ -28,8 +28,8 @@ from typing import Any, ClassVar, Literal, Self, TypedDict
 from pydantic import BaseModel as _PydanticBaseModel
 from typing_extensions import override
 
-from kronos.protocols import Allowable, Hashable, Serializable, implements
-from kronos.utils._hash import hash_obj
+from krons.protocols import Allowable, Hashable, Serializable, implements
+from krons.utils._hash import hash_obj
 
 from ._sentinel import Undefined, Unset, is_sentinel, is_undefined
 
@@ -152,7 +152,7 @@ class _SentinelMixin:
                 if not self._is_sentinel(v):
                     data[k] = self._normalize_value(v)
         if mode == "json":
-            from kronos.utils._json_dump import json_dump
+            from krons.utils._json_dump import json_dump
 
             return json_dump(data, decode=True, as_loaded=True, **kwargs)
 

{kronos → krons}/types/db_types.py

@@ -18,7 +18,7 @@ import types
 from typing import Annotated, Any, Literal, Union, get_args, get_origin
 from uuid import UUID
 
-from kronos.types._sentinel import Unset, UnsetType, not_sentinel
+from krons.types._sentinel import Unset, UnsetType, not_sentinel
 
 
 def _is_field_info(obj: Any) -> bool:
@@ -237,7 +237,7 @@ def extract_kron_db_meta(
 
     else:
         # Try Spec (lazy import to avoid circular)
-        from kronos.specs.spec import Spec
+        from krons.specs.spec import Spec
 
         if isinstance(from_, Spec):
             if metas in ("FK", "BOTH"):

{kronos → krons}/types/identity.py

@@ -7,7 +7,7 @@ Provides ID[T] syntax for associating UUIDs with specific model types,
 enabling compile-time type checking and runtime semantic clarity.
 
 Usage:
-    from kronos.types import ID
+    from krons.types import ID
 
     user_id: ID[User] = uuid4()
     org_id: ID[Organization] = uuid4()

{kronos → krons}/utils/_to_list.py

@@ -29,7 +29,7 @@ def _do_init() -> None:
     from pydantic import BaseModel
     from pydantic_core import PydanticUndefinedType
 
-    from kronos.types import UndefinedType, UnsetType
+    from krons.types import UndefinedType, UnsetType
 
     global _MODEL_LIKE, _MAP_LIKE, _SINGLETONE_TYPES, _SKIP_TYPE, _SKIP_TUPLE_SET
     _MODEL_LIKE = (BaseModel,)

{kronos → krons}/utils/_utils.py

@@ -13,7 +13,7 @@ from uuid import UUID, uuid4
 
 from anyio import Path as AsyncPath
 
-from kronos.protocols import Observable
+from krons.protocols import Observable
 
 __all__ = (
     "create_path",
@@ -188,7 +188,7 @@ def is_import_installed(package_name: str) -> bool:
 
 _TYPE_CACHE: dict[str, type] = {}
 
-_DEFAULT_ALLOWED_PREFIXES: frozenset[str] = frozenset({"kronos."})
+_DEFAULT_ALLOWED_PREFIXES: frozenset[str] = frozenset({"krons."})
 _ALLOWED_MODULE_PREFIXES: set[str] = set(_DEFAULT_ALLOWED_PREFIXES)
 
 
@@ -210,7 +210,7 @@ def register_type_prefix(prefix: str) -> None:
 
 
 def load_type_from_string(type_str: str) -> type:
-    """Load type from fully qualified path (e.g., 'kronos.core.Node').
+    """Load type from fully qualified path (e.g., 'krons.core.Node').
 
     Security: Only allowlisted module prefixes can be loaded.
 

{kronos → krons}/utils/concurrency/__init__.py

@@ -37,63 +37,63 @@ from typing import TYPE_CHECKING
 
 _LAZY_IMPORTS: dict[str, tuple[str, str]] = {
     # _cancel
-    "CancelScope": ("kronos.utils.concurrency._cancel", "CancelScope"),
-    "effective_deadline": ("kronos.utils.concurrency._cancel", "effective_deadline"),
-    "fail_after": ("kronos.utils.concurrency._cancel", "fail_after"),
-    "fail_at": ("kronos.utils.concurrency._cancel", "fail_at"),
-    "move_on_after": ("kronos.utils.concurrency._cancel", "move_on_after"),
-    "move_on_at": ("kronos.utils.concurrency._cancel", "move_on_at"),
+    "CancelScope": ("krons.utils.concurrency._cancel", "CancelScope"),
+    "effective_deadline": ("krons.utils.concurrency._cancel", "effective_deadline"),
+    "fail_after": ("krons.utils.concurrency._cancel", "fail_after"),
+    "fail_at": ("krons.utils.concurrency._cancel", "fail_at"),
+    "move_on_after": ("krons.utils.concurrency._cancel", "move_on_after"),
+    "move_on_at": ("krons.utils.concurrency._cancel", "move_on_at"),
     # _errors
     "get_cancelled_exc_class": (
-        "kronos.utils.concurrency._errors",
+        "krons.utils.concurrency._errors",
         "get_cancelled_exc_class",
     ),
-    "is_cancelled": ("kronos.utils.concurrency._errors", "is_cancelled"),
+    "is_cancelled": ("krons.utils.concurrency._errors", "is_cancelled"),
     "non_cancel_subgroup": (
-        "kronos.utils.concurrency._errors",
+        "krons.utils.concurrency._errors",
         "non_cancel_subgroup",
     ),
-    "shield": ("kronos.utils.concurrency._errors", "shield"),
+    "shield": ("krons.utils.concurrency._errors", "shield"),
     # _patterns
-    "CompletionStream": ("kronos.utils.concurrency._patterns", "CompletionStream"),
-    "bounded_map": ("kronos.utils.concurrency._patterns", "bounded_map"),
-    "gather": ("kronos.utils.concurrency._patterns", "gather"),
-    "race": ("kronos.utils.concurrency._patterns", "race"),
-    "retry": ("kronos.utils.concurrency._patterns", "retry"),
+    "CompletionStream": ("krons.utils.concurrency._patterns", "CompletionStream"),
+    "bounded_map": ("krons.utils.concurrency._patterns", "bounded_map"),
+    "gather": ("krons.utils.concurrency._patterns", "gather"),
+    "race": ("krons.utils.concurrency._patterns", "race"),
+    "retry": ("krons.utils.concurrency._patterns", "retry"),
     # _primitives
-    "CapacityLimiter": ("kronos.utils.concurrency._primitives", "CapacityLimiter"),
-    "Condition": ("kronos.utils.concurrency._primitives", "Condition"),
-    "Event": ("kronos.utils.concurrency._primitives", "Event"),
-    "Lock": ("kronos.utils.concurrency._primitives", "Lock"),
-    "Queue": ("kronos.utils.concurrency._primitives", "Queue"),
-    "Semaphore": ("kronos.utils.concurrency._primitives", "Semaphore"),
+    "CapacityLimiter": ("krons.utils.concurrency._primitives", "CapacityLimiter"),
+    "Condition": ("krons.utils.concurrency._primitives", "Condition"),
+    "Event": ("krons.utils.concurrency._primitives", "Event"),
+    "Lock": ("krons.utils.concurrency._primitives", "Lock"),
+    "Queue": ("krons.utils.concurrency._primitives", "Queue"),
+    "Semaphore": ("krons.utils.concurrency._primitives", "Semaphore"),
     # _priority_queue
-    "PriorityQueue": ("kronos.utils.concurrency._priority_queue", "PriorityQueue"),
-    "QueueEmpty": ("kronos.utils.concurrency._priority_queue", "QueueEmpty"),
-    "QueueFull": ("kronos.utils.concurrency._priority_queue", "QueueFull"),
+    "PriorityQueue": ("krons.utils.concurrency._priority_queue", "PriorityQueue"),
+    "QueueEmpty": ("krons.utils.concurrency._priority_queue", "QueueEmpty"),
+    "QueueFull": ("krons.utils.concurrency._priority_queue", "QueueFull"),
     # _resource_tracker
-    "LeakInfo": ("kronos.utils.concurrency._resource_tracker", "LeakInfo"),
-    "LeakTracker": ("kronos.utils.concurrency._resource_tracker", "LeakTracker"),
+    "LeakInfo": ("krons.utils.concurrency._resource_tracker", "LeakInfo"),
+    "LeakTracker": ("krons.utils.concurrency._resource_tracker", "LeakTracker"),
     "track_resource": (
-        "kronos.utils.concurrency._resource_tracker",
+        "krons.utils.concurrency._resource_tracker",
         "track_resource",
     ),
     "untrack_resource": (
-        "kronos.utils.concurrency._resource_tracker",
+        "krons.utils.concurrency._resource_tracker",
         "untrack_resource",
     ),
     # _run_async
-    "run_async": ("kronos.utils.concurrency._run_async", "run_async"),
+    "run_async": ("krons.utils.concurrency._run_async", "run_async"),
     # _task
-    "TaskGroup": ("kronos.utils.concurrency._task", "TaskGroup"),
-    "create_task_group": ("kronos.utils.concurrency._task", "create_task_group"),
+    "TaskGroup": ("krons.utils.concurrency._task", "TaskGroup"),
+    "create_task_group": ("krons.utils.concurrency._task", "create_task_group"),
     # _utils
-    "current_time": ("kronos.utils.concurrency._utils", "current_time"),
-    "is_coro_func": ("kronos.utils.concurrency._utils", "is_coro_func"),
-    "run_sync": ("kronos.utils.concurrency._utils", "run_sync"),
-    "sleep": ("kronos.utils.concurrency._utils", "sleep"),
-    "alcall": ("kronos.utils.concurrency._async_call", "alcall"),
-    "bcall": ("kronos.utils.concurrency._async_call", "bcall"),
+    "current_time": ("krons.utils.concurrency._utils", "current_time"),
+    "is_coro_func": ("krons.utils.concurrency._utils", "is_coro_func"),
+    "run_sync": ("krons.utils.concurrency._utils", "run_sync"),
+    "sleep": ("krons.utils.concurrency._utils", "sleep"),
+    "alcall": ("krons.utils.concurrency._async_call", "alcall"),
+    "bcall": ("krons.utils.concurrency._async_call", "bcall"),
 }
 
 _LOADED: dict[str, object] = {}
@@ -122,7 +122,7 @@ def __getattr__(name: str) -> object:
         _LOADED[name] = value
         return value
 
-    raise AttributeError(f"module 'kronos.utils.concurrency' has no attribute {name!r}")
+    raise AttributeError(f"module 'krons.utils.concurrency' has no attribute {name!r}")
 
 
 def __dir__() -> list[str]:

{kronos → krons}/utils/concurrency/_async_call.py

@@ -11,9 +11,9 @@ Primary exports:
 from collections.abc import AsyncGenerator, Callable
 from typing import Any, ParamSpec, TypeVar
 
-from kronos.types._sentinel import Unset, not_sentinel
-from kronos.utils._lazy_init import LazyInit
-from kronos.utils._to_list import to_list
+from krons.types._sentinel import Unset, not_sentinel
+from krons.utils._lazy_init import LazyInit
+from krons.utils._to_list import to_list
 
 from ._cancel import move_on_after
 from ._errors import get_cancelled_exc_class

{kronos → krons}/utils/fuzzy/_fuzzy_match.py

@@ -4,9 +4,9 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any, Literal
 
 if TYPE_CHECKING:
-    from kronos.types import KeysLike
+    from krons.types import KeysLike
 
-from kronos.types._sentinel import Unset
+from krons.types._sentinel import Unset
 
 from ._string_similarity import SimilarityAlgo, string_similarity
 

{kronos → krons}/utils/sql/_sql_validation.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 import re
 
-from kronos.errors import ValidationError
+from krons.errors import ValidationError
 
 __all__ = (
     "validate_identifier",

{krons-0.1.0.dist-info → krons-0.1.1.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: krons
-Version: 0.1.0
+Version: 0.1.1
 Summary: Spec-based composable framework for building type-safe systems
-Project-URL: Homepage, https://github.com/khive-ai/kronos
-Project-URL: Repository, https://github.com/khive-ai/kronos
-Project-URL: Issues, https://github.com/khive-ai/kronos/issues
+Project-URL: Homepage, https://github.com/khive-ai/krons
+Project-URL: Repository, https://github.com/khive-ai/krons
+Project-URL: Issues, https://github.com/khive-ai/krons/issues
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -46,7 +46,7 @@ pip install krons
 ## Quick Start
 
 ```python
-from kronos.specs import Spec, Operable
+from krons.specs import Spec, Operable
 
 # Define specs
 name_spec = Spec(str, name="name")