origin-lang 0.1.0__tar.gz

origin_lang-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: origin-lang
+Version: 0.1.0
+Summary: Every value is either in the interior or at a boundary. The runtime knows which.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/knoxvilledatabase/origin
+Keywords: ai,safety,boundary,inference,type-system
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10

origin_lang-0.1.0/origin_lang/__init__.py

@@ -0,0 +1,13 @@
+"""
+Origin: every value is either in the interior or at a boundary.
+
+    from origin_lang import Value, boundary
+
+This is the pure Python version. Runtime enforcement, same concept.
+For compile-time enforcement, see the Rust crate.
+"""
+
+from origin_lang.value import Value
+from origin_lang.boundary import boundary, BoundaryKind
+
+__all__ = ["Value", "boundary", "BoundaryKind"]

origin_lang-0.1.0/origin_lang/boundary.py

@@ -0,0 +1,41 @@
+"""
+The @boundary decorator: mark a class as a boundary kind.
+
+    @boundary
+    class LowConfidence:
+        confidence: float
+        threshold: float
+
+This turns the class into a frozen dataclass that can be used
+as the reason field in Value.boundary().
+"""
+
+from dataclasses import dataclass
+
+
+class BoundaryKind:
+    """Base class for boundary kinds. Optional — @boundary is simpler."""
+    pass
+
+
+def boundary(cls):
+    """Decorator that turns a class into a boundary kind.
+
+    Wraps it as a dataclass and marks it as a BoundaryKind.
+
+        @boundary
+        class LowConfidence:
+            confidence: float
+            threshold: float
+
+        Value.boundary(LowConfidence(confidence=0.61, threshold=0.85), last=diagnosis)
+    """
+    # Make it a dataclass if it isn't already
+    cls = dataclass(frozen=True)(cls)
+
+    # Register as a BoundaryKind
+    if BoundaryKind not in cls.__mro__:
+        # Can't modify __bases__ on a dataclass, so register it differently
+        cls._is_boundary_kind = True
+
+    return cls

origin_lang-0.1.0/origin_lang/value.py

