algovoi-keystone-httpx 0.1.1__tar.gz

algovoi_keystone_httpx-0.1.1/NOTICE

@@ -0,0 +1,8 @@
+algovoi-keystone-httpx
+Copyright 2026 AlgoVoi
+
+This product includes software developed by AlgoVoi.
+Licensed under the Apache License, Version 2.0.
+
+Built on the AlgoVoi substrate: RFC 8785 (JCS) canonicalisation + SHA-256,
+producing content-addressed execution_ref evidence recomputable offline.

algovoi_keystone_httpx-0.1.1/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: algovoi-keystone-httpx
+Version: 0.1.1
+Summary: Bind outbound HTTP calls to the AlgoVoi keystone -- wrap any httpx.Client or requests.Session and every POST / PUT / PATCH / DELETE gets a content-addressed execution_ref (keystone-only edition, Apache-2.0)
+Author-email: AlgoVoi <chopmob@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://docs.algovoi.co.uk/keystone-connectors
+Project-URL: Documentation, https://docs.algovoi.co.uk/keystone-connectors
+Project-URL: Repository, https://github.com/chopmob-cloud/AlgoVoi-Keystone-Connectors
+Project-URL: Issues, https://github.com/chopmob-cloud/AlgoVoi-Keystone-Connectors/issues
+Keywords: http,httpx,requests,outbound,webhook,client,keystone,execution_ref,jcs,rfc8785,algovoi
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: NOTICE
+Requires-Dist: algovoi-execution-ref>=0.1.0
+Dynamic: license-file
+
+# algovoi-keystone-httpx
+
+Bind **outbound** HTTP calls to the AlgoVoi keystone. The `asgi` connector binds the requests a
+service *receives*; this one binds the calls a service *makes*. Wrap any sync `httpx.Client` or
+`requests.Session` and every state-changing call (POST / PUT / PATCH / DELETE) is bound to the
+`decision_ref` that authorised it, emitting a content-addressed `execution_ref` any party can
+recompute offline:
+
+```
+execution_ref = "sha256:" + SHA-256(JCS({ decision_ref, action_type, scope, outcome, executed_at_ms }))
+```
+
+`action_type` is `http:<method>`; `scope` is the destination `host/path` (query string dropped for
+stability). Outcome comes from the response status: 2xx/3xx COMMITTED, 4xx SKIPPED, 5xx/exception
+FAILED. Reads (GET / HEAD / OPTIONS) pass through unbound. No httpx or requests dependency.
+
+```python
+from algovoi_keystone_httpx import keystone_http_client
+
+client = keystone_http_client(httpx.Client(), decision_ref=decision_ref)
+client.post("https://api.partner.com/v1/pay", json=payload)   # bound
+ref = client.execution_ref
+```
+
+Records emitted on `client.executions` drop straight into `algovoi-keystone-validate`.
+
+Keystone-only edition, Apache-2.0. Built on the AlgoVoi substrate (RFC 8785 JCS + SHA-256).

algovoi_keystone_httpx-0.1.1/README.md

@@ -0,0 +1,27 @@
+# algovoi-keystone-httpx
+
+Bind **outbound** HTTP calls to the AlgoVoi keystone. The `asgi` connector binds the requests a
+service *receives*; this one binds the calls a service *makes*. Wrap any sync `httpx.Client` or
+`requests.Session` and every state-changing call (POST / PUT / PATCH / DELETE) is bound to the
+`decision_ref` that authorised it, emitting a content-addressed `execution_ref` any party can
+recompute offline:
+
+```
+execution_ref = "sha256:" + SHA-256(JCS({ decision_ref, action_type, scope, outcome, executed_at_ms }))
+```
+
+`action_type` is `http:<method>`; `scope` is the destination `host/path` (query string dropped for
+stability). Outcome comes from the response status: 2xx/3xx COMMITTED, 4xx SKIPPED, 5xx/exception
+FAILED. Reads (GET / HEAD / OPTIONS) pass through unbound. No httpx or requests dependency.
+
+```python
+from algovoi_keystone_httpx import keystone_http_client
+
+client = keystone_http_client(httpx.Client(), decision_ref=decision_ref)
+client.post("https://api.partner.com/v1/pay", json=payload)   # bound
+ref = client.execution_ref
+```
+
+Records emitted on `client.executions` drop straight into `algovoi-keystone-validate`.
+
+Keystone-only edition, Apache-2.0. Built on the AlgoVoi substrate (RFC 8785 JCS + SHA-256).

