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

krons/work/rules/__init__.py

@@ -0,0 +1,47 @@
+# Copyright (c) 2025 - 2026, HaiyangLi <quantocean.li at gmail dot com>
+# SPDX-License-Identifier: Apache-2.0
+
+"""Rules module: validation rules with auto-correction support.
+
+Core exports:
+- Rule, RuleParams, RuleQualifier: Base rule classes
+- ValidationError: Validation failure exception
+- Validator: Spec-aware validation orchestrator
+- RuleRegistry: Type-to-rule mapping with inheritance
+- Common rules: StringRule, NumberRule, BooleanRule, ChoiceRule, MappingRule, BaseModelRule
+"""
+
+from krons.errors import ValidationError
+
+from .common import (
+    BaseModelRule,
+    BooleanRule,
+    ChoiceRule,
+    MappingRule,
+    NumberRule,
+    StringRule,
+)
+from .registry import RuleRegistry, get_default_registry, reset_default_registry
+from .rule import Rule, RuleParams, RuleQualifier
+from .validator import Validator
+
+__all__ = (
+    # Base classes
+    "Rule",
+    "RuleParams",
+    "RuleQualifier",
+    "ValidationError",
+    # Validator
+    "Validator",
+    # Registry
+    "RuleRegistry",
+    "get_default_registry",
+    "reset_default_registry",
+    # Common rules
+    "BaseModelRule",
+    "BooleanRule",
+    "ChoiceRule",
+    "MappingRule",
+    "NumberRule",
+    "StringRule",
+)

krons/{enforcement → work/rules}/common/boolean.py

@@ -50,7 +50,9 @@ class BooleanRule(Rule):
             ValueError: If not a boolean
         """
         if not isinstance(v, bool):
-            raise ValueError(f"Invalid boolean value: expected bool, got {type(v).__name__}")
+            raise ValueError(
+                f"Invalid boolean value: expected bool, got {type(v).__name__}"
+            )
 
     async def perform_fix(self, v: Any, _t: type) -> Any:
         """Attempt to convert value to boolean.

krons/{enforcement → work/rules}/common/choice.py

@@ -58,7 +58,9 @@ class ChoiceRule(Rule):
         self.case_sensitive = case_sensitive
 
         if not case_sensitive:
-            self._lower_map = {str(c).lower(): c for c in self.choices if isinstance(c, str)}
+            self._lower_map = {
+                str(c).lower(): c for c in self.choices if isinstance(c, str)
+            }
 
     async def validate(self, v: Any, t: type, **kw) -> None:
         """Validate that value is in allowed choices (exact match only).
@@ -72,7 +74,9 @@ class ChoiceRule(Rule):
         if v in self.choices:
             return
 
-        raise ValueError(f"Invalid choice: {v} not in {sorted(str(c) for c in self.choices)}")
+        raise ValueError(
+            f"Invalid choice: {v} not in {sorted(str(c) for c in self.choices)}"
+        )
 
     async def perform_fix(self, v: Any, _t: type) -> Any:
         """Attempt to fix value to closest choice.
@@ -94,4 +98,6 @@ class ChoiceRule(Rule):
             if v_lower in self._lower_map:
                 return self._lower_map[v_lower]
 
-        raise ValueError(f"Cannot fix choice: {v} not in {sorted(str(c) for c in self.choices)}")
+        raise ValueError(
+            f"Cannot fix choice: {v} not in {sorted(str(c) for c in self.choices)}"
+        )

krons/{enforcement → work/rules}/common/number.py

@@ -66,7 +66,9 @@ class NumberRule(Rule):
             ValueError: If not a number or constraints violated
         """
         if not isinstance(v, (int, float)):
-            raise ValueError(f"Invalid number value: expected int or float, got {type(v).__name__}")
+            raise ValueError(
+                f"Invalid number value: expected int or float, got {type(v).__name__}"
+            )
 
         if self.ge is not None and v < self.ge:
             raise ValueError(f"Number too small: {v} < {self.ge}")

krons/{enforcement → work/rules}/common/string.py

@@ -103,14 +103,18 @@ class StringRule(Rule):
             ValueError: If not a string or constraints violated
         """
         if not isinstance(v, str):
-            raise ValueError(f"Invalid string value: expected str, got {type(v).__name__}")
+            raise ValueError(
+                f"Invalid string value: expected str, got {type(v).__name__}"
+            )
 
         if self.min_length is not None and len(v) < self.min_length:
             raise ValueError(
                 f"String too short: got {len(v)} characters, minimum {self.min_length}"
             )
         if self.max_length is not None and len(v) > self.max_length:
-            raise ValueError(f"String too long: got {len(v)} characters, maximum {self.max_length}")
+            raise ValueError(
+                f"String too long: got {len(v)} characters, maximum {self.max_length}"
+            )
 
         if self._compiled_pattern is not None:
             if len(v) > self.regex_max_input_length:
@@ -119,7 +123,9 @@ class StringRule(Rule):
                     f"maximum {self.regex_max_input_length}"
                 )
             if not self._compiled_pattern.match(v):