@@ -0,0 +1,147 @@
+"""
+The core type. Interior or Boundary. One distinction. Every domain.
+
+Value<T, B> in Rust. Value[T, B] in Python. Same idea:
+- Interior(value): the value is in safe territory.
+- Boundary(reason, last): the value crossed the edge.
+  reason says which boundary. last says what the computation knew.
+
+The `last` field is what neither exceptions nor Result carry.
+It's always here. You can't drop it.
+"""
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Callable
+
+T = TypeVar("T")
+U = TypeVar("U")
+B = TypeVar("B")
+
+
+class Value(Generic[T, B]):
+    """A value that is either interior or at a boundary."""
+
+    __slots__ = ("_interior", "_reason", "_last", "_is_interior")
+
+    def __init__(self, *, _interior=None, _reason=None, _last=None, _is_interior=True):
+        self._interior = _interior
+        self._reason = _reason
+        self._last = _last
+        self._is_interior = _is_interior
+
+    @staticmethod
+    def interior(value: T) -> Value[T, B]:
+        """Construct an interior value."""
+        return Value(_interior=value, _is_interior=True)
+
+    @staticmethod
+    def boundary(reason: B, *, last: T) -> Value[T, B]:
+        """Construct a boundary value with a reason and last known value."""
+        if last is None:
+            raise ValueError(
+                "boundary() requires last= — the whole point is preserving "
+                "what the computation knew before it hit the boundary"
+            )
+        return Value(_reason=reason, _last=last, _is_interior=False)
+
+    @property
+    def is_interior(self) -> bool:
+        return self._is_interior
+
+    @property
+    def is_boundary(self) -> bool:
+        return not self._is_interior
+
+    def unwrap(self) -> T:
+        """Get the interior value, or raise if boundary.
+
+        In boundary-checked code, prefer match instead.
+        """
+        if self._is_interior:
+            return self._interior
+        raise BoundaryError(self._reason, self._last)
+
+    def or_default(self, fallback: T) -> T:
+        """Get the interior value, or return a fallback."""
+        if self._is_interior:
+            return self._interior
+        return fallback
+
+    def map(self, f: Callable[[T], U]) -> Value[U, B]:
+        """Map over the value. Boundaries propagate with mapped last."""
+        if self._is_interior:
+            return Value.interior(f(self._interior))
+        return Value.boundary(self._reason, last=f(self._last))
+
+    def __repr__(self):
+        if self._is_interior:
+            return f"Value.Interior({self._interior!r})"
+        return f"Value.Boundary({self._reason!r}, last={self._last!r})"
+
+    # -- Pattern matching support (Python 3.10+) --
+
+    class Interior:
+        """Match pattern for interior values.
+
+            case Value.Interior(diagnosis):
+                treat(diagnosis)
+        """
+        __match_args__ = ("value",)
+
+        def __init__(self, value):
+            self.value = value
+
+    class Boundary:
+        """Match pattern for boundary values.
+
+            case Value.Boundary(LowConfidence(confidence=c), last=diagnosis):
+                refer_to_specialist(diagnosis, c)
+        """
+        __match_args__ = ("reason", "last")
+
+        def __init__(self, reason, last):
+            self.reason = reason
+            self.last = last
+
+    # Enable generic subscript: Value[T, B]
+    def __class_getitem__(cls, params):
+        return cls
+
+
+def match(value: Value[T, B]):
+    """Unpack a Value for pattern matching.
+
+    With Python 3.10+ match/case:
+
+        match match(result):
+            case Value.Interior(diagnosis):
+                treat(diagnosis)
+            case Value.Boundary(LowConfidence(confidence=c), last=diagnosis):
+                refer_to_specialist(diagnosis, c)
+
+    Or with isinstance:
+
+        m = match(result)
+        if isinstance(m, Value.Interior):
+            treat(m.value)
+        elif isinstance(m, Value.Boundary):
+            handle(m.reason, m.last)
+    """
+    if value.is_interior:
+        return Value.Interior(value._interior)
+    return Value.Boundary(value._reason, value._last)
+
+
+class BoundaryError(Exception):
+    """Raised when unwrap() is called on a boundary value.
+
+    Carries the reason and the last known value, because even
+    in an exception, the information shouldn't be lost.
+    """
+
+    def __init__(self, reason, last):
+        self.reason = reason
+        self.last = last
+        super().__init__(
+            f"called unwrap() on a Boundary: {reason!r} (last={last!r})"
+        )

origin_lang-0.1.0/origin_lang.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: origin-lang
+Version: 0.1.0
+Summary: Every value is either in the interior or at a boundary. The runtime knows which.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/knoxvilledatabase/origin
+Keywords: ai,safety,boundary,inference,type-system
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10

origin_lang-0.1.0/origin_lang.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+pyproject.toml
+origin_lang/__init__.py
+origin_lang/boundary.py
+origin_lang/value.py
+origin_lang.egg-info/PKG-INFO
+origin_lang.egg-info/SOURCES.txt
+origin_lang.egg-info/dependency_links.txt
+origin_lang.egg-info/top_level.txt
+tests/test_value.py

origin_lang-0.1.0/origin_lang.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

origin_lang-0.1.0/origin_lang.egg-info/top_level.txt

@@ -0,0 +1 @@
+origin_lang

