wasmkeep 0.2.0__py3-none-any.whl

wasmkeep/workflow.py

@@ -0,0 +1,110 @@
+"""Durable workflows (ADR 0019): the client side.
+
+A workflow class is served by the Rust SDK's runner (or the TypeScript
+one), one actor per instance, as `examples/workflows/orders` is. This module
+starts and follows instances from any Python actor, speaking the runner's
+protocol (`/wasmkeep-workflow/v1`) over `actors.call`, byte for byte like
+the Rust `workflow::Client`:
+
+```python
+from wasmkeep import Actor, workflow
+
+orders = workflow.Client("orders")
+
+class App(Actor):
+    def fetch(self, req):
+        orders.start("order-42", "item=book")      # idempotent while kept
+        orders.send_event("order-42", "approved", b"")
+        return orders.status("order-42").state     # "waiting", "completed", ...
+```
+
+Errors raise `WorkflowError`: "unknown" (no such instance), "finished" (an
+event to a finished instance), "call" or "refused".
+"""
+
+from typing import Optional
+
+from ._call import CallFailed, call
+from .wire import STATES, Data, Status, decode_status, hex, lossy, to_bytes
+
+__all__ = ["STATES", "Client", "Status", "WorkflowError"]
+
+_PREFIX = "/wasmkeep-workflow/v1"
+
+
+class WorkflowError(Exception):
+    """Why a workflow operation failed, as `kind`:
+
+    - "unknown": no instance with that id (never started, or deleted after
+      its retention);
+    - "finished": the instance has finished, so it takes no more events;
+    - "call": the call failed (the instance may or may not have recorded
+      it);
+    - "refused": the instance answered with an unexpected `status`.
+    """
+
+    def __init__(self, kind: str, detail: str = "", status: Optional[int] = None):
+        if kind == "unknown":
+            message = "no such workflow instance"
+        elif kind == "finished":
+            message = "the workflow instance has finished"
+        elif kind == "call":
+            message = detail
+        else:
+            message = f"refused ({status}): {detail}"
+        super().__init__(message)
+        self.kind = kind
+        self.detail = detail
+        """The detail: the call's error, or the instance's answer."""
+        self.status = status
+        """The instance's status, for "refused"."""
+
+
+class Client:
+    """Starts and queries instances of one workflow class."""
+
+    def __init__(self, cls: str):
+        """Instances of `cls` (the workflow class's name): instance `id` is
+        actor `cls/id`."""
+        self.cls = cls
+
+    def _call(self, id: str, method: str, path: str, body: bytes) -> bytes:  # noqa: A002 - Rust's name
+        try:
+            status, reply = call(f"{self.cls}/{id}", method, f"{_PREFIX}{path}", {}, body)
+        except CallFailed as e:
+            raise WorkflowError("call", str(e)) from None
+        if status == 200:
+            return reply
+        if status == 404:
+            raise WorkflowError("unknown")
+        if status == 409:
+            raise WorkflowError("finished")
+        raise WorkflowError("refused", lossy(reply), status)
+
+    @staticmethod
+    def _status(body: bytes) -> Status:
+        status = decode_status(body)
+        if status is None:
+            raise WorkflowError("refused", "malformed status", 200)
+        return status
+
+    def start(self, id: str, input: Data = b"") -> Status:  # noqa: A002 - Rust's names
+        """Starts instance `id` with `input`, or returns its status if it
+        exists (a start is idempotent while the instance is kept). It runs
+        in its own event, soon after: this call only records it."""
+        return self._status(self._call(id, "POST", "/start", to_bytes(input)))
+
+    def status(self, id: str) -> Status:  # noqa: A002 - Rust's name
+        """The instance's status; "unknown" if there is none."""
+        return self._status(self._call(id, "GET", "/status", b""))
+
+    def send_event(self, id: str, name: str, payload: Data = b"") -> None:  # noqa: A002 - Rust's name
+        """Delivers event `name` with `payload`: recorded durably, then the
+        instance runs. "unknown" if it was never started, "finished" if it
+        has finished."""
+        self._call(id, "POST", f"/event?name={hex(name.encode())}", to_bytes(payload))
+
+    def cancel(self, id: str) -> Status:  # noqa: A002 - Rust's name
+        """Cancels the instance: it runs no further step (one running now
+        finishes first). Returns its status; a finished one is unchanged."""
+        return self._status(self._call(id, "POST", "/cancel", b""))