algovoi_keystone_httpx-0.1.1/algovoi_keystone_httpx/__init__.py

@@ -0,0 +1,23 @@
+"""algovoi-keystone-httpx -- bind outbound HTTP calls to the AlgoVoi keystone (httpx / requests)."""
+from .adapter import (
+    EXECUTION_OUTCOMES,
+    KeystoneHTTPClient,
+    KeystoneHTTPError,
+    WRITE_METHODS,
+    keystone_http_client,
+    outcome_for_status,
+    request_execution_ref,
+    tamper_detected,
+)
+
+__all__ = [
+    "EXECUTION_OUTCOMES",
+    "KeystoneHTTPClient",
+    "KeystoneHTTPError",
+    "WRITE_METHODS",
+    "keystone_http_client",
+    "outcome_for_status",
+    "request_execution_ref",
+    "tamper_detected",
+]
+__version__ = "0.1.0"

algovoi_keystone_httpx-0.1.1/algovoi_keystone_httpx.egg-info/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: algovoi-keystone-httpx
+Version: 0.1.1
+Summary: Bind outbound HTTP calls to the AlgoVoi keystone -- wrap any httpx.Client or requests.Session and every POST / PUT / PATCH / DELETE gets a content-addressed execution_ref (keystone-only edition, Apache-2.0)
+Author-email: AlgoVoi <chopmob@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://docs.algovoi.co.uk/keystone-connectors
+Project-URL: Documentation, https://docs.algovoi.co.uk/keystone-connectors
+Project-URL: Repository, https://github.com/chopmob-cloud/AlgoVoi-Keystone-Connectors
+Project-URL: Issues, https://github.com/chopmob-cloud/AlgoVoi-Keystone-Connectors/issues
+Keywords: http,httpx,requests,outbound,webhook,client,keystone,execution_ref,jcs,rfc8785,algovoi
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: NOTICE
+Requires-Dist: algovoi-execution-ref>=0.1.0
+Dynamic: license-file
+
+# algovoi-keystone-httpx
+
+Bind **outbound** HTTP calls to the AlgoVoi keystone. The `asgi` connector binds the requests a
+service *receives*; this one binds the calls a service *makes*. Wrap any sync `httpx.Client` or
+`requests.Session` and every state-changing call (POST / PUT / PATCH / DELETE) is bound to the
+`decision_ref` that authorised it, emitting a content-addressed `execution_ref` any party can
+recompute offline:
+
+```
+execution_ref = "sha256:" + SHA-256(JCS({ decision_ref, action_type, scope, outcome, executed_at_ms }))
+```
+
+`action_type` is `http:<method>`; `scope` is the destination `host/path` (query string dropped for
+stability). Outcome comes from the response status: 2xx/3xx COMMITTED, 4xx SKIPPED, 5xx/exception
+FAILED. Reads (GET / HEAD / OPTIONS) pass through unbound. No httpx or requests dependency.
+
+```python
+from algovoi_keystone_httpx import keystone_http_client
+
+client = keystone_http_client(httpx.Client(), decision_ref=decision_ref)
+client.post("https://api.partner.com/v1/pay", json=payload)   # bound
+ref = client.execution_ref
+```
+
+Records emitted on `client.executions` drop straight into `algovoi-keystone-validate`.
+
+Keystone-only edition, Apache-2.0. Built on the AlgoVoi substrate (RFC 8785 JCS + SHA-256).

algovoi_keystone_httpx-0.1.1/algovoi_keystone_httpx.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+NOTICE
+README.md
+pyproject.toml
+setup.py
+algovoi_keystone_httpx/__init__.py
+algovoi_keystone_httpx.egg-info/PKG-INFO
+algovoi_keystone_httpx.egg-info/SOURCES.txt
+algovoi_keystone_httpx.egg-info/dependency_links.txt
+algovoi_keystone_httpx.egg-info/requires.txt
+algovoi_keystone_httpx.egg-info/top_level.txt
+tests/test_keystone_httpx.py

algovoi_keystone_httpx-0.1.1/algovoi_keystone_httpx.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

