bend-python 0.1.0__py3-none-any.whl

bend_python/lib/thread_state.bend

@@ -0,0 +1,225 @@
+import Base
+
+# Specification of the C driver's thread-state and lease protocol, not
+# verification of C. Attached means a valid CPython thread state (and the GIL
+# on GIL builds). Free-threaded Python still requires attachment.
+#
+# The native states cover bp_native between setting and clearing bp_current:
+# Bend evaluation, where the C bridge makes no Python API call. A native
+# failure longjmps back inside that window, so it also leaves via Leave.
+type State is Data:
+  Attached{}
+  Detached{}
+  AttachedNative{}
+  DetachedNative{}
+
+# Native runtime health: ordinary Python exceptions do not mark a context failed.
+type Outcome is Data:
+  Succeeded{}
+  Failed{}
+
+# A Python effect includes reference-count changes and exception operations.
+type Operation is Data:
+  Save{}
+  Restore{}
+  Enter{}
+  Leave{outcome: Outcome}
+  PythonEffect{}
+  AcquireLease{slot: Nat}
+  ReturnLease{slot: Nat, outcome: Outcome, small_heap: Bool, cache_space: Bool}
+
+def is_native(state: State) -> Bool:
+  match state:
+    case AttachedNative{}:
+      True{}
+    case DetachedNative{}:
+      True{}
+    case _:
+      False{}
+
+def is_leave(operation: Operation) -> Bool:
+  match operation:
+    case Leave{_}:
+      True{}
+    case _:
+      False{}
+
+# Attachment and native transitions. Only step_session handles lease operations.
+def step(state: State, operation: Operation) -> Maybe<State>:
+  match state operation:
+    case Attached{} Save{}:
+      Some{Detached{}}
+    case Detached{} Restore{}:
+      Some{Attached{}}
+    case Attached{} PythonEffect{}:
+      Some{Attached{}}
+    case Attached{} Enter{}:
+      Some{AttachedNative{}}
+    case Detached{} Enter{}:
+      Some{DetachedNative{}}
+    case AttachedNative{} Leave{_}:
+      Some{Attached{}}
+    case DetachedNative{} Leave{_}:
+      Some{Detached{}}
+    case _ _:
+      None{}
+
+def run(operations: List<Operation>, state: State) -> Maybe<State>:
+  match operations:
+    case []:
+      Some{state}
+    case operation <> tail:
+      Maybe.bind(&1, State, State, step(state, operation), next => run(tail, next))
+
+# C detaches during native work when the export asks to, and always on
+# free-threaded builds (Py_GIL_DISABLED), where staying attached only stalls
+# stop-the-world pauses.
+def detaches(release_gil: Bool, free_threaded: Bool) -> Bool:
+  release_gil || free_threaded
+
+def native_call(detach: Bool, outcome: Outcome) -> List<Operation>:
+  match detach:
+    case True{}:
+      [Save{}, Enter{}, Leave{outcome}, Restore{}]
+    case False{}:
+      [Enter{}, Leave{outcome}]
+
+# Each slot denotes one distinct runtime allocation. The C cache must preserve
+# that identity and perform acquisition/return atomically; these are trust inputs.
+type Context is Data:
+  Idle{}
+  Leased{}
+  Discarded{}
+
+def eligible(context: Maybe<&2, Context>) -> Bool:
+  match context:
+    case Some{Idle{}}:
+      True{}
+    case _:
+      False{}
+
+def available(pool: List<&2, Context>, slot: Nat) -> Bool:
+  eligible(List.get(&2, Context, pool, slot))
+
+def leased(context: Maybe<&2, Context>) -> Bool:
+  match context:
+    case Some{Leased{}}:
+      True{}
+    case _:
+      False{}
+
+def returnable(pool: List<&2, Context>, slot: Nat) -> Bool:
+  leased(List.get(&2, Context, pool, slot))
+
+def reserve(pool: List<&2, Context>, slot: Nat) -> List<&2, Context>:
+  List.set(&2, Context, pool, slot, Leased{})
+
+def acquire_if(allowed: Bool, pool: List<&2, Context>, slot: Nat) -> Maybe<List<&2, Context>>:
+  match allowed:
+    case True{}:
+      Some{reserve(pool, slot)}
+    case False{}:
+      None{}
+
+def acquire(+pool: List<&2, Context>, +slot: Nat) -> Maybe<List<&2, Context>>:
+  acquire_if(available(pool, slot), pool, slot)
+
+# C's bp_runtime_release: an instance is reusable when it is not poisoned (no
+# native failure) and its heap stayed within 32 MiB; it is cached when it is
+# reusable and fewer than eight instances are idle. Otherwise it is unmapped.
+def completion(outcome: Outcome, small_heap: Bool, cache_space: Bool) -> Context:
+  match outcome small_heap cache_space:
+    case Succeeded{} True{} True{}:
+      Idle{}
+    case _ _ _:
+      Discarded{}
+
+def finish(pool: List<&2, Context>, slot: Nat, outcome: Outcome, small_heap: Bool, cache_space: Bool) -> List<&2, Context>:
+  List.set(&2, Context, pool, slot, completion(outcome, small_heap, cache_space))
+
+def finish_if(allowed: Bool, pool: List<&2, Context>, slot: Nat, outcome: Outcome, small_heap: Bool, cache_space: Bool) -> Maybe<List<&2, Context>>:
+  match allowed:
+    case True{}:
+      Some{finish(pool, slot, outcome, small_heap, cache_space)}
+    case False{}:
+      None{}
+
+# Only a leased slot may be returned; a double return is rejected.
+def release(+pool: List<&2, Context>, +slot: Nat, outcome: Outcome, small_heap: Bool, cache_space: Bool) -> Maybe<List<&2, Context>>:
+  finish_if(returnable(pool, slot), pool, slot, outcome, small_heap, cache_space)
+
+# The combined model: one invocation's thread state together with the pool.
+type Session is Data:
+  Session{state: State, pool: List<&2, Context>}
+
+def detached_with(pool: Maybe<List<&2, Context>>) -> Maybe<Session>:
+  match pool:
+    case Some{next}:
+      Some{Session{Detached{}, next}}
+    case None{}:
+      None{}
+
+def with_pool(state: Maybe<State>, pool: List<&2, Context>) -> Maybe<Session>:
+  match state:
+    case Some{next}:
+      Some{Session{next, pool}}
+    case None{}:
+      None{}
+
+# The pool mutex is taken only while detached; lease operations in any other
+# state are rejected.
+def step_session(session: Session, operation: Operation) -> Maybe<Session>:
+  match session operation:
+    case Session{Detached{}, pool} AcquireLease{slot}:
+      detached_with(acquire(pool, slot))
+    case Session{Detached{}, pool} ReturnLease{slot, outcome, small_heap, cache_space}:
+      detached_with(release(pool, slot, outcome, small_heap, cache_space))
+    case Session{_, _} AcquireLease{_}:
+      None{}
+    case Session{_, _} ReturnLease{_, _, _, _}:
+      None{}
+    case Session{state, pool} operation:
+      with_pool(step(state, operation), pool)
+
+def run_session(operations: List<Operation>, session: Session) -> Maybe<Session>:
+  match operations:
+    case []:
+      Some{session}
+    case operation <> tail:
+      Maybe.bind(&1, Session, Session, step_session(session, operation), next => run_session(tail, next))
+
+# One invocation owns its context throughout native work and attached effects.
+# Only cache acquire/return takes a shared lock; evaluation has no shared mutex.
+def acquire_call(slot: Nat) -> List<Operation>:
+  [Save{}, AcquireLease{slot}, Restore{}]
+
+def return_call(slot: Nat, outcome: Outcome, small_heap: Bool, cache_space: Bool) -> List<Operation>:
+  [Save{}, ReturnLease{slot, outcome, small_heap, cache_space}, Restore{}]
+
+# A lease is healthy only if every native step succeeded; one failure poisons it.
+def health(outcomes: List<&2, Outcome>) -> Outcome:
+  match outcomes:
+    case []:
+      Succeeded{}
+    case Succeeded{} <> tail:
+      health(tail)
+    case Failed{} <> _:
+      Failed{}
+
+# bp_run's loop: each native step (start, resume, or dropping the continuation
+# after a Python exception) is followed by attached Python work: performing the
+# requested effect, or raising. C stops after the first native failure; the
+# model also allows later rounds, so its laws cover that too.
+def rounds(+detach: Bool, outcomes: List<&2, Outcome>) -> List<Operation>:
+  match outcomes:
+    case []:
+      []
+    case outcome <> tail:
+      List.append(&1, Operation, native_call(detach, outcome), PythonEffect{} <> rounds(detach, tail))
+
+# bp_run: lease, run any number of rounds, then return the lease (marked by
+# the rounds' health) before releasing the arena.
+def invocation(+slot: Nat, detach: Bool, +outcomes: List<&2, Outcome>, small_heap: Bool, cache_space: Bool) -> List<Operation>:
+  List.append(&1, Operation, acquire_call(slot),
+    List.append(&1, Operation, rounds(detach, outcomes),
+      return_call(slot, health(outcomes), small_heap, cache_space)))