wasmkeep-0.2.0.dist-info/METADATA

@@ -0,0 +1,254 @@
+Metadata-Version: 2.5
+Name: wasmkeep
+Version: 0.2.0
+Summary: Write WasmKeep actors in Python.
+Project-URL: Repository, https://github.com/WasmKeep/wasmkeep
+Project-URL: Documentation, https://github.com/WasmKeep/wasmkeep/tree/main/sdks/python
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: actors,component-model,wasi,wasmkeep,webassembly
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: componentize-py==0.25.1
+Description-Content-Type: text/markdown
+
+# WasmKeep actors in Python
+
+Write [WasmKeep](https://github.com/WasmKeep/wasmkeep) actors as plain Python
+classes. WasmKeep is a self-hosted platform for actors: WebAssembly
+components, each with its own SQLite database, handling one event at a time.
+This package is the SDK and the command that builds your module into such a
+component, with
+[componentize-py](https://github.com/bytecodealliance/componentize-py)
+(CPython embedded). WasmKeep is pre-alpha.
+
+## Install
+
+```bash
+python3 -m venv .venv && . .venv/bin/activate
+pip install wasmkeep
+```
+
+That is all a build needs: the package carries the WIT files of the
+`wasmkeep:actor` world, and componentize-py comes with it at the version
+the SDK is written for. To run the result you need the `wasmkeep` server:
+[install a release](https://github.com/WasmKeep/wasmkeep#install) of the
+same version as the package.
+
+## A first actor
+
+`app.py`:
+
+```python
+from wasmkeep import Actor, storage
+
+
+class Hits(Actor):
+    # Once per deployed version, before any other event: create tables here.
+    def init(self):
+        storage.exec("CREATE TABLE IF NOT EXISTS hits (at INTEGER NOT NULL)")
+
+    # One HTTP request at a time, in arrival order: no locks needed.
+    def fetch(self, req):
+        storage.exec("INSERT INTO hits (at) VALUES (unixepoch())")
+        [row] = storage.query("SELECT count(*) AS n FROM hits")
+        return {"hits": row["n"], "path": req.path}   # a dict is sent as JSON
+
+
+WitWorld, IncomingHandler = Hits.exports()
+```
+
+Build it into a component and serve it:
+
+```bash
+python -m wasmkeep build app -o actor.wasm
+wasmkeep serve --actor hits=actor.wasm
+```
+
+In another terminal:
+
+```bash
+curl localhost:8080/actor/hits/alice   # {"hits": 1, "path": "/"}
+curl localhost:8080/actor/hits/alice   # {"hits": 2, "path": "/"}
+curl localhost:8080/actor/hits/bob     # {"hits": 1, "path": "/"}: another actor, its own database
+```
+
+`build` takes the module's name (`app` for `app.py`), found in the current
+directory; `-p DIR` (repeatable) names other directories to find it and
+what it imports in. Pure-Python packages installed in the same environment
+are bundled too. The last line of `app.py` is what the component exports:
+keep it at module level.
+
+The other hooks, all optional:
+
+```python
+from wasmkeep import Actor, sockets
+
+
+class Room(Actor):
+    # The alarm set with alarms.set(...) fired (at least once).
+    def alarm(self):
+        pass
+
+    def websocket_open(self, conn, path):
+        sockets.send(conn, "welcome")       # return False to refuse
+
+    def websocket_message(self, conn, data):
+        sockets.broadcast(data)
+
+    def websocket_close(self, conn, code, reason):
+        pass
+```
+
+## Versions
+
+| | |
+| --- | --- |
+| The package | The version of the WasmKeep server it is released with; use the two at the same version |
+| componentize-py | 0.25.1 exactly, installed with the package: the SDK imports the bindings that version generates |
+| Python, to run the build | 3.10 or later (CI builds with 3.13) |
+| Python, in the component | CPython 3.14, the one componentize-py 0.25.1 embeds, whatever Python ran the build |
+| The interface | `wasmkeep:actor@0.2.0`, versioned on its own: `wasmkeep.WIT_VERSION`, the WIT files in the package's `wit/` |
+
+`python -m wasmkeep --version` prints the package's version and the
+interface's.
+
+## Outside a component
+
+The host's functions (`storage`, `alarms`, `actors`, `sockets`, `env`, and
+`exports()`) exist only inside a built component, running on a WasmKeep
+node. Under plain CPython the package imports, so an editor resolves it and
+the build command runs, but calling one of them raises `RuntimeError`: an
+actor is tried by building it and serving it (`wasmkeep serve` runs on a
+laptop). Keep logic you want to unit-test in functions that take and return
+plain values.
+
+## API
+
+| | |
+| --- | --- |
+| `storage.exec(sql, *params)` | Runs a statement; returns the rows changed |
+| `storage.exec_durable(sql, *params)` | The same, returning once the write is durable (inside a transaction, only `COMMIT`) |
+| `storage.query(sql, *params)` | Rows as dicts, by column name |
+| `storage.delete_self()` | Deletes this actor when the event ends |
+| `alarms.set(at_ms)`, `alarms.get()`, `alarms.clear()` | The actor's single alarm, in ms since the Unix epoch |
+| `env.get(name, default=None)` | The class's configuration value or secret (`deploy --config`, `secrets set`, `serve --env`; last wins; see [`env`](https://github.com/WasmKeep/wasmkeep/blob/v0.2.0/docs/reference/api.md#interface-env)), or `default` |
+| `actors.self_address()` | This actor's `ActorAddress` (`tenant`, `class_name`, `name`) |
+| `actors.call("class/name", method=, path=, headers=, body=)` | Calls another actor; returns a `CallResponse` (`status`, `headers`, `body`, `text()`, `json()`) |
+| `sockets.send(conn, data)`, `broadcast(data, except_conn=)`, `close(conn, code, reason)`, `connections()` | The actor's WebSockets (str is text, bytes binary) |
+| `Response(body, status, headers)`, `json(value, status)` | Full responses; a handler may also return str, bytes, a dict or a list |
+
+SQL values are `None`, `int`, `float`, `str` and `bytes` (`bool` binds as 0
+or 1). Failures raise `SqlError` (with `.kind`: syntax, constraint, bind, ...)
+and `CallError` (`.kind`: invalid-address, reentrant, too-large, timeout,
+failed). An exception in `fetch` becomes a 500; in `init` or `alarm` it fails
+the event (an alarm is retried).
+
+One instance of your class handles events until the actor hibernates; keep
+anything that must survive in `storage`, not on `self`.
+
+## Key-value and queues
+
+`wasmkeep.kv` and `wasmkeep.queue` are clients for key-value shards and
+queues built from actors ([ADR 0015](https://github.com/WasmKeep/wasmkeep/blob/v0.2.0/docs/adr/0015-kv-and-queues-as-sdk-patterns.md)).
+The shard and queue classes are the Rust SDK's: deploy the components of
+[`examples/jobs`](https://github.com/WasmKeep/wasmkeep/tree/v0.2.0/examples/jobs)
+as classes `kv` and `queue` (a release carries them already built, `kv.wasm`
+and `queue.wasm`). These clients speak their protocol over `actors.call`, byte for byte like the
+Rust and TypeScript clients, so all of them share the same data.
+
+```python
+from wasmkeep import Actor, kv, queue
+
+store = kv.Client("kv", 8).with_read_cache(60_000)   # 8 shards; get may serve 60 s old reads
+jobs = queue.Client("queue/jobs")
+
+
+class App(Actor):
+    def fetch(self, req):
+        if queue.is_delivery(req):                    # a push from a queue
+            return queue.handle_delivery(req, lambda _queue, m: "ack")
+        version = store.put("user:42", "Ada")
+        store.compare_and_set("user:42", version, "Ada L.")   # KvError "conflict" if it moved
+        jobs.send("resize 42")
+        return store.get("user:42").value
+
+
+WitWorld, IncomingHandler = App.exports()
+```
+
+| | |
+| --- | --- |
+| `kv.Client(class_name, shards)` | Keys over `shards` actors `class_name/shard-<i>`; every caller uses the same count |
+| `get(key)`, `get_fresh(key)` | An `Entry` (`value`, `version`, `expires_at`) or `None`; `get_fresh` skips the read cache |
+| `put(key, value)`, `put_with(key, value, expect=, ttl_ms=, durable=)` | The new version; `expect` is `"any"`, `"absent"` or a version |
+| `compare_and_set(key, expected, value)` | `put` only at version `expected` (`None`: absent) |
+| `delete(key)`, `delete_if(key, version)` | `True` if the key was there |
+| `list(prefix, after=None, limit=100)` | Keys (`bytes`) from every shard, in byte order |
+| `queue.Client(address)` | One queue actor, `class/name` |
+| `send(body)`, `send_delayed(body, ms)`, `send_batch(bodies)` | Ids, once durable; a batch (up to 1,000) is all or none |
+| `lease(max, visibility_ms)`, `ack(m)`, `retry(m, delay_ms=None)`, `settle(items)` | Pull consumers; `ack` and `retry` are `False` for a stale lease |
+| `stats()`, `dead_letters(limit)` | `Stats` (`ready`, `delayed`, `in_flight`, `dead`) and `DeadLetter`s |
+| `queue.is_delivery(req)`, `queue.handle_delivery(req, handle)` | Push consumers: `handle(queue, message)` returns `"ack"`, `"retry"` or `queue.RetryAfter(ms)` |
+
+Failures raise `kv.KvError` (`.kind`: conflict, key-too-long, storage, call,
+refused with `.status`) and `queue.QueueError` (storage, call, refused);
+numbers outside Rust's `u32`/`u64` raise `ValueError`. The
+[guide](https://github.com/WasmKeep/wasmkeep/blob/v0.2.0/docs/kv-and-queues.md#python) covers the semantics and
+limits; [`examples/py-jobs`](https://github.com/WasmKeep/wasmkeep/tree/v0.2.0/examples/py-jobs) is a working app.
+
+## Workflows
+
+`wasmkeep.workflow` starts and follows durable workflows
+([ADR 0019](https://github.com/WasmKeep/wasmkeep/blob/v0.2.0/docs/adr/0019-workflows-as-an-sdk-pattern.md)): the
+workflow class is written with the Rust SDK's runner (as
+[`examples/workflows/orders`](https://github.com/WasmKeep/wasmkeep/tree/v0.2.0/examples/workflows/orders),
+which a release carries already built, `workflows-orders.wasm`), one actor
+per instance, and this client speaks its protocol over `actors.call`, like
+the Rust `workflow::Client`. Only the client side is in Python.
+
+```python
+from wasmkeep import workflow
+
+orders = workflow.Client("orders")              # instance `id` is actor `orders/<id>`
+orders.start("order-42", "item=book")           # a Status; idempotent while kept
+orders.send_event("order-42", "approved", b"")
+status = orders.status("order-42")              # status.state, .output, .error, ...
+orders.cancel("order-42")
+```
+
+| | |
+| --- | --- |
+| `workflow.Client(cls)` | Instances of the workflow class `cls` |
+| `start(id, input=b"")` | Records the start (the instance runs in its own event, right after); returns its `Status` |
+| `status(id)`, `cancel(id)` | The instance's `Status`; `cancel` stops it (a finished one is unchanged) |
+| `send_event(id, name, payload=b"")` | Delivers an event, recorded durably |
+| `Status` | `state` (`"running"`, `"waiting"`, `"completed"`, `"failed"`, `"cancelled"`), `wake_at`, `waiting_for`, `output`, `error`, `positions`, `is_finished` |
+
+Failures raise `workflow.WorkflowError` (`.kind`: unknown, finished, call,
+refused with `.status`). The [guide](https://github.com/WasmKeep/wasmkeep/blob/v0.2.0/docs/workflows.md#python) covers
+the semantics.
+
+## From a clone
+
+The [examples](https://github.com/WasmKeep/wasmkeep/tree/v0.2.0/examples) build
+against the SDK in the repository, with the same command
+(`examples/py-counter/build.sh`): [counter](https://github.com/WasmKeep/wasmkeep/tree/v0.2.0/examples/py-counter),
+[chat room](https://github.com/WasmKeep/wasmkeep/tree/v0.2.0/examples/py-chat-room),
+[jobs](https://github.com/WasmKeep/wasmkeep/tree/v0.2.0/examples/py-jobs)
+(key-value, queues and workflow orders). The protocol code
+(`wasmkeep/wire.py`) imports no host bindings, so the SDK's unit tests run
+under plain CPython, without componentize-py:
+
+```bash
+sdks/python/test/run.sh          # python3 -m unittest discover -s test
+```
+
+Python components are large (about 19 MB, CPython included) and slower than
+Rust: see [languages](https://github.com/WasmKeep/wasmkeep/blob/v0.2.0/docs/languages.md).
+
+## License
+
+Apache-2.0; see `LICENSE` and `NOTICE` in the package.

wasmkeep-0.2.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+wasmkeep/__init__.py,sha256=6GKfXDioyVSQ5mEof3Lr_1tCBst6Ri5AenQgLeMAakk,16310
+wasmkeep/__main__.py,sha256=dz6l80XzZXSAGO5tVQEPA9ce42d3k-wRjGyVz1ZyNBE,4152
+wasmkeep/_call.py,sha256=n90WoNMtRKzaCiRsegyBMgi8xG19DUfJeDnjhXCi9Os,1304
+wasmkeep/kv.py,sha256=F9iuHhmdsSOZBH0VQSsHZCUe457ZLxMN0KragL7RSC0,9764
+wasmkeep/queue.py,sha256=C09mo5lxyqPKVQ3VZms2c5iij1Id3l7rEhgbk4ulaYg,7901
+wasmkeep/wire.py,sha256=C52YnKqu3ZmqZxp4tUgIeXukXoeDhu7j0g_NL7NFY9E,17049
+wasmkeep/workflow.py,sha256=ekUaWzdKJ2kjRDGkMLOqyUdM2BdqCS_BPqRlNWVyH5Y,4370
+wasmkeep/wit/actor.wit,sha256=saSp5z39e7ZGT59puv3PKha8bLefu2ywTzhQRqmE4h8,11509
+wasmkeep/wit/deps/cli.wit,sha256=-2rF0j_K89IxFCo8L5ux6bwf5a9vHzKfaxpVVc4NOHM,6843
+wasmkeep/wit/deps/clocks.wit,sha256=btiqZbuMviJKCyy6yfwbO9Jb2xftpa4NI8mD7THER8w,5867
+wasmkeep/wit/deps/filesystem.wit,sha256=5nXyYQF7-bT6ffW5cBAj_gJJ7ecQIawb-Xh0jmLtzag,24592
+wasmkeep/wit/deps/http.wit,sha256=S71Y9QlwCmY3OFYR8YPFvVmE2B_u-F4p39wF69KDBFo,31611
+wasmkeep/wit/deps/io.wit,sha256=luIG0AB2-gSA3zLFvPJVo_pIYoBawva4U3p4HM5U9DM,13648
+wasmkeep/wit/deps/random.wit,sha256=SFeMQCE9XKtmUJgJBfoUagvow5xEM-5efgBje4fb4I8,3349
+wasmkeep/wit/deps/sockets.wit,sha256=rTjb87C73zTA8rYI7cv-4E1xtEOmP6_x9eAFPD-Es3c,46200
+wasmkeep-0.2.0.dist-info/METADATA,sha256=Fsd8-4aP_Z3Q0Xuf-SWrJBSE3fXXKTB57QRJkEQgAs4,11745
+wasmkeep-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+wasmkeep-0.2.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+wasmkeep-0.2.0.dist-info/licenses/NOTICE,sha256=oNnACLobuPOpDwv1QIi8kB_TIJwn8f_OrqDMqkCNk0o,632
+wasmkeep-0.2.0.dist-info/RECORD,,

wasmkeep-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

wasmkeep-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

wasmkeep-0.2.0.dist-info/licenses/NOTICE

@@ -0,0 +1,14 @@
+WasmKeep Python SDK
+Copyright 2026 Julien Turbide
+
+This product is licensed under the Apache License, Version 2.0 (see LICENSE).
+
+The WASI interface files in wasmkeep/wit/deps/ (copied from
+crates/wasmkeep-wit/wit/deps/ in the WasmKeep repository) are Copyright the
+Contributors to the WASI Specification, published by the WebAssembly
+Community Group under the W3C Community Contributor License Agreement.
+
+The SDK is built into a component with componentize-py, installed as a
+separate package under its own license. A component built with it embeds
+CPython and componentize-py's runtime, whose notices travel with that
+component.