krons 0.2.0__tar.gz → 0.2.1__tar.gz

{krons-0.2.0 → krons-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: krons
-Version: 0.2.0
+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

{krons-0.2.0 → krons-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "krons"
-version = "0.2.0"
+version = "0.2.1"
 description = "Spec-based composable framework for building type-safe systems"
 readme = "README.md"
 requires-python = ">=3.11"

{krons-0.2.0 → krons-0.2.1}/src/krons/work/__init__.py

@@ -32,7 +32,6 @@ Two complementary patterns at different abstraction levels:
             return await self.llm.chat(**kwargs)
 
 Core concepts:
-- Phrase: Typed operation signature (inputs -> outputs)
 - Form: Data binding + scheduling (stateful artifact)
 - Report: Multi-step workflow declaration (stateful artifact)
 - Worker: Execution capability (stateless station)
@@ -53,11 +52,6 @@ _LAZY_IMPORTS: dict[str, tuple[str, str]] = {
     "ParsedAssignment": ("krons.work.form", "ParsedAssignment"),
     "parse_assignment": ("krons.work.form", "parse_assignment"),
     "parse_full_assignment": ("krons.work.form", "parse_full_assignment"),
-    # phrase
-    "CrudOperation": ("krons.work.phrase", "CrudOperation"),
-    "CrudPattern": ("krons.work.phrase", "CrudPattern"),
-    "Phrase": ("krons.work.phrase", "Phrase"),
-    "phrase": ("krons.work.phrase", "phrase"),
     # report
     "Report": ("krons.work.report", "Report"),
     # worker
@@ -102,16 +96,12 @@ if TYPE_CHECKING:
         parse_assignment,
         parse_full_assignment,
     )
-    from krons.work.phrase import CrudOperation, CrudPattern, Phrase, phrase
     from krons.work.report import Report
     from krons.work.worker import WorkConfig, Worker, WorkLink, work, worklink
 
 __all__ = (
-    "CrudOperation",
-    "CrudPattern",
     "Form",
     "ParsedAssignment",
-    "Phrase",
     "Report",
     "WorkConfig",
     "WorkLink",
@@ -120,7 +110,6 @@ __all__ = (
     "WorkerTask",
     "parse_assignment",
     "parse_full_assignment",
-    "phrase",
     "work",
     "worklink",
 )

{krons-0.2.0 → krons-0.2.1}/src/krons/work/form.py

@@ -6,23 +6,19 @@
 A Form represents an instantiated work unit with:
 - Data binding (input values)
 - Execution state tracking (filled, workable)
-- Optional Phrase reference for typed I/O
 
-Forms are the stateful layer between Phrase (definition) and Operation (execution).
+Forms are the stateful scheduling layer for Operations.
 """
 
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from pydantic import Field
 
 from krons.core import Element
 
-if TYPE_CHECKING:
-    from .phrase import Phrase
-
 __all__ = ("Form", "ParsedAssignment", "parse_assignment", "parse_full_assignment")
 
 
@@ -123,9 +119,7 @@ def parse_full_assignment(assignment: str) -> ParsedAssignment:
 class Form(Element):
     """Data binding container for work units.
 
-    A Form binds input data and tracks execution state. It can be created:
-    1. From a Phrase (typed I/O)
-    2. From an assignment string (dynamic fields)
+    A Form binds input data and tracks execution state.
 
     Assignment DSL supports full format:
         "branch: inputs -> outputs | resource"
@@ -144,7 +138,6 @@ class Form(Element):
         available_data: Current data values
         output: Execution result
         filled: Whether form has been executed
-        phrase: Optional Phrase reference for typed execution
     """
 
     assignment: str = Field(
@@ -165,9 +158,6 @@ class Form(Element):
     output: Any = Field(default=None)
     filled: bool = Field(default=False)
 
-    # Optional phrase reference (set via from_phrase())
-    _phrase: "Phrase | None" = None
-
     def model_post_init(self, _: Any) -> None:
         """Parse assignment to derive fields if not already set."""
         if self.assignment and not self.input_fields and not self.output_fields:
@@ -179,35 +169,6 @@ class Form(Element):
             if parsed.resource and self.resource is None:
                 self.resource = parsed.resource
 
-    @classmethod
-    def from_phrase(
-        cls,
-        phrase: "Phrase",
-        **initial_data: Any,
-    ) -> "Form":
-        """Create Form from a Phrase with optional initial data.
-
-        Args:
-            phrase: Phrase defining typed I/O
-            **initial_data: Initial input values
-
-        Returns:
-            Form bound to the phrase
-        """
-        form = cls(
-            assignment=f"{', '.join(phrase.inputs)} -> {', '.join(phrase.outputs)}",
-            input_fields=list(phrase.inputs),
-            output_fields=list(phrase.outputs),
-            available_data=dict(initial_data),
-        )
-        form._phrase = phrase
-        return form
-
-    @property
-    def phrase(self) -> "Phrase | None":
-        """Get bound phrase if any."""
-        return self._phrase
-
     def is_workable(self) -> bool:
         """Check if form is ready for execution.
 
@@ -274,32 +235,8 @@ class Form(Element):
                 result[field] = self.available_data[field]
         return result
 
-    async def execute(self, ctx: Any = None) -> Any:
-        """Execute the form if it has a bound phrase.
-
-        Args:
-            ctx: Execution context
-
-        Returns:
-            Execution result
-
-        Raises:
-            RuntimeError: If no phrase bound or form not workable
-        """
-        if self._phrase is None:
-            raise RuntimeError("Form has no bound phrase - cannot execute")
-
-        if not self.is_workable():
-            missing = [f for f in self.input_fields if f not in self.available_data]
-            raise RuntimeError(f"Form not workable - missing inputs: {missing}")
-
-        result = await self._phrase(self.get_inputs(), ctx)
-        self.set_output(result)
-        return result
-
     def __repr__(self) -> str:
         status = (
             "filled" if self.filled else ("ready" if self.is_workable() else "pending")
         )
-        phrase_info = f", phrase={self._phrase.name}" if self._phrase else ""
-        return f"Form('{self.assignment}', {status}{phrase_info})"
+        return f"Form('{self.assignment}', {status})"

{krons-0.2.0 → krons-0.2.1}/tests/work/test_form.py

@@ -9,9 +9,7 @@ from uuid import UUID, uuid4
 
 import pytest
 
-from krons.core.specs import Operable, Spec
 from krons.work.form import Form, parse_assignment
-from krons.work.phrase import Phrase
 
 # =============================================================================
 # Tests: parse_assignment
@@ -152,85 +150,6 @@ class TestFormCreation:
         assert form.output is None
 
 
-# =============================================================================
-# Tests: Form.from_phrase
-# =============================================================================
-
-
-class TestFormFromPhrase:
-    """Tests for Form.from_phrase factory."""
-
-    def test_from_phrase_basic(self):
-        """Form.from_phrase should create form bound to phrase."""
-        spec1 = Spec(str, name="name")
-        spec2 = Spec(int, name="count")
-        op = Operable([spec1, spec2])
-
-        async def handler(options, ctx):
-            return {"count": len(options.name)}
-
-        p = Phrase(
-            name="count_chars",
-            operable=op,
-            inputs={"name"},
-            outputs={"count"},
-            handler=handler,
-        )
-
-        form = Form.from_phrase(p)
-
-        assert form.phrase is p
-        assert "name" in form.input_fields
-        assert "count" in form.output_fields
-        assert "name -> count" in form.assignment or "name" in form.assignment
-
-    def test_from_phrase_with_initial_data(self):
-        """Form.from_phrase should accept initial data."""
-        spec1 = Spec(str, name="name")
-        spec2 = Spec(int, name="count")
-        op = Operable([spec1, spec2])
-
-        async def handler(options, ctx):
-            return {"count": len(options.name)}
-
-        p = Phrase(
-            name="count_chars",
-            operable=op,
-            inputs={"name"},
-            outputs={"count"},
-            handler=handler,
-        )
-
-        form = Form.from_phrase(p, name="hello")
-
-        assert form.available_data["name"] == "hello"
-
-    def test_from_phrase_phrase_property(self):
-        """Form.phrase property should return bound phrase."""
-        spec1 = Spec(str, name="name")
-        spec2 = Spec(int, name="count")
-        op = Operable([spec1, spec2])
-
-        async def handler(options, ctx):
-            return {"count": 0}
-
-        p = Phrase(
-            name="test",
-            operable=op,
-            inputs={"name"},
-            outputs={"count"},
-            handler=handler,
-        )
-
-        form = Form.from_phrase(p)
-        assert form.phrase is p
-
-    def test_form_without_phrase(self):
-        """Form without phrase should have phrase=None."""
-        form = Form(assignment="a -> b")
-        assert form.phrase is None
-
-
 # =============================================================================
 # Tests: Form.is_workable
 # =============================================================================
@@ -468,70 +387,6 @@ class TestFormGetOutputData:
 # =============================================================================
 
 
-class TestFormExecute:
-    """Tests for Form.execute async execution."""
-
-    @pytest.mark.anyio
-    async def test_execute_with_phrase(self):
-        """execute should invoke bound phrase and set output."""
-        spec1 = Spec(str, name="name")
-        spec2 = Spec(int, name="length")
-        op = Operable([spec1, spec2])
-
-        async def handler(options, ctx):
-            return {"length": len(options.name)}
-
-        p = Phrase(
-            name="get_length",
-            operable=op,
-            inputs={"name"},
-            outputs={"length"},
-            handler=handler,
-        )
-
-        form = Form.from_phrase(p, name="hello")
-
-        result = await form.execute(ctx=None)
-
-        assert form.filled is True
-        assert form.available_data["length"] == 5
-        assert result.length == 5
-
-    @pytest.mark.anyio
-    async def test_execute_no_phrase_raises(self):
-        """execute without bound phrase should raise RuntimeError."""
-        form = Form(
-            assignment="a -> b",
-            available_data={"a": 1},
-        )
-
-        with pytest.raises(RuntimeError, match="no bound phrase"):
-            await form.execute(ctx=None)
-
-    @pytest.mark.anyio
-    async def test_execute_not_workable_raises(self):
-        """execute when not workable should raise RuntimeError."""
-        spec1 = Spec(str, name="name")
-        spec2 = Spec(int, name="length")
-        op = Operable([spec1, spec2])
-
-        async def handler(options, ctx):
-            return {"length": 0}
-
-        p = Phrase(
-            name="get_length",
-            operable=op,
-            inputs={"name"},
-            outputs={"length"},
-            handler=handler,
-        )
-
-        form = Form.from_phrase(p)  # No data provided
-
-        with pytest.raises(RuntimeError, match="not workable"):
-            await form.execute(ctx=None)
-
-
 # =============================================================================
 # Tests: Form.__repr__
 # =============================================================================
@@ -568,28 +423,6 @@ class TestFormRepr:
 
         assert "filled" in repr_str
 
-    def test_repr_with_phrase(self):
-        """repr should include phrase name when bound."""
-        spec1 = Spec(str, name="a")
-        spec2 = Spec(int, name="b")
-        op = Operable([spec1, spec2])
-
-        async def handler(options, ctx):
-            return {"b": 0}
-
-        p = Phrase(
-            name="test_phrase",
-            operable=op,
-            inputs={"a"},
-            outputs={"b"},
-            handler=handler,
-        )
-
-        form = Form.from_phrase(p)
-        repr_str = repr(form)
-
-        assert "test_phrase" in repr_str
-
 
 # =============================================================================
 # Tests: Form Element inheritance

{krons-0.2.0 → krons-0.2.1}/uv.lock

@@ -889,7 +889,7 @@ wheels = [
 
 [[package]]
 name = "krons"
-version = "0.2.0"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },