purepy-lang 0.1.0__tar.gz

purepy_lang-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: purepy-lang
+Version: 0.1.0
+Summary: The small immutable-record runtime for verified PurePy programs
+Project-URL: Repository, https://github.com/dwrtz/purepy
+Project-URL: Documentation, https://github.com/dwrtz/purepy/blob/main/docs/LANGUAGE_GUIDE.md
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12

purepy_lang-0.1.0/README.md

@@ -0,0 +1,36 @@
+# PurePy runtime
+
+The package supplies the single runtime decorator admitted by PurePy:
+
+```python
+from purepy import value
+
+@value
+class User:
+    user_id: int
+    name: str
+
+user = User(1, name="Ada")
+```
+
+Records are frozen, slotted, nominal, and data-only. The static verifier validates
+field types and deep immutability, including homogeneous tuples, optional values,
+project records, and manifest-declared external values. The runtime permits Python
+3.14 deferred annotations without resolving forward records at decoration time.
+There are no defaults, user methods, or inheritance. The host must supply values
+of the exact declared types; the decorator does not repeat static type checking.
+
+Use uv to create the repository's Python 3.14 virtual environment and install the
+runtime. From the repository root, run:
+
+```sh
+make setup
+make python-test
+```
+
+Python 3.12 and later execute this support package; PurePy source syntax targets
+3.14. The managed development interpreter is `.venv/bin/python`. This runtime
+performs no I/O and has no registry, verifier integration,
+effect interpreter, or application framework. The verifier is authoritative about
+class shapes, recursive records, and field types; arbitrary unverified callers
+remain responsible for the contracts they pass into verified code.

purepy_lang-0.1.0/purepy/__init__.py

@@ -0,0 +1,5 @@
+"""Runtime support for the PurePy language. Verification is performed separately."""
+
+from .value import value
+
+__all__ = ["value"]

purepy_lang-0.1.0/purepy/value.py

@@ -0,0 +1,38 @@
+"""Data-only nominal records, with no registry or runtime effect machinery.
+
+The static verifier remains authoritative about source syntax. These checks catch
+accidental misuse by ordinary Python callers; they are not a Python sandbox.
+"""
+
+from dataclasses import dataclass, fields
+_CLASS_METADATA = frozenset({
+    "__module__", "__qualname__", "__doc__", "__annotations__",
+    "__dict__", "__weakref__", "__firstlineno__", "__static_attributes__",
+    "__annotate__", "__annotate_func__", "__annotations_cache__",
+})
+
+
+def _reject_subclass(cls, **kwargs):
+    raise TypeError("@value records cannot be subclassed")
+
+
+def value(cls):
+    """Create a frozen, slotted record from annotated fields without defaults.
+
+    Positional and explicit keyword construction use declaration order. The
+    verifier validates field types and rejects recursive record definitions. The
+    host must supply exact Pure Values, including immutable external values whose
+    contracts live in manifests. This runtime neither loads manifests nor eagerly
+    resolves Python 3.14 deferred annotations.
+    """
+    if type(cls) is not type or cls.__bases__ != (object,):
+        raise TypeError("@value requires a plain class without inheritance or a metaclass")
+    for name in cls.__dict__:
+        if name not in _CLASS_METADATA:
+            raise TypeError(f"@value class bodies contain only annotated fields, not {name!r}")
+    record = dataclass(frozen=True, slots=True)(cls)
+    for field in fields(record):
+        if field.name.startswith("__") and field.name.endswith("__"):
+            raise TypeError("@value fields cannot use reserved double-underscore names")
+    record.__init_subclass__ = classmethod(_reject_subclass)
+    return record

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

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: purepy-lang
+Version: 0.1.0
+Summary: The small immutable-record runtime for verified PurePy programs
+Project-URL: Repository, https://github.com/dwrtz/purepy
+Project-URL: Documentation, https://github.com/dwrtz/purepy/blob/main/docs/LANGUAGE_GUIDE.md
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12

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

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+purepy/__init__.py
+purepy/py.typed
+purepy/value.py
+purepy_lang.egg-info/PKG-INFO
+purepy_lang.egg-info/SOURCES.txt
+purepy_lang.egg-info/dependency_links.txt
+purepy_lang.egg-info/top_level.txt
+tests/test_value.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+purepy

purepy_lang-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools==80.9.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "purepy-lang"
+version = "0.1.0"
+description = "The small immutable-record runtime for verified PurePy programs"
+requires-python = ">=3.12"
+classifiers = ["Programming Language :: Python :: 3"]
+
+[project.urls]
+Repository = "https://github.com/dwrtz/purepy"
+Documentation = "https://github.com/dwrtz/purepy/blob/main/docs/LANGUAGE_GUIDE.md"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["purepy"]
+
+[tool.setuptools.package-data]
+purepy = ["py.typed"]

purepy_lang-0.1.0/setup.cfg

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

purepy_lang-0.1.0/tests/test_value.py

@@ -0,0 +1,164 @@
+"""Runtime parity and defensive checks for the sole PurePy decorator."""
+
+import dataclasses
+import sys
+import unittest
+
+from purepy import value
+
+
+@value
+class User:
+    identifier: int
+    name: str
+
+
+@value
+class Group:
+    users: tuple[User, ...]
+    title: str | None
+
+
+class ValueTests(unittest.TestCase):
+    def test_positional_keyword_fields_and_equality(self):
+        first = User(1, "Ada")
+        self.assertEqual(first, User(name="Ada", identifier=1))
+        self.assertEqual(first.identifier, 1)
+        self.assertEqual(first.name, "Ada")
+        self.assertNotEqual(first, User(2, "Ada"))
+        self.assertEqual(tuple(field.name for field in dataclasses.fields(User)), ("identifier", "name"))
+
+    def test_nominal_equality(self):
+        @value
+        class Other:
+            identifier: int
+            name: str
+        self.assertNotEqual(User(1, "Ada"), Other(1, "Ada"))
+
+    def test_frozen_slots(self):
+        user = User(1, "Ada")
+        self.assertFalse(hasattr(user, "__dict__"))
+        with self.assertRaises(dataclasses.FrozenInstanceError):
+            user.name = "Grace"
+        with self.assertRaises(dataclasses.FrozenInstanceError):
+            del user.name
+        with self.assertRaises((AttributeError, TypeError)):
+            user.other = 2
+
+    def test_deep_values(self):
+        group = Group((User(1, "Ada"),), None)
+        self.assertEqual(group, Group(users=(User(1, "Ada"),), title=None))
+        with self.assertRaises(dataclasses.FrozenInstanceError):
+            group.users[0].name = "Grace"
+        with self.assertRaises(TypeError):
+            group.users[0] = User(2, "Grace")
+
+    def test_wrong_constructor_binding(self):
+        for call in (lambda: User(1), lambda: User(1, "Ada", "extra"),
+                     lambda: User(1, name="Ada", identifier=2),
+                     lambda: User(1, label="Ada")):
+            with self.assertRaises(TypeError):
+                call()
+
+    def test_no_inheritance(self):
+        with self.assertRaises(TypeError):
+            class Child(User):
+                pass
+        class Base:
+            pass
+        with self.assertRaises(TypeError):
+            @value
+            class Child(Base):
+                identifier: int
+
+    def test_reject_methods_defaults_constants_properties_nested_classes(self):
+        for extra in ({"x": 1}, {"f": lambda self: 1}, {"CONSTANT": 1},
+                      {"field": property(lambda self: 1)}, {"Nested": type("Nested", (), {})},
+                      {"__init__": lambda self: None}, {"__slots__": ()}):
+            with self.subTest(extra=extra), self.assertRaises(TypeError):
+                value(type("Invalid", (), {"__annotations__": {"x": int}, **extra}))
+
+    def test_external_value_contract_is_owned_by_manifest_and_host(self):
+        @dataclasses.dataclass(frozen=True, slots=True)
+        class ExternalValue:
+            text: str
+
+        @value
+        class ContainsExternal:
+            external: ExternalValue
+
+        self.assertEqual(ContainsExternal(ExternalValue("opaque")),
+                         ContainsExternal(ExternalValue("opaque")))
+
+    def test_opaque_value_construction_and_field_reads_do_not_dispatch(self):
+        @dataclasses.dataclass(frozen=True, slots=True)
+        class Opaque:
+            number: int
+
+            def __eq__(self, other):
+                raise AssertionError("opaque equality must not be invoked")
+
+            def __bool__(self):
+                raise AssertionError("opaque truthiness must not be invoked")
+
+            def __repr__(self):
+                raise AssertionError("opaque formatting must not be invoked")
+
+            def __hash__(self):
+                raise AssertionError("opaque hashing must not be invoked")
+
+        @value
+        class Envelope:
+            tokens: tuple[Opaque | None, ...]
+
+        token = Opaque(7)
+        envelope = Envelope(tokens=(token, None))
+        self.assertIs(envelope.tokens[0], token)
+        self.assertIsNone(envelope.tokens[1])
+        with self.assertRaises(dataclasses.FrozenInstanceError):
+            envelope.tokens = ()
+
+    @unittest.skipIf(sys.version_info < (3, 14), "deferred annotation syntax requires Python 3.14")
+    def test_forward_record_annotations_on_python314(self):
+        # No source-level quoted annotations or future import is needed on 3.14.
+        namespace = {"value": value, "__name__": __name__}
+        exec("""
+@value
+class Outer:
+    item: Later
+
+@value
+class Later:
+    number: int
+""", namespace)
+        outer = namespace["Outer"](namespace["Later"](7))
+        self.assertEqual(outer.item.number, 7)
+
+    def test_primitive_optional_nested_tuple_fields(self):
+        @value
+        class Primitives:
+            flag: bool
+            number: float
+            data: bytes
+            nothing: None
+            tuples: tuple[tuple[int, ...], ...]
+        # Python evaluates an annotation spelled None as None, not NoneType.
+        result = Primitives(True, 1.5, b"x", None, ((1, 2), ()))
+        self.assertEqual(result.tuples, ((1, 2), ()))
+
+    def test_no_custom_metaclass(self):
+        class Meta(type):
+            pass
+        with self.assertRaises(TypeError):
+            value(Meta("Invalid", (), {"__annotations__": {"x": int}}))
+
+    def test_empty_record(self):
+        @value
+        class Empty:
+            """An empty record is data-only."""
+        self.assertEqual(Empty(), Empty())
+        self.assertFalse(hasattr(Empty(), "__dict__"))
+
+
+if __name__ == "__main__":
+    unittest.main()