bend_python/library.py

@@ -0,0 +1,52 @@
+"""Find or vendor the Bend library shipped with the Python build helper."""
+
+import os
+from pathlib import Path
+import shutil
+
+
+def library_path():
+    """Return the directory containing python.bend, python.c, and their laws."""
+    installed = Path(__file__).with_name("lib")
+    checkout = Path(__file__).resolve().parents[2] / "bend"
+    for candidate in (installed, checkout):
+        if (candidate / "python.bend").is_file() and (candidate / "python.c").is_file():
+            return candidate
+    raise RuntimeError("The bend-python installation is missing its Bend library")
+
+
+def get_include():
+    """Return the library directory as a string, for build-tool compatibility."""
+    return str(library_path())
+
+
+def vendor(destination="bend", *, force=False):
+    """Copy the library into a project for Bend's relative imports.
+
+    Existing identical files are accepted. Different files are preserved unless
+    ``force=True``; unrelated files in the directory are always preserved. A
+    symlink is never written through: it must already open the library file, or
+    it is a conflict that ``force=True`` replaces with a regular file.
+    """
+    source = library_path()
+    target = Path(destination)
+    files = sorted(path for path in source.iterdir() if path.suffix in {".bend", ".c"})
+
+    def current(path):
+        existing = target / path.name
+        if existing.is_symlink():
+            return existing.resolve() == path.resolve()
+        return existing.is_file() and existing.read_bytes() == path.read_bytes()
+
+    stale = [path for path in files if not current(path)]
+    conflicts = [target / path.name for path in stale if os.path.lexists(target / path.name)]
+    if conflicts and not force:
+        names = ", ".join(str(path) for path in conflicts)
+        raise FileExistsError(f"Refusing to replace modified library files: {names}; use --force")
+    target.mkdir(parents=True, exist_ok=True)
+    for path in stale:
+        destination_file = target / path.name
+        if destination_file.is_symlink():
+            destination_file.unlink()
+        shutil.copyfile(path, destination_file)
+    return target.resolve()

bend_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,262 @@
+Metadata-Version: 2.4
+Name: bend-python
+Version: 0.1.0
+Summary: Write CPython extensions in Bend 2, with laws proved at build time
+Author: Lucas Wiman
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/lucaswiman/bend-python
+Project-URL: Source, https://github.com/lucaswiman/bend-python
+Project-URL: Issues, https://github.com/lucaswiman/bend-python/issues
+Project-URL: Changelog, https://github.com/lucaswiman/bend-python/blob/main/CHANGELOG.md
+Keywords: bend,extension,native,setuptools,proof,dependent types
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Setuptools Plugin
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# bend-python
+
+Write CPython extensions in [Bend 2](https://github.com/bendlang/bend), a pure,
+dependently typed language that compiles to native code, and state laws about
+your code that the build **proves before it compiles**. A false law is a build
+error, not a failing test.
+
+```bend
+# fast.bend
+import Base
+import ./bend/python.bend as Python
+
+def square(+x: U32) -> U32:
+  (x * x : U32)
+
+def main() -> IO(Unit):
+  Python.export_u32(~(x => square(x)), "square", True{})
+```
+
+```bend
+# LAWS.bend: the claim
+import Base
+import ./fast.bend as Fast
+
+law square_wraps:
+  {Fast.square(65536) == 0 : U32}
+```
+
+```bend
+# PROOF.bend: its proof, checked by every build
+import Base
+import ./LAWS.bend as Laws
+
+def Laws.square_wraps():
+  {==}
+```
+
+```python
+>>> import fast
+>>> fast.square(12)
+144
+>>> fast.square(2**16)           # U32 arithmetic wraps, as the law says
+0
+>>> fast.square(-1)
+OverflowError: can't convert negative value to unsigned int
+```
+
+`True{}` releases the GIL while Bend computes, so threads calling `square` run
+in parallel. Installed wheels need neither Bend nor a compiler.
+
+**Status: experimental.** Linux x86_64, CPython 3.10–3.14 including free-threaded
+3.14t, Bend pinned to 2.0.28. Bend 2 is young: its strings are linked lists of
+characters, so text-heavy code is slow and memory-hungry. Benchmark before
+relying on it.
+
+## Build an extension
+
+You need Clang and the `bend-python` SDK in your build environment. The first
+build downloads the pinned Bend compiler (checksum-verified, cached under
+`~/.cache/bend-python`); set `BEND` to use your own, or `BEND_PYTHON_DOWNLOAD=0`
+to forbid the download.
+
+`fast.bend` imports `./bend/python.bend`. If that directory is missing, the build
+copies the SDK's Bend library there; `python -m bend_python vendor bend` does
+the same by hand, for editors and `bend --check-only`.
+
+`setup.py` (setuptools is the only supported build backend):
+
+```python
+from setuptools import setup
+from bend_python import BendBuildExt, BendExtension
+
+setup(
+    name="fast",
+    ext_modules=[BendExtension("fast", "fast.bend", proofs=["PROOF.bend"])],
+    cmdclass={"build_ext": BendBuildExt},
+)
+```
+
+`pyproject.toml`:
+
+```toml
+[build-system]
+requires = ["setuptools>=80", "bend-python==0.1.0"]
+build-backend = "setuptools.build_meta"
+```
+
+Then `python -m build` or `pip install .`. The build proves the library's laws
+and yours, generates C, and compiles it; a false law ends the build with
+`error: Bend proof check failed: PROOF.bend` after Bend's diagnostic. Dotted
+names such as `mypackage._native` work. Ship your `.bend` files in the sdist
+(`include *.bend` in `MANIFEST.in`).
+[`examples/`](https://github.com/lucaswiman/bend-python/tree/main/examples) is a
+complete project built this way.
+
+## The Python interface
+
+An export receives a `Python.Call` (positional arguments and a kwargs dict) and
+returns `IO(Python.Object)`. A `Python.Object` is a handle to any Python object:
+passing one through Bend preserves identity, aliases, cycles and precision,
+with no serialization.
+
+```bend
+def echo(request: Python.Call) -> IO(Python.Object):
+  Python.unary(request)                  # exactly one positional argument
+
+# in main:  Python.export("echo", echo, False{})
+```
+
+| Bend API | Does |
+|---|---|
+| `export(name, function, release_gil)` | Expose `Call -> IO(Object)`; `function` must not capture variables |
+| `export_u32` / `export_f32` / `export_bool` / `export_string` / `export_binary_u32` | Typed exports from a template `~f`: argument checks and conversions included. Binary templates are curried: `~(x => y => add(x, y))` |
+| `unary`, `binary` | Require exactly one/two positional arguments and no keywords |
+| `to_u32` `from_u32` `to_f32` `from_f32` `to_bool` `from_bool` `to_string` `from_string` `from_nat` | Convert between Python objects and Bend values |
+| `to_bytes`, `from_bytes` | Any contiguous buffer (`bytes`, `bytearray`, `memoryview`, ...) to `List<U32>` of bytes, and back to `bytes` |
+| `truthy` | Python truthiness, as `bool(value)` |
+| `get_item` `set_item` `getattr` `len` | The Python operations, raising Python's exceptions |
+| `tuple` `list` `dict` `empty_dict` `none` | Build Python objects |
+| `call(f, args, kwargs)`, `invoke(f, arguments)` | Call Python, including callbacks that reenter Bend |
+| `builtins(name)`, `construct(name, arguments)` | Look up or call a builtin such as `"int"` or `"dict"` |
+| `import_module(name)` | Import a module, such as `"operator"` |
+
+Conversions are strict. `to_u32` accepts only `int` in `[0, 2**32)`, not `bool`;
+`to_bool` only `bool` (use `truthy` for anything else). `to_f32` accepts only
+`float` and rounds to single precision (overflowing to infinity). Strings convert
+codepoint by codepoint, lone surrogates included; they are linked lists in Bend,
+so prefer `to_bytes` for binary data.
+`to_bytes` snapshots a direct `bytearray` while holding its lock on free-threaded
+Python. For other mutable buffer exporters, including memoryviews of mutable
+storage, callers must prevent concurrent writes while conversion runs.
+Wrong types raise `TypeError`, out-of-range values `OverflowError`, and wrong
+arity or unexpected keywords in typed exports `TypeError`. Python exceptions
+raised inside a call propagate unchanged.
+
+Handles are valid only during the call that created them. The bridge seals each
+handle with a per-call key and rejects invalid decoded handles with `ValueError`.
+This detects accidental fabrication or reuse from another call probabilistically;
+it is not an absolute guarantee or a security boundary.
+
+## Threads and the GIL
+
+Every call runs in its own Bend runtime instance (heap, stack and allocator),
+so threads call the same extension concurrently, and callbacks can reenter it.
+The third argument to `export` sets the GIL policy: `True{}` releases the GIL
+during pure Bend evaluation, `False{}` holds it. Free-threaded builds always
+detach during evaluation and never enable the GIL. The bridge reattaches before
+every Python operation. Each call uses one CPU core; Bend's own parallel
+scheduler and GPU backends are not enabled.
+
+## What is proved, and what is trusted
+
+The build refuses to compile unless every law checks:
+
+- **Argument checks.** Typed exports accept exactly the right number of
+  arguments and request a `TypeError` for every other count
+  ([`bend/LAWS.bend`](https://github.com/lucaswiman/bend-python/blob/main/bend/LAWS.bend)).
+- **Thread protocol.** A model of the C driver proves that Python operations
+  happen only while attached and never during native evaluation, that every
+  call returns attached (failures included), and that free-threaded builds
+  detach ([`bend/THREAD_LAWS.bend`](https://github.com/lucaswiman/bend-python/blob/main/bend/THREAD_LAWS.bend)).
+- **Runtime leases.** In the same model, a call with any number of evaluation
+  rounds owns one instance and changes no other, a lease cannot be returned
+  twice, a native failure in any round poisons it, and only healthy, small
+  instances are cached for reuse.
+
+Each model was mutation-tested: breaking any of these rules fails a law. The
+laws are about models and pure Bend code. **Nothing proves that the C bridge
+implements the model**, or anything about CPython, reference counting, or the
+generated runtime; those are covered by tests. The table maps each invariant to
+its evidence:
+
+| Invariant | Evidence |
+|---|---|
+| Python API only while attached, never during evaluation | Model proved (`native_effect_rejected`, `native_only_leaves`); C asserts attachment (and the GIL on GIL builds) at every boundary |
+| Every call returns attached, including after native failures | Model proved for any slot, rounds and outcomes (`native_returns_attached`, `invocation_returns_attached`); C's `setjmp` placement trusted |
+| One call per runtime instance | Model proved (`acquisition_requires_available`, `leased_invocation_rejected`, `double_return_rejected`); C's pool mutex trusted; concurrency test |
+| A native failure affects only its instance | Model proved (`failure_isolated`); C unmaps poisoned instances; test |
+| Failed or large instances are never reused | Model proved (`failure_poisons_lease`, `reusable_requires_*`); test for memory release |
+| Wrong arity is a `TypeError` | Proved for the parsers and wrappers (`*_exact_arity`, `*_complete`, `*_rejected`); keyword rejection tested |
+| Accidental forged or stale handles are detected | Sealing in C; tests. Rejection is probabilistic: 32-bit collisions remain possible. Hostile Bend code can import its own C |
+| Exports cannot capture variables | Checked by C at import; test |
+| Objects cross unchanged; conversions are strict | C; tests |
+
+## Limits
+
+- Main interpreter only; subinterpreters are rejected.
+- A native Bend failure (such as `Nat` overflow) raises `RuntimeError` and
+  discards that runtime instance; other calls are unaffected. Native crashes and
+  stack exhaustion still kill the process.
+- Each active instance reserves about 10 GiB of *virtual* memory, so `ulimit -v`
+  or strict overcommit can make calls fail. Up to eight idle instances are
+  cached; an instance whose heap grew past 32 MiB is released instead.
+- Bend's C runtime is private API. The build pins 2.0.28 and refuses to patch a
+  runtime that has changed.
+
+## Developing this repository
+
+```sh
+bash scripts/bootstrap.sh              # Python 3.14, uv venv, checksum-verified Bend
+uv pip install --python .venv/bin/python --no-build-isolation -e .
+(cd examples && CC=clang ../.venv/bin/python setup.py build_ext --inplace)
+.venv/bin/python -m unittest discover -s tests
+uvx prek install                       # ruff, file hygiene, and proof gates on commit
+```
+
+[`docker/Dockerfile`](https://github.com/lucaswiman/bend-python/blob/main/docker/Dockerfile)
+builds the pure SDK wheel once, then builds, `auditwheel`-repairs and tests the
+example for CPython 3.10–3.14 and 3.14t with the image's current Clang. Select
+versions with `-e PYTHON_TAGS=cp314-cp314t`.
+
+```sh
+docker build -f docker/Dockerfile -t bend-python-manylinux .
+docker run --rm --user "$(id -u):$(id -g)" \
+  -v "$PWD:/io:ro" -v "$PWD/wheelhouse:/wheelhouse" bend-python-manylinux
+```
+
+[CI](https://github.com/lucaswiman/bend-python/blob/main/.github/workflows/wheels.yml)
+runs that recipe per version, `prek`, and `twine check` on the SDK. Record changes
+under "Unreleased" in [`CHANGELOG.md`](https://github.com/lucaswiman/bend-python/blob/main/CHANGELOG.md).
+To release, move them to a dated `## [X.Y.Z] - YYYY-MM-DD` section matching the
+project version and publish a GitHub release tagged `vX.Y.Z`; the
+[release workflow](https://github.com/lucaswiman/bend-python/blob/main/.github/workflows/release.yml)
+checks both, then publishes the SDK to PyPI by trusted publishing, with
+provenance attestations. [`AGENTS.md`](https://github.com/lucaswiman/bend-python/blob/main/AGENTS.md)
+has notes for contributors and coding agents.
+
+## License
+
+[MIT](https://github.com/lucaswiman/bend-python/blob/main/LICENSE).

bend_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+bend_python/__init__.py,sha256=OIRqMCQzAl1jR8CvixAoU2I91rVTuAJAlvuDwrTabnU,661
+bend_python/__main__.py,sha256=JGA_yvOmQflnq_zvVtBX3s39I6ZZCNywIqDnbcHvKjE,924
+bend_python/build.py,sha256=zcKj6WKYwPPyuGq0lgMTch98J6Yp7Z651fs-iQM4eIM,14993
+bend_python/library.py,sha256=vsr45hq-1BSiUoU9wZjJzYEjbgpgwqEiTWmyEIdy1AY,2145
+bend_python/lib/LAWS.bend,sha256=YOIHKsfTskVUcW8aAga52V6fC0fI3r7tvsb6Avh7IPc,3337
+bend_python/lib/PROOF.bend,sha256=1p0OqP_HS6kEzEppnhM4JPnBdAc4BizIIj0jeX9ahJo,3688
+bend_python/lib/THREAD_LAWS.bend,sha256=tP9I58ii2rtJjOBb5mhZDxsZBFtbtTgG9JcLd-wOl0Y,7916
+bend_python/lib/THREAD_PROOF.bend,sha256=PmvHozp6Z287bZzWUfdjKm32FzMWv8lNiGsIk59X6aw,14565
+bend_python/lib/python.bend,sha256=9EWUc1vZoldzKns_QMpRUQd8_N33PmRTnZ2pBvv2Jjc,6704
+bend_python/lib/python.c,sha256=_e7GzGdImxtB_lf6Kz906FImlRBhRamhI6Pl8Bo31vI,29366
+bend_python/lib/thread_state.bend,sha256=QjkzfQnF_Cov6STn11l26XD1wD7wWmlKKHkOYPzqidQ,7971
+bend_python-0.1.0.dist-info/licenses/LICENSE,sha256=16PdXBiotwGBf2K9Cxt_kttbhz1ULtpaPMEJb-7lUO4,1068
+bend_python-0.1.0.dist-info/METADATA,sha256=iZmA9aGijWRojd5YhiB7lMYtjWBZQ2a_fQNp3XDJdBg,12442
+bend_python-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+bend_python-0.1.0.dist-info/top_level.txt,sha256=Ws_7WRe8A92BLNtvCFa2qeyqHqlK1erA0IRbRTKv4CU,12
+bend_python-0.1.0.dist-info/RECORD,,

bend_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bend_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lucas Wiman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bend_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bend_python