-                raise ValueError(f"String does not match required pattern: {self.pattern}")
+                raise ValueError(
+                    f"String does not match required pattern: {self.pattern}"
+                )
 
     async def perform_fix(self, v: Any, t: type) -> Any:
         """Attempt to convert value to string and re-validate.

krons/{enforcement → work/rules}/rule.py

@@ -8,8 +8,8 @@ from dataclasses import dataclass, field
 from enum import IntEnum, auto
 from typing import Any
 
+from krons.core.types import Params
 from krons.errors import ValidationError
-from krons.types import Params
 
 __all__ = ("Rule", "RuleParams", "RuleQualifier", "ValidationError")
 

krons/{enforcement → work/rules}/validator.py

@@ -7,14 +7,16 @@ from collections import deque
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, ClassVar
 
-from krons.types import is_sentinel
+from krons.core.types import is_sentinel, not_sentinel
 from krons.utils.concurrency import is_coro_func
 
 from .registry import RuleRegistry, get_default_registry
 from .rule import Rule, ValidationError
 
 if TYPE_CHECKING:
-    from krons.specs import Operable, Spec
+    from pydantic import BaseModel
+
+    from krons.core.specs import Operable, Spec
 
 __all__ = ("Validator",)
 
@@ -29,7 +31,9 @@ class Validator:
     ):
         self.registry = registry or get_default_registry()
         max_entries = (
-            max_log_entries if max_log_entries is not None else self.DEFAULT_MAX_LOG_ENTRIES
+            max_log_entries
+            if max_log_entries is not None
+            else self.DEFAULT_MAX_LOG_ENTRIES
         )
         self.validation_log: deque[dict[str, Any]] = deque(
             maxlen=max_entries if max_entries > 0 else None
@@ -141,7 +145,9 @@ class Validator:
                     raise ValidationError(error_msg)
             else:
                 try:
-                    value = await rule.invoke(field_name, value, spec.base_type, auto_fix=auto_fix)
+                    value = await rule.invoke(
+                        field_name, value, spec.base_type, auto_fix=auto_fix
+                    )
                 except Exception as e:
                     self.log_validation_error(field_name, value, str(e))
                     raise
@@ -171,14 +177,20 @@ class Validator:
 
         return value
 
-    async def validate_operable(
+    async def validate(
         self,
         data: dict[str, Any],
         operable: Operable,
         capabilities: set[str] | None = None,
         auto_fix: bool = True,
         strict: bool = True,
+        structure: type[BaseModel] | None = None,
     ) -> dict[str, Any]:
+        if not_sentinel(capabilities, {"none"}) and not capabilities.issubset(
+            operable.allowed()
+        ):
+            raise ValidationError("Capabilities exceed operable's allowed set")
+
         capabilities = capabilities or operable.allowed()
         validated: dict[str, Any] = {}
 
@@ -195,4 +207,7 @@ class Validator:
                 spec, value, auto_fix=auto_fix, strict=strict
             )
 
+        if structure is not None:
+            validated = operable.validate_instance(structure, validated)
+
         return validated

krons/work/worker.py

@@ -0,0 +1,266 @@
+# Copyright (c) 2025 - 2026, HaiyangLi <quantocean.li at gmail dot com>
+# SPDX-License-Identifier: Apache-2.0
+
+"""Worker - Declarative workflow definition via decorated methods.
+
+A Worker defines workflows through:
+- @work: Typed operations with assignment DSL (inputs -> outputs)
+- @worklink: Conditional edges between work methods
+
+Example:
+    class FileCoder(Worker):
+        @work(assignment="instruction, context -> code", capacity=2)
+        async def write_code(self, form_id, **kwargs):
+            result = await llm.chat(**kwargs)
+            return form_id, result.code
+
+        @worklink(from_="write_code", to_="execute_code")
+        async def write_to_execute(self, from_result):
+            form_id, code = from_result
+            return {"form_id": form_id, "code": code}
+
+    engine = WorkerEngine(worker=FileCoder())
+    await engine.add_task(form=my_form, task_function="write_code")
+    await engine.execute()
+"""
+
+from __future__ import annotations
+
+import functools
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Awaitable, Callable
+from uuid import UUID
+
+if TYPE_CHECKING:
+    from .form import Form
+
+__all__ = (
+    "Worker",
+    "WorkConfig",
+    "WorkLink",
+    "work",
+    "worklink",
+)
+
+
+@dataclass
+class WorkConfig:
+    """Configuration for a @work decorated method.
+
+    Attributes:
+        assignment: DSL string 'inputs -> outputs' for typed I/O
+        form_param_key: Parameter name that receives form ID
+        capacity: Max concurrent executions (rate limiting)
+        refresh_time: Seconds between capacity resets
+        timeout: Max execution time in seconds
+    """
+
+    assignment: str = ""
+    form_param_key: str = ""
+    capacity: int = 1
+    refresh_time: float = 0.1
+    timeout: float | None = None
+
+
+@dataclass
+class WorkLink:
+    """Edge definition between work methods.
+
+    Attributes:
+        from_: Source method name
+        to_: Target method name
+        handler_name: Name of the handler method on the Worker
+    """
+
+    from_: str
+    to_: str
+    handler_name: str
+
+
+class Worker:
+    """Base class for declarative workflow definition.
+
+    Subclass and decorate methods with @work and @worklink to define workflows.
+    Worker maintains form storage and tracks work method metadata.
+
+    Attributes:
+        name: Worker name (default: class name)
+        forms: Dict mapping form IDs to Form instances
+        _work_methods: Registry of @work decorated methods
+        _work_links: Registry of @worklink edges
+        _stopped: Stop flag for execution
+
+    Example:
+        class MyCoder(Worker):
+            name = "coder"
+
+            @work(assignment="task -> plan", capacity=2)
+            async def plan(self, task_name, **kwargs):
+                ...
+                return task_name
+
+            @work(assignment="plan -> code", form_param_key="task_name")
+            async def implement(self, task_name, **kwargs):
+                ...
+
+            @worklink(from_="plan", to_="implement")
+            async def plan_to_implement(self, from_result):
+                return {"task_name": from_result}
+    """
+
+    name: str = "worker"
+
+    def __init__(self) -> None:
+        """Initialize worker state."""
+        # Form storage: form_id -> Form
+        self.forms: dict[str | UUID, Form] = {}
+
+        # Collect @work methods from class
+        self._work_methods: dict[str, tuple[Callable, WorkConfig]] = {}
+        self._work_links: list[WorkLink] = []
+        self._stopped = False
+
+        self._collect_work_metadata()
+
+    def _collect_work_metadata(self) -> None:
+        """Scan class for @work and @worklink decorated methods."""
+        for name in dir(self):
+            if name.startswith("_"):
+                continue
+
+            attr = getattr(self, name, None)
+            if attr is None:
+                continue
+
+            # Check for @work decorator
+            if hasattr(attr, "_work_config"):
+                config: WorkConfig = attr._work_config
+                self._work_methods[name] = (attr, config)
+
+            # Check for @worklink decorator
+            if hasattr(attr, "_worklink_from") and hasattr(attr, "_worklink_to"):
+                link = WorkLink(
+                    from_=attr._worklink_from,
+                    to_=attr._worklink_to,
+                    handler_name=name,
+                )
+                self._work_links.append(link)
+
+    def get_links_from(self, method_name: str) -> list[WorkLink]:
+        """Get all outgoing links from a method."""
+        return [link for link in self._work_links if link.from_ == method_name]
+
+    def get_links_to(self, method_name: str) -> list[WorkLink]:
+        """Get all incoming links to a method."""
+        return [link for link in self._work_links if link.to_ == method_name]
+
+    async def stop(self) -> None:
+        """Signal worker to stop processing."""
+        self._stopped = True
+
+    async def start(self) -> None:
+        """Clear stop flag to allow processing."""
+        self._stopped = False
+
+    def is_stopped(self) -> bool:
+        """Check if worker is stopped."""
+        return self._stopped
+
+    def __repr__(self) -> str:
+        methods = list(self._work_methods.keys())
+        links = len(self._work_links)
+        forms = len(self.forms)
+        return f"{self.__class__.__name__}(methods={methods}, links={links}, forms={forms})"
+
+
+def work(
+    assignment: str = "",
+    *,
+    form_param_key: str = "",
+    capacity: int = 1,
+    refresh_time: float = 0.1,
+    timeout: float | None = None,
+) -> Callable[[Callable[..., Awaitable]], Callable[..., Awaitable]]:
+    """Decorator for typed work methods.
+
+    Args:
+        assignment: DSL string 'inputs -> outputs' defining typed I/O.
+            Used for form field binding when form_param_key is set.
+        form_param_key: Parameter name that receives form ID.
+            If set, the engine will bind form fields to kwargs.
+        capacity: Max concurrent executions (for rate limiting).
+        refresh_time: Seconds between capacity resets.
+        timeout: Max execution time in seconds.
+
+    Returns:
+        Decorator that attaches WorkConfig to the method.
+
+    Example:
+        @work(assignment="context, instruction -> code", form_param_key="form_id")
+        async def write_code(self, form_id, **kwargs):
+            # kwargs contains context, instruction from form
+            result = await llm.chat(**kwargs)
+            return form_id, result.code
+    """
+
+    def decorator(func: Callable[..., Awaitable]) -> Callable[..., Awaitable]:
+        config = WorkConfig(
+            assignment=assignment,
+            form_param_key=form_param_key,
+            capacity=capacity,
+            refresh_time=refresh_time,
+            timeout=timeout,
+        )
+
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            return await func(*args, **kwargs)
+
+        wrapper._work_config = config  # type: ignore[attr-defined]
+        return wrapper
+
+    return decorator
+
+
+def worklink(
+    from_: str,
+    to_: str,
+) -> Callable[[Callable[..., Awaitable]], Callable[..., Awaitable]]:
+    """Decorator for conditional edges between work methods.
+
+    The decorated function receives the result from the 'from_' method
+    and returns kwargs dict for the 'to_' method. Return None to skip
+    the edge (conditional routing).
+
+    Args:
+        from_: Source method name
+        to_: Target method name
+
+    Returns:
+        Decorator that attaches WorkLink info to the method.
+
+    Example:
+        @worklink(from_="write_code", to_="execute_code")
+        async def write_to_execute(self, from_result):
+            form_id, code = from_result
+            return {"form_id": form_id, "code": code}
+
+        @worklink(from_="execute_code", to_="debug_code")
+        async def execute_to_debug(self, from_result):
+            form_id, error = from_result
+            if error is not None:  # Conditional edge
+                return {"form_id": form_id, "error": error}
+            # Return None = edge not taken
+    """
+
+    def decorator(func: Callable[..., Awaitable]) -> Callable[..., Awaitable]:
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            return await func(*args, **kwargs)
+
+        # Store link info - handler_name will be set during _collect_work_metadata
+        wrapper._worklink_from = from_  # type: ignore[attr-defined]
+        wrapper._worklink_to = to_  # type: ignore[attr-defined]
+        return wrapper
+
+    return decorator

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: krons
-Version: 0.1.1
+Version: 0.2.1
 Summary: Spec-based composable framework for building type-safe systems
 Project-URL: Homepage, https://github.com/khive-ai/krons
 Project-URL: Repository, https://github.com/khive-ai/krons
@@ -22,7 +22,21 @@ Requires-Dist: anyio>=4.10.0
 Requires-Dist: httpx>=0.26.0
 Requires-Dist: orjson>=3.10.0
 Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rapidfuzz>=3.10.0
+Provides-Extra: agent
+Requires-Dist: fastmcp>=2.14.4; extra == 'agent'
+Requires-Dist: tiktoken>=0.11.0; extra == 'agent'
+Provides-Extra: all
+Requires-Dist: fastmcp>=2.14.4; extra == 'all'
+Requires-Dist: rich>=13.0; extra == 'all'
+Requires-Dist: tiktoken>=0.11.0; extra == 'all'
+Provides-Extra: display
+Requires-Dist: rich>=13.0; extra == 'display'
+Provides-Extra: fastmcp
+Requires-Dist: fastmcp>=2.14.4; extra == 'fastmcp'
+Provides-Extra: tiktoken
+Requires-Dist: tiktoken>=0.11.0; extra == 'tiktoken'
 Description-Content-Type: text/markdown
 
 # krons

krons-0.2.1.dist-info/RECORD

@@ -0,0 +1,151 @@
+krons/__init__.py,sha256=4q7g_NShAZ3SXLVTZ4H8vFSCXpps-3tjCs7qg6WkQPI,1359
+krons/errors.py,sha256=nRWkWZmokOlp3hquC2dBe-gowdVIHllENiD0KxU3m8U,4051
+krons/protocols.py,sha256=xYJUHdXbFHYtjy3rcEt8ttIngzigEve7tYa-8G35v7k,15333
+krons/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+krons/agent/__init__.py,sha256=7AfP-1BHYosM5MiqcSOpoGF0y-bQ2OKN8oQePR2o98Y,4581
+krons/agent/tool.py,sha256=JDlj_QCMw6ILKu2NkKLOoywiIlIIQwVfS-A_HT88OTg,8573
+krons/agent/mcps/__init__.py,sha256=B3RYDI0XaDaECpgxqFp5bBIdCFRGPyzbCDpQeljY0P0,447
+krons/agent/mcps/loader.py,sha256=SAw3ZLvBYHfT1bklLI7i15mnqwAA_aZtnJRR9WEfKl4,10554
+krons/agent/mcps/wrapper.py,sha256=tW4aXzMMBqh4BtcuEaLxYqLxttGRJ06UQSjWmqdsGfI,28169
+krons/agent/message/__init__.py,sha256=vumj0lHyraEoshw0tx8yWt5fyUUuAC3qVBiSLQuq-9A,499
+krons/agent/message/action.py,sha256=ynONthCd78gWzl3dbQughJOGd-Iys6lbOzzYwuLXGWU,2047
+krons/agent/message/assistant.py,sha256=V75490V9mQLKbBkH9cYAmnva2-Q3hwCAj_4flLUCvOE,1459
+krons/agent/message/common.py,sha256=j9rpVoZhH6FV9JLVv6K-IgRJqPGnT5Vcw80UsEWv5ME,1282
+krons/agent/message/instruction.py,sha256=jouxli_yDwRcLJhXs8f9cR0MdreW3pNRDIw2ha7K4uE,4793
+krons/agent/message/prepare_msg.py,sha256=85XB-S2qxzXAUxn0cu46LNbWq0JL6w1IO1soJ3ci0Y4,7017
+krons/agent/message/role.py,sha256=wKY5gIov4yHuvHiXEGFJ8YIaDR2YcmyH83JnDLgnFtI,1397
+krons/agent/message/system.py,sha256=vCwFrYtM8K-5bVvl-mo0xW-Q_1AWqIAOgwDnNQ41DeA,1884
+krons/agent/operations/__init__.py,sha256=UqKGE99xyYBGHnEHPVLq8Bf7dvs195gAnpMH3zpjNNA,2095
+krons/agent/operations/act.py,sha256=WeUiVMcYOQN2EYLEvQU17HcqoQkcWzuqIgJjGP4AWXM,3606
+krons/agent/operations/generate.py,sha256=oNXAwUKw3rcPlGkgq8zhggnNJPVcAzIIUhYIca23Ro0,5447
+krons/agent/operations/llm_reparse.py,sha256=kF_KglZu_R4RVTpl-1lheeHGfvsK1bvAJidDdpW1iEA,2696
+krons/agent/operations/operate.py,sha256=zOIPRoLYV0sXeSTmCvuD5mlwArimP456a7GEpxljjQ8,8966
+krons/agent/operations/parse.py,sha256=HN7gnRm5_6gbabah3enaL280FVywQqIK5N6oOZG8NGQ,8261
+krons/agent/operations/react.py,sha256=f5_5IVf8oi2TD8QXT53DefTxd1zO0nMmJ07SrL_28NQ,9468
+krons/agent/operations/specs.py,sha256=UzH3A8VivQkUZdjDq78T_pmBQlY-BJafOVAKvpS0go8,7407
+krons/agent/operations/structure.py,sha256=8HN5_dA4sYZFUbVPffEGmcamm9VUxFveAko59sgWydI,5250
+krons/agent/operations/utils.py,sha256=goot2IAmrxTOoJa1kn2kfvv03i8mb02ifOKfBJMv_Qw,2335
+krons/agent/providers/__init__.py,sha256=XJtszdh8f5sfAR0eQipKplBSLdKwtL0F7uQPmah8g6s,555
+krons/agent/providers/anthropic_messages.py,sha256=x0oBKQa-T3zu8TyZ50Rm1fvgkY8ukzvAZJc1HVugBh0,4388
+krons/agent/providers/claude_code.py,sha256=nTKJkK1gGUdCgXpzRXiGtC840a5qm0tKBeakqlPQ9Kw,9881
+krons/agent/providers/gemini.py,sha256=TCJkk9iSnnkPdDuTlAB5yOphNYUPkPGKVYkrja9zcuI,9059
+krons/agent/providers/match.py,sha256=3kiW-hyfnF6UgBYD7LG4KFhFKXbWpDdtDQ71-9t5wIQ,2251
+krons/agent/providers/oai_chat.py,sha256=-97XBJ6WQT9OsjKSrV5s3or-WhBfUjDHomGiBYjCeVY,5463
+krons/agent/third_party/__init__.py,sha256=gR454Rk5b1Bv3QibE-822UcoSWhpLCLtJae028QGtN4,110
+krons/agent/third_party/anthropic_models.py,sha256=rd2Skh_Xx1S2G1JXi2YFb1j6SHm62e7brNBq9CZPAgI,3968
+krons/agent/third_party/claude_code.py,sha256=NBYMsdPheb0PqGgTO2_aUAR2XoGDsPUwsB7Nd9PjipA,23758
+krons/agent/third_party/gemini_models.py,sha256=2dag2WbSTKLBd8t0F7t_TXCcl7aqsTFgDI6XLkhsZwM,17416
+krons/agent/third_party/openai_models.py,sha256=L-GkJ-bBW5zwPbgCWEYHMNqRiZfFTAUJE96AVZoDAkQ,8040
+krons/core/__init__.py,sha256=HG0wBaNCbH3xGDRNX3657g-hZo4Isu2MKaXeUXmXqa0,3496
+krons/core/base/__init__.py,sha256=Edl_HH2F1l0SMHMzuEPU_IFjkigRR1vtqVXcPm-mr1o,3614
+krons/core/base/broadcaster.py,sha256=Es__WfL-j2h5NS6aU18fgaFkZsJIL-zDe86Qvlea-io,4013
+krons/core/base/element.py,sha256=LqBbmPttXoDAFy56JzWhSJ4sBw_LW7hMGxZUog85N8g,7642
+krons/core/base/event.py,sha256=iZQ65Xg3a8eaCEl4Hca-pxPNtckhrHkydEqYyppbuo0,11524
+krons/core/base/eventbus.py,sha256=z45ORtGey5A1N9hdyEPOhlX1whaTTdqdk7g3XEDL-_8,3761
+krons/core/base/flow.py,sha256=eqsYm8QO7bD5Y9VYnlpHFWpaUCY0rCeKGrDrFUyBVA4,12364
+krons/core/base/graph.py,sha256=FiTMArxuz6At3oYPEoamES3FtBM-AM6QnA7EQ8G18mo,15972
+krons/core/base/node.py,sha256=0_-R6uNe6-LF3adQRZowSIICdy6ep3cQIQRdF0oosoQ,34699
+krons/core/base/pile.py,sha256=ZKvnX3BjMsrH989TLNZII1dDWv4yPhSRzLKXx2yzyKQ,21108
+krons/core/base/processor.py,sha256=GrdNZa5YD0tXle847ttnxuWe4Ego1MhULzWHmSz5RqQ,18768
+krons/core/base/progression.py,sha256=srcrmp_zALgg7II5TJsuMM9DdNJszgTxLxvES0WBOTE,9844
+krons/core/specs/__init__.py,sha256=AKFEXqLmJpW__Y6xorJ1Vbp7AZ46kIs0157STVFGVWk,500
+krons/core/specs/factory.py,sha256=TsRZIoWuz0sLYUGfQ_X5Gff2oBll-quk-kOnpX5_yB0,3362
+krons/core/specs/operable.py,sha256=zO15i56_UzTTuM3yg_-EMtQY1Equ_WBi3rUCoCKrYck,11067
+krons/core/specs/protocol.py,sha256=Se-Cow7de4hF4vkvw5qYj14c37JJ-4aJSDIvJHFyst8,4392
+krons/core/specs/spec.py,sha256=QaVWN3ZrX8l1x15xXtfpNGzSIV01X0H3jy9Mjv9vT8Y,18706
+krons/core/specs/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+krons/core/specs/adapters/_utils.py,sha256=ChWH-C2LRXaXiWM3n7P0DZ8Oci5dSDq59DIJtHx2h-g,1365
+krons/core/specs/adapters/dataclass_field.py,sha256=thhgC3iQsrkfMkKzB4XmDbwh4fpLYocdL0KvY_zxbzo,8802
+krons/core/specs/adapters/factory.py,sha256=_LoSMCtHNkK5kNL5LUDjHvJJ2BtDHAaW1gly5LpNPXQ,1572
+krons/core/specs/adapters/pydantic_adapter.py,sha256=UxnOtJdeIyJEPBBjSACWE-JVc0yWxHSepz5i2SZhS6A,10410
+krons/core/specs/adapters/sql_ddl.py,sha256=NTttvx16X926qeQNWxqdoLlToeiMwufpKEPWNdAXHg0,31377
+krons/core/specs/catalog/__init__.py,sha256=TwS7hvGxa4-2Usu5rKGlhmUS0hhBlRzVNFNKDE7q8eU,1231
+krons/core/specs/catalog/_audit.py,sha256=g-L4eSJw3H0hfejex5LwsnepaGyTUPrL8JbPU7lPycY,1260
+krons/core/specs/catalog/_common.py,sha256=ItOPWV1fEeaz6ss5XNZYUetp204saIs7s5Bl0Jt8AOQ,1207
+krons/core/specs/catalog/_content.py,sha256=pQAbgjoObZcAQLe8Wg-_sqQ8VYZUGsRQJnjuiCjH-p0,1972
+krons/core/specs/catalog/_enforcement.py,sha256=JlKF_qGc-Xk7E_ebvq6lQs19iRBAWk2TOe1Qm7XMf1k,2126
+krons/core/types/__init__.py,sha256=pJ6kuop7vSLZp5jMBs-CQ7CHRjvUuO8kHhpZ34KM85I,1049
+krons/core/types/_sentinel.py,sha256=QJGyRAYNkJ2ylw6dhxPHJNgmxqBdorBd-xx7pNrUykw,8855
+krons/core/types/base.py,sha256=Un3MrPGuyns9SgPczJ5vbQExemTO-9B2Eks87NDd--A,12330
+krons/core/types/db_types.py,sha256=3ZaAXJe4dartmF-IyKr59NVlL2EbGpx7AtVqqbrIXIk,8136
+krons/core/types/identity.py,sha256=Ccb5oJArC1PEzdzNPlLi_oK87uKx7BFevX9rvY9y-14,1949
+krons/resource/__init__.py,sha256=h83vOSa6zXXMRdfxch7yg7kGy6Pe_6c0wWANByATbZ8,2783
+krons/resource/backend.py,sha256=mW1kkAZrUwnBZeMOY_0I_egpTKpuNyIs5Mps4r2cOxk,10979
+krons/resource/endpoint.py,sha256=X_Yt5KLXKN5Wwc75MX0c5gPyE_Dlv16rIfm8CKd1xYE,22253
+krons/resource/hook.py,sha256=XQujjDwBZa2vCktP6Ey0QFfFFNEd6igc1qUR5-tfeQU,17115
+krons/resource/imodel.py,sha256=_BOfbLk5JNoKAnjf3k67E6O2Qef4fsKa1hprw1C4L1Q,18595
+krons/resource/registry.py,sha256=Vqe8uUtMMtxu4NgU5RUPFmpIxtKxdCfmVQQy1lhZMZo,3829
+krons/resource/utilities/__init__.py,sha256=-ycdoYgtXrliJwbtQGMHBRvZL0qX2xLzooL3RNV99x4,1013
+krons/resource/utilities/header_factory.py,sha256=WZCCZMh9EJVi8tnY7dJD07FcTOrrUMvecJmzy8P65Os,2992
+krons/resource/utilities/rate_limited_executor.py,sha256=xtvxTeHowoghb4WpY_9WNgqbFKHPBZKtKbaGyaTpTsk,9710
+krons/resource/utilities/rate_limiter.py,sha256=DdaqnxOnst43ZAxcC9kBnnFbUCAsR89KzA0XL5xGPtU,6003
+krons/resource/utilities/resilience.py,sha256=eOPSZ6m89IH_RCgaGLrFPQGTZtMBZOrs8G0sjSpfv40,14389
+krons/resource/utilities/token_calculator.py,sha256=gBQvkmqL4gnqFx5o-FtPeoLDPBFTdN0ZpFkaT71VVLk,6437
+krons/session/__init__.py,sha256=aCdCYe2HCLV8ujlBZHSqFr0nF8gj_PypI0BXoIU7ThU,1017
+krons/session/constraints.py,sha256=DvmLKyf5eYUX2nxCDcco1-uDipGjiIJwoUxWVtX2w84,2361
+krons/session/exchange.py,sha256=QChEqK5NFZJpHWxPrXd8LkGBCFg6LNONd1ZEy0MufpI,9165
+krons/session/message.py,sha256=mtZ-PYCCoyWLy7BSB5TL5a0hIt0aQX2zdckOCIl6NZ0,2007
+krons/session/registry.py,sha256=13pPKmDZJaj9q27oUOdtH6-jrHP_HDFF8lCdcNF--EE,999
+krons/session/session.py,sha256=bBK6rYPmYu5YcmU-oWoJL9pU8pdzr9Y4Z5wcIIiuirw,13221
+krons/utils/__init__.py,sha256=V-jTKULdofjJXxcEHygefKV_v6XE4H3poCdxPLjvf_4,1718
+krons/utils/_function_arg_parser.py,sha256=H5JVLBVY8W9ZNkZ4_YVtVVY1rFYvnIRhSrAhKEdj2Qc,3479
+krons/utils/_hash.py,sha256=W2Ma9v8-INPaGkur7GTtbF8KwuXSJNSwk8DCNPRvx8Q,6859
+krons/utils/_json_dump.py,sha256=rpBmr0NCmIKRdmpgn1nSWIHI3FTsGYsQjOa3YTxCi3M,12482
+krons/utils/_lazy_init.py,sha256=bCx_W3dfzirB5KnAt6_jmbnwOk2xbU7-kgOhMQqzW70,1806
+krons/utils/_pythonic_function_call.py,sha256=PAqnb-PNzVBvIrXh5-680mj7BlRiUziiHkjxELe0q78,8388
+krons/utils/_to_list.py,sha256=RuiUWkoxHjD-2pqbbumar69AADCKYoGqSKL5FPu6LdM,6114
+krons/utils/_to_num.py,sha256=NyyIL9Az1EaW6QFh9R7AeJdaUPoSRBNVBX9yj78wpok,3102
+krons/utils/_utils.py,sha256=g1LAKX9-AwREb-XzXaAaHMCeSBlhtfWMu7GK1XDDAzg,11145
+krons/utils/display.py,sha256=haAzWny-Ez1H6LphxNsEaYyFY3uctj2xbvgR8ZAUfJg,7312
+krons/utils/concurrency/__init__.py,sha256=1HD-aY4Hevde0Hm0-VYa0eheT5OiwhlnDJtofIuV9wk,6754
+krons/utils/concurrency/_async_call.py,sha256=cb7iXphip1zKPsim6whf-nCvdopq1spQNqx7sWxiejo,10233
+krons/utils/concurrency/_cancel.py,sha256=b9f6yT8gObS6Y3EWKoGzNfYxqM1ZrN_8ctfyIjT1m1U,3326
+krons/utils/concurrency/_errors.py,sha256=8bG72f71OxWYTdQ9AmUnI20UjEz0UYsWjQayter4CNI,2603
+krons/utils/concurrency/_patterns.py,sha256=Xl31p63JkU370N9bA05uu60GDXrgwm1DHCjEq2U8-oo,11540
+krons/utils/concurrency/_primitives.py,sha256=D1Rl1hujXXPdL4Mw6eW5EN8utM3bh8vmmFtXmuvsDw0,9024
+krons/utils/concurrency/_priority_queue.py,sha256=wGi6ESS6AIZ0QNRBQR5UwcSQI5GhKjATBC_aEw6c0aQ,4342
+krons/utils/concurrency/_resource_tracker.py,sha256=aBLTpSaUsUCtRLEHzIaBYu0NOuACFbIt3JGACo7K-0E,3179
+krons/utils/concurrency/_run_async.py,sha256=A_vuPi9-wWRr3oXiAMnv3l7MV2B76jkBXoVztX_Vcgo,1940
+krons/utils/concurrency/_task.py,sha256=4ivkiUUbutheoYZ-G8-mTfHX4YgWguGIy1v5hSU871w,2528
+krons/utils/concurrency/_utils.py,sha256=CyH_z4prYFeCFgwk4Pc3q0m5NRzDB2TP-G2oxdM_-C0,2136
+krons/utils/fuzzy/__init__.py,sha256=aztwfirLUDf8i-NukKhER1Pp0cZBcgtD92G1n_I4cq4,502
+krons/utils/fuzzy/_extract_json.py,sha256=6Y-QEfXrTBdaNmlbMfVm6xJPBKI0RBbr_t0VYGE7nMo,2922
+krons/utils/fuzzy/_fuzzy_json.py,sha256=hV6v9YkQpGxwOnhpLM6jkrG5fZKYluMTxgdqsk5sTew,9151
+krons/utils/fuzzy/_fuzzy_match.py,sha256=6uDoKwqEnms_NMT2T4GB0LC9hhyeuEOOCAu39vO1COA,4953
+krons/utils/fuzzy/_string_similarity.py,sha256=4G0lgBek8zgRcgKi6V0npwRKdkdmQ_wfayr3eCLZmEY,6155
+krons/utils/fuzzy/_to_dict.py,sha256=cS-7NPKIePFlsGSRExCnBRPn7qHIHmcqR1tQBl5tRjE,12941
+krons/utils/schemas/__init__.py,sha256=Si_UjyztaT0Shi85ISs6ESpTLohk9yLSYdy2x4-82Yo,701
+krons/utils/schemas/_breakdown_pydantic_annotation.py,sha256=wfgrCnpPP74UpDyeOxox4uZgVEJZU7UBiBwZHL0ocT0,4075
+krons/utils/schemas/_formatter.py,sha256=DSxYkJDNncno1T_FSEAa1B3BrONfR_swFbd1AOtrtcg,2682
+krons/utils/schemas/_minimal_yaml.py,sha256=IhbPmInpLpuQpPcTtW1noLoVi4JLFBUL2aRaeLvoB2Q,4652
+krons/utils/schemas/_typescript.py,sha256=XrbUQBbWxhzwuAXS6w54vwBno9Bg3dPpqZFRPPQIKBg,5240
+krons/utils/sql/__init__.py,sha256=yNjm9Dr-ZjrZSD3Lext7fPR80qX5svGT2PnXqlb5qXs,264
+krons/utils/sql/_sql_validation.py,sha256=smxNU3HjPhQuRK5ehG9Fl4DeljKK9tqUQIvRUopgvc8,4229
+krons/utils/validators/__init__.py,sha256=qmCYoL6fQL1O6-GcfcUARii_fjXYNed6rKZWOp3skj8,87
+krons/utils/validators/_validate_image_url.py,sha256=WAffNY3WpPFe_lqFLHumJS0_hm92NwIOmDOK1GR61ew,1858
+krons/work/__init__.py,sha256=8C3ypK0FInl6YSos-F_MkuDhu_Vb_uN8HEegFq8pvwc,3541
+krons/work/engine.py,sha256=ZHZzzRqedpLEkcX5eQ6zZQMXYfgmLMRN2JOwkLajND4,10924
+krons/work/form.py,sha256=QwXYclRR-MxneNLF0CKbMvk_K-piZBmMXyCd_Y3XOeE,7264
+krons/work/report.py,sha256=wxjMGnUc8b2Jn26l0t0k0cWetZFDyvyqBz0ldae4BD0,9027
+krons/work/worker.py,sha256=hK7t5ztG_5wKPScwjtsctP4-ob6bHw9WKRJTw_gw_Fc,8494
+krons/work/operations/__init__.py,sha256=vU-jy0Xy25W4vj98wV3sk3c8x6hKc5sf4nW3U_FQGdY,999
+krons/work/operations/builder.py,sha256=_OGvooSl8s3Pmx8En15SX4XxQ12wF2ZszwVb5Hqzdpc,7779
+krons/work/operations/context.py,sha256=rMcKR8kJkVk-7X1nW8LGoSjW4Eaj66LM46El8wwURmU,5323
+krons/work/operations/flow.py,sha256=RL_GIIKlIURsbLp4-xRA7bJukeCVx0b_garodGd1NhI,14803
+krons/work/operations/node.py,sha256=3NbM2o22oMpFXy6I7osGKIOIzJ69r5Bby99LHrNifr4,3374
+krons/work/operations/registry.py,sha256=cVQA36_jgr9bxRiCsVM_plGPrTVr08vci1aio3olZyM,3483
+krons/work/rules/__init__.py,sha256=oxBsYI3vxAp85G1pMIpQM_84HUYwHbB1lxa9t4uB6YY,1187
+krons/work/rules/registry.py,sha256=JFdwcIVtysntj6wMY3bO7-hqwNU7QIoIbEQuhsy5O4U,4742
+krons/work/rules/rule.py,sha256=uKjjiBwgzryiAOyTUI2YiqSyFg3QluvNRJ09EwtrbK8,9471
+krons/work/rules/validator.py,sha256=CbbdueLI_6JvbbG0yvcljyhjO3HhpF4mlfBTzdhP4jA,7240
+krons/work/rules/common/__init__.py,sha256=U0rEcHOxLftR4-xJNuuXMSDYFAvbs0KzwV3GhlZcUrY,1026
+krons/work/rules/common/boolean.py,sha256=zX9i-oggejwFA0QYQSj1rDU1epqqpUe-ARFS4aol3qY,2644
+krons/work/rules/common/choice.py,sha256=QT0qMDvoPHTGjYeybRkZX8oolIy8Y3iQIqehoV28cco,3264
+krons/work/rules/common/mapping.py,sha256=Loq54MNEtwpnHN0aypTjFOqwoOKLEysddHh-JESedvs,3824
+krons/work/rules/common/model.py,sha256=xmM6coEThf_fgIiqJiyDgvdfib_FpVeY6LgWPVcWSwU,3026
+krons/work/rules/common/number.py,sha256=cCukgMSpQu5RdYK5rXAUyop9qXgDRfLCioMvE8kIzHg,3162
+krons/work/rules/common/string.py,sha256=zHp_OLh0FL4PvmSlyDTEzb2I97-DBSEyI2zcMo10voA,5090
+krons-0.2.1.dist-info/METADATA,sha256=O9pmDvpEfTq1HydsJRGUwTA6IPn_veB57Em2udfOO9g,2527
+krons-0.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+krons-0.2.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+krons-0.2.1.dist-info/RECORD,,