origin_lang-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "origin-lang"
+version = "0.1.0"
+description = "Every value is either in the interior or at a boundary. The runtime knows which."
+requires-python = ">=3.10"
+license = "MIT"
+keywords = ["ai", "safety", "boundary", "inference", "type-system"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+[project.urls]
+Homepage = "https://github.com/knoxvilledatabase/origin"

origin_lang-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

origin_lang-0.1.0/tests/test_value.py

@@ -0,0 +1,242 @@
+"""Tests for Origin's Python implementation."""
+
+import pytest
+from dataclasses import dataclass
+from origin_lang import Value, boundary
+from origin_lang.value import match, BoundaryError
+
+
+# -- Domain types --
+
+@dataclass
+class Diagnosis:
+    condition: str
+    icd_code: str
+    confidence: float
+
+
+@boundary
+class LowConfidence:
+    confidence: float
+    threshold: float
+
+
+@boundary
+class Hallucinated:
+    claim: str
+    evidence_score: float
+
+
+@boundary
+class OutOfDomain:
+    distance: float
+
+
+# -- Construction --
+
+class TestConstruction:
+    def test_interior(self):
+        v = Value.interior(42)
+        assert v.is_interior
+        assert not v.is_boundary
+
+    def test_boundary(self):
+        v = Value.boundary(LowConfidence(0.3, 0.85), last="partial result")
+        assert v.is_boundary
+        assert not v.is_interior
+
+    def test_boundary_requires_last(self):
+        with pytest.raises(ValueError, match="requires last"):
+            Value.boundary(LowConfidence(0.3, 0.85), last=None)
+
+
+# -- The point: last is always preserved --
+
+class TestLastPreserved:
+    def test_last_carries_diagnosis(self):
+        """The moment: 'I've never had this before. I always lost that value.'"""
+        diagnosis = Diagnosis("Pneumonia", "J18.9", 0.61)
+        v = Value.boundary(
+            LowConfidence(confidence=0.61, threshold=0.85),
+            last=diagnosis,
+        )
+
+        m = match(v)
+        assert isinstance(m, Value.Boundary)
+        assert m.last.condition == "Pneumonia"
+        assert m.last.confidence == 0.61
+        assert m.reason.confidence == 0.61
+
+    def test_last_carries_through_hallucination(self):
+        diagnosis = Diagnosis("Time travel syndrome", "Z99.99", 0.03)
+        v = Value.boundary(
+            Hallucinated(claim="Time travel syndrome", evidence_score=0.03),
+            last=diagnosis,
+        )
+
+        m = match(v)
+        assert isinstance(m, Value.Boundary)
+        assert m.last.condition == "Time travel syndrome"
+        assert m.reason.evidence_score == 0.03
+
+    def test_interior_has_value(self):
+        diagnosis = Diagnosis("ACS", "I21.9", 0.92)
+        v = Value.interior(diagnosis)
+
+        m = match(v)
+        assert isinstance(m, Value.Interior)
+        assert m.value.condition == "ACS"
+
+
+# -- Pattern matching (Python 3.10+) --
+
+class TestPatternMatching:
+    def test_match_interior(self):
+        v = Value.interior(Diagnosis("ACS", "I21.9", 0.92))
+
+        result = match(v)
+        match result:
+            case Value.Interior(d):
+                assert d.condition == "ACS"
+            case _:
+                pytest.fail("expected Interior")
+
+    def test_match_boundary_with_last(self):
+        diagnosis = Diagnosis("Pneumonia", "J18.9", 0.61)
+        v = Value.boundary(
+            LowConfidence(confidence=0.61, threshold=0.85),
+            last=diagnosis,
+        )
+
+        result = match(v)
+        match result:
+            case Value.Boundary(LowConfidence(confidence=c, threshold=t), last=d):
+                assert c == 0.61
+                assert t == 0.85
+                assert d.condition == "Pneumonia"
+            case _:
+                pytest.fail("expected Boundary with LowConfidence")
+
+    def test_match_different_boundary_kinds(self):
+        v1 = Value.boundary(
+            LowConfidence(0.3, 0.85),
+            last=Diagnosis("Unknown", "R69", 0.3),
+        )
+        v2 = Value.boundary(
+            Hallucinated("Temporal displacement", 0.03),
+            last=Diagnosis("Temporal displacement", "Z99.99", 0.03),
+        )
+
+        m1 = match(v1)
+        m2 = match(v2)
+
+        match m1:
+            case Value.Boundary(LowConfidence(), last=d):
+                assert d.condition == "Unknown"
+            case _:
+                pytest.fail("expected LowConfidence")
+
+        match m2:
+            case Value.Boundary(Hallucinated(claim=c), last=d):
+                assert c == "Temporal displacement"
+                assert d.condition == "Temporal displacement"
+            case _:
+                pytest.fail("expected Hallucinated")
+
+
+# -- Unwrap --
+
+class TestUnwrap:
+    def test_unwrap_interior(self):
+        v = Value.interior(42)
+        assert v.unwrap() == 42
+
+    def test_unwrap_boundary_raises(self):
+        v = Value.boundary(LowConfidence(0.3, 0.85), last="partial")
+        with pytest.raises(BoundaryError) as exc_info:
+            v.unwrap()
+        # Even the exception preserves the information
+        assert exc_info.value.last == "partial"
+        assert exc_info.value.reason == LowConfidence(0.3, 0.85)
+
+
+# -- or_default --
+
+class TestOrDefault:
+    def test_interior_ignores_fallback(self):
+        v = Value.interior(42)
+        assert v.or_default(0) == 42
+
+    def test_boundary_uses_fallback(self):
+        v = Value.boundary(LowConfidence(0.3, 0.85), last="partial")
+        assert v.or_default("fallback") == "fallback"
+
+
+# -- Map --
+
+class TestMap:
+    def test_map_interior(self):
+        v = Value.interior(5)
+        result = v.map(lambda x: x * 2)
+        assert result.is_interior
+        assert result.unwrap() == 10
+
+    def test_map_boundary_preserves_reason_and_maps_last(self):
+        v = Value.boundary(LowConfidence(0.3, 0.85), last=5)
+        result = v.map(lambda x: x * 2)
+        assert result.is_boundary
+        m = match(result)
+        assert m.reason == LowConfidence(0.3, 0.85)
+        assert m.last == 10
+
+
+# -- Repr --
+
+class TestRepr:
+    def test_interior_repr(self):
+        v = Value.interior(42)
+        assert repr(v) == "Value.Interior(42)"
+
+    def test_boundary_repr(self):
+        v = Value.boundary(LowConfidence(0.3, 0.85), last="partial")
+        assert "Boundary" in repr(v)
+        assert "last=" in repr(v)
+
+
+# -- Pipeline demo --
+
+class TestPipeline:
+    """Same scenario as the Rust comparison: 5-layer healthcare pipeline."""
+
+    def infer(self, symptoms: list[str]) -> Value[Diagnosis, LowConfidence]:
+        if not symptoms:
+            return Value.boundary(
+                OutOfDomain(distance=1.0),
+                last=Diagnosis("Unknown", "R69", 0.0),
+            )
+        if "chest pain" in symptoms:
+            return Value.interior(Diagnosis("ACS", "I21.9", 0.92))
+        return Value.boundary(
+            LowConfidence(confidence=0.30, threshold=0.50),
+            last=Diagnosis("Nonspecific", "R69", 0.30),
+        )
+
+    def test_interior_pipeline(self):
+        result = self.infer(["chest pain"])
+        assert result.is_interior
+        assert result.unwrap().condition == "ACS"
+
+    def test_boundary_preserves_last(self):
+        result = self.infer(["fatigue"])
+        assert result.is_boundary
+        m = match(result)
+        # This is the moment. The diagnosis is still here.
+        assert m.last.condition == "Nonspecific"
+        assert m.last.confidence == 0.30
+
+    def test_empty_symptoms_out_of_domain(self):
+        result = self.infer([])
+        assert result.is_boundary
+        m = match(result)
+        assert isinstance(m.reason, OutOfDomain)
+        assert m.last.condition == "Unknown"