algovoi_keystone_httpx-0.1.1/algovoi_keystone_httpx.egg-info/requires.txt

@@ -0,0 +1 @@
+algovoi-execution-ref>=0.1.0

algovoi_keystone_httpx-0.1.1/algovoi_keystone_httpx.egg-info/top_level.txt

@@ -0,0 +1 @@
+algovoi_keystone_httpx

algovoi_keystone_httpx-0.1.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=70", "Cython>=3.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "algovoi-keystone-httpx"
+version = "0.1.1"
+description = "Bind outbound HTTP calls to the AlgoVoi keystone -- wrap any httpx.Client or requests.Session and every POST / PUT / PATCH / DELETE gets a content-addressed execution_ref (keystone-only edition, Apache-2.0)"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+authors = [{ name = "AlgoVoi", email = "chopmob@gmail.com" }]
+keywords = ["http", "httpx", "requests", "outbound", "webhook", "client", "keystone", "execution_ref", "jcs", "rfc8785", "algovoi"]
+requires-python = ">=3.10"
+dependencies = ["algovoi-execution-ref>=0.1.0"]
+classifiers = [
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP",
+]
+
+[project.urls]
+Homepage = "https://docs.algovoi.co.uk/keystone-connectors"
+Documentation = "https://docs.algovoi.co.uk/keystone-connectors"
+Repository = "https://github.com/chopmob-cloud/AlgoVoi-Keystone-Connectors"
+Issues = "https://github.com/chopmob-cloud/AlgoVoi-Keystone-Connectors/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["algovoi_keystone_httpx*"]
+
+[tool.setuptools.package-data]
+"algovoi_keystone_httpx" = ["*.so", "*.pyd"]
+
+[tool.setuptools.exclude-package-data]
+"algovoi_keystone_httpx" = ["*.c", "*.pyx", "*.pxd"]

algovoi_keystone_httpx-0.1.1/setup.cfg

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

algovoi_keystone_httpx-0.1.1/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+from Cython.Build import cythonize
+setup(ext_modules=cythonize("algovoi_keystone_httpx/adapter.pyx", build_dir="build", compiler_directives={"language_level": "3", "annotation_typing": False}))

algovoi_keystone_httpx-0.1.1/tests/test_keystone_httpx.py

@@ -0,0 +1,135 @@
+"""Tests for algovoi-keystone-httpx (keystone-only edition)."""
+import pytest
+from algovoi_execution_ref import execution_ref
+from algovoi_keystone_httpx import (
+    EXECUTION_OUTCOMES, KeystoneHTTPError, keystone_http_client, outcome_for_status,
+    request_execution_ref, tamper_detected,
+)
+
+DR = "sha256:" + "a" * 64
+TS = 1716460800000
+URL = "https://api.partner.com/v1/pay?token=secret"
+SCOPE = "api.partner.com/v1/pay"
+
+
+class Resp:
+    def __init__(self, status_code):
+        self.status_code = status_code
+
+
+class FakeClient:
+    """httpx.Client / requests.Session double. Returns a status set per URL; raises on 'boom'."""
+    def __init__(self):
+        self.calls = []
+
+    def post(self, url, *a, **k):
+        self.calls.append(("post", url))
+        if url == "boom":
+            raise RuntimeError("connection reset")
+        return Resp(201)
+
+    def put(self, url, *a, **k):
+        self.calls.append(("put", url))
+        return Resp(200)
+
+    def delete(self, url, *a, **k):
+        self.calls.append(("delete", url))
+        return Resp(404)
+
+    def get(self, url, *a, **k):
+        self.calls.append(("get", url))
+        return Resp(200)   # read path, must pass through unbound
+
+    def request(self, method, url, *a, **k):
+        self.calls.append(("request", method, url))
+        return Resp(200)
+
+
+def test_request_execution_ref_matches_primitive():
+    ref = request_execution_ref(decision_ref=DR, method="POST", url=URL, outcome="COMMITTED", executed_at_ms=TS)
+    assert ref == execution_ref(DR, "http:post", SCOPE, "COMMITTED", TS)
+    assert ref.startswith("sha256:") and len(ref) == 71
+
+
+def test_scope_drops_query():
+    a = request_execution_ref(decision_ref=DR, method="POST", url="https://h/p?x=1", outcome="COMMITTED", executed_at_ms=TS)
+    b = request_execution_ref(decision_ref=DR, method="POST", url="https://h/p?x=2", outcome="COMMITTED", executed_at_ms=TS)
+    assert a == b   # query string is not part of scope
+
+
+def test_outcome_for_status():
+    assert outcome_for_status(201) == "COMMITTED"
+    assert outcome_for_status(302) == "COMMITTED"
+    assert outcome_for_status(404) == "SKIPPED"
+    assert outcome_for_status(500) == "FAILED"
+    assert outcome_for_status(0) == "FAILED"
+
+
+def test_rejects_bad():
+    with pytest.raises(KeystoneHTTPError):
+        request_execution_ref(decision_ref=DR, method="POST", url=URL, outcome="DONE", executed_at_ms=TS)
+    with pytest.raises(KeystoneHTTPError):
+        request_execution_ref(decision_ref=DR, method="", url=URL, outcome="COMMITTED", executed_at_ms=TS)
+
+
+def test_post_binds_committed():
+    c = keystone_http_client(FakeClient(), decision_ref=DR, clock_ms=lambda: TS)
+    c.post(URL, json={})
+    assert c.execution_ref == execution_ref(DR, "http:post", SCOPE, "COMMITTED", TS)
+    assert c.executions[0]["outcome"] == "COMMITTED"
+
+
+def test_delete_4xx_is_skipped():
+    c = keystone_http_client(FakeClient(), decision_ref=DR, clock_ms=lambda: TS)
+    c.delete("https://api.partner.com/v1/pay")
+    assert c.execution_ref == execution_ref(DR, "http:delete", SCOPE, "SKIPPED", TS)
+
+
+def test_request_write_binds():
+    c = keystone_http_client(FakeClient(), decision_ref=DR, clock_ms=lambda: TS)
+    c.request("PUT", "https://api.partner.com/v1/pay")
+    assert c.execution_ref == execution_ref(DR, "http:put", SCOPE, "COMMITTED", TS)
+
+
+def test_request_read_passthrough_unbound():
+    c = keystone_http_client(FakeClient(), decision_ref=DR, clock_ms=lambda: TS)
+    r = c.request("GET", "https://api.partner.com/v1/pay")
+    assert r.status_code == 200
+    assert c.executions == []   # GET via request() is not bound
+
+
+def test_get_passthrough_unbound():
+    c = keystone_http_client(FakeClient(), decision_ref=DR, clock_ms=lambda: TS)
+    c.get("https://api.partner.com/v1/pay")
+    assert c.executions == []   # reads are not bound
+
+
+def test_failed_post_records_failed_and_reraises():
+    c = keystone_http_client(FakeClient(), decision_ref=DR, clock_ms=lambda: TS)
+    with pytest.raises(RuntimeError):
+        c.post("boom")
+    assert c.executions[-1]["outcome"] == "FAILED"
+    assert c.execution_ref == execution_ref(DR, "http:post", "boom", "FAILED", TS)
+
+
+def test_rejects_bad_decision():
+    with pytest.raises(KeystoneHTTPError):
+        keystone_http_client(FakeClient(), decision_ref="")
+
+
+def test_on_execution_callback():
+    seen = []
+    c = keystone_http_client(FakeClient(), decision_ref=DR, clock_ms=lambda: TS, on_execution=seen.append)
+    c.post(URL)
+    assert seen[0]["execution_ref"] == c.execution_ref
+
+
+def test_tamper_detected():
+    ref = request_execution_ref(decision_ref=DR, method="POST", url=URL, outcome="COMMITTED", executed_at_ms=TS)
+    assert not tamper_detected(ref, decision_ref=DR, method="POST", url=URL, outcome="COMMITTED", executed_at_ms=TS)
+    assert tamper_detected(ref, decision_ref=DR, method="POST", url="https://api.partner.com/v1/refund", outcome="COMMITTED", executed_at_ms=TS)
+    assert tamper_detected("not-a-ref", decision_ref=DR, method="POST", url=URL, outcome="COMMITTED", executed_at_ms=TS)
+
+
+def test_outcomes_constant():
+    assert EXECUTION_OUTCOMES == ("COMMITTED", "SKIPPED", "FAILED", "REVERSED")