ainize 0.1.0__tar.gz

ainize-0.1.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: ainize
+Version: 0.1.0
+Summary: Call an Ainize node with ordinary OpenAI code; pay for throughput by staking AIN
+License: MIT
+Project-URL: Homepage, https://github.com/ainblockchain/ainize
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.40
+Requires-Dist: eth-account>=0.13
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+
+# ainize (Python)
+
+Call an Ainize node with the OpenAI code you already have.
+
+```python
+import ainize
+
+client = ainize.connect("https://node.example", private_key="0x…")
+
+client.chat.completions.create(
+    model="qwen3.8-flash-next",
+    messages=[{"role": "user", "content": "hello"}],
+)
+```
+
+`connect()` signs one challenge to prove your address, and returns a real `openai.OpenAI` with `base_url` and
+`api_key` already set. Everything after that line is OpenAI's — its methods, its parameters, its exceptions.
+
+Already hold a key? `ainize.connect(url, api_key="ainize-sk-…")` skips the signing.
+
+## What you pay with
+
+A deposit, not a per-token charge. Send AIN or sAIN to the node; the operator holds it staked, and your share of
+the node's throughput is your share of what everyone asking at that moment has deposited. An idle deposit costs
+nobody anything, and the principal is not consumed.
+
+```python
+ainize.deposit_address("https://node.example")          # where to send
+ainize.await_deposit(url, tx_hash, api_key=client.api_key)   # wait until the node has credited it
+```
+
+The library never signs a transfer. It tells you where to send and waits for the node to notice; moving funds
+stays with the wallet you already trust.
+
+## Tests
+
+They drive a real node and a stub model — mocking the transport would test our idea of the node's replies rather
+than the node's replies, and the shapes are exactly where compatibility breaks. Run them from this directory, so
+the package on disk is the one imported:
+
+```bash
+python -m venv .venv && .venv/bin/pip install openai eth-account httpx pytest
+.venv/bin/python -m pytest
+```

ainize-0.1.0/README.md

@@ -0,0 +1,44 @@
+# ainize (Python)
+
+Call an Ainize node with the OpenAI code you already have.
+
+```python
+import ainize
+
+client = ainize.connect("https://node.example", private_key="0x…")
+
+client.chat.completions.create(
+    model="qwen3.8-flash-next",
+    messages=[{"role": "user", "content": "hello"}],
+)
+```
+
+`connect()` signs one challenge to prove your address, and returns a real `openai.OpenAI` with `base_url` and
+`api_key` already set. Everything after that line is OpenAI's — its methods, its parameters, its exceptions.
+
+Already hold a key? `ainize.connect(url, api_key="ainize-sk-…")` skips the signing.
+
+## What you pay with
+
+A deposit, not a per-token charge. Send AIN or sAIN to the node; the operator holds it staked, and your share of
+the node's throughput is your share of what everyone asking at that moment has deposited. An idle deposit costs
+nobody anything, and the principal is not consumed.
+
+```python
+ainize.deposit_address("https://node.example")          # where to send
+ainize.await_deposit(url, tx_hash, api_key=client.api_key)   # wait until the node has credited it
+```
+
+The library never signs a transfer. It tells you where to send and waits for the node to notice; moving funds
+stays with the wallet you already trust.
+
+## Tests
+
+They drive a real node and a stub model — mocking the transport would test our idea of the node's replies rather
+than the node's replies, and the shapes are exactly where compatibility breaks. Run them from this directory, so
+the package on disk is the one imported:
+
+```bash
+python -m venv .venv && .venv/bin/pip install openai eth-account httpx pytest
+.venv/bin/python -m pytest
+```

ainize-0.1.0/ainize/__init__.py

@@ -0,0 +1,15 @@
+"""Call an Ainize node with the OpenAI code you already have.
+
+    import ainize
+
+    client = ainize.connect("https://node.example", private_key=...)
+    client.chat.completions.create(model="qwen3.8-flash-next", messages=[...])
+
+`connect()` returns a real `openai.OpenAI`. What you pay with is a deposit: send AIN or sAIN to the node and your
+share of its throughput is your share of what everyone asking at that moment has deposited.
+"""
+
+from ._connect import await_deposit, connect, deposit_address
+
+__all__ = ["connect", "deposit_address", "await_deposit"]
+__version__ = "0.1.0"

ainize-0.1.0/ainize/_connect.py

@@ -0,0 +1,114 @@
+"""Point OpenAI at an Ainize node.
+
+This library does one thing on top of `openai`: it proves which address is calling and gets a key back. It does
+not wrap the client, subclass it, or re-export a narrowed version of it — it returns the real `openai.OpenAI`,
+because the whole promise is that nothing after that line is different. A wrapper would have to grow a method
+every time OpenAI's client does, and would be a second place for bugs to live.
+
+It also never signs a transfer. `deposit_address()` says where to send AIN and `await_deposit()` waits for the
+node to notice; moving funds stays with the wallet the person already trusts. A library that signs transfers is a
+much larger thing to hand your private key to than one that signs a login, and the difference is not something a
+caller can see from the import line.
+"""
+
+from __future__ import annotations
+
+import time
+
+import httpx
+import openai
+from eth_account import Account
+from eth_account.messages import encode_defunct
+
+__all__ = ["connect", "deposit_address", "await_deposit"]
+
+_DEFAULT_TIMEOUT = 30.0
+
+
+def connect(
+    node_url: str,
+    *,
+    private_key: str | None = None,
+    api_key: str | None = None,
+    timeout: float = _DEFAULT_TIMEOUT,
+) -> openai.OpenAI:
+    """Return an `openai.OpenAI` pointed at `node_url`, signing in if it has to.
+
+    Pass `private_key` to sign in and be issued a key, or `api_key` to reuse one you already hold. The returned
+    client is the genuine article: every call, parameter and exception is OpenAI's.
+    """
+    node_url = node_url.rstrip("/")
+    if api_key is None:
+        if private_key is None:
+            raise ValueError(
+                "connect() needs either private_key (to sign in and be issued one) or api_key (one you already hold)"
+            )
+        api_key = _sign_in(node_url, private_key, timeout=timeout)
+    return openai.OpenAI(base_url=f"{node_url}/v1", api_key=api_key)
+
+
+def _sign_in(node_url: str, private_key: str, *, timeout: float) -> str:
+    """Prove the address once and leave with a key.
+
+    The message signed is the one the node issued, verbatim — it is not rebuilt here. A rebuilt message is a
+    message the client had a hand in, and the node verifies against the bytes it handed out.
+    """
+    account = Account.from_key(private_key)
+    with httpx.Client(timeout=timeout) as http:
+        challenge = http.post(
+            f"{node_url}/v1/auth/nonce",
+            json={"address": account.address, "scheme": "eip191"},
+        )
+        challenge.raise_for_status()
+        issued_challenge = challenge.json()
+
+        signature = account.sign_message(
+            encode_defunct(text=issued_challenge["message"])
+        ).signature.hex()
+        if not signature.startswith("0x"):
+            signature = f"0x{signature}"
+
+        token = http.post(
+            f"{node_url}/v1/auth/token",
+            json={"nonce": issued_challenge["nonce"], "signature": signature},
+        )
+        token.raise_for_status()
+        return token.json()["api_key"]
+
+
+def deposit_address(node_url: str, *, timeout: float = _DEFAULT_TIMEOUT) -> str:
+    """Where to send AIN or sAIN to buy a share of this node's throughput."""
+    with httpx.Client(timeout=timeout) as http:
+        response = http.get(f"{node_url.rstrip('/')}/v1/account/deposit-address")
+        response.raise_for_status()
+        return response.json()["address"]
+
+
+def await_deposit(
+    node_url: str,
+    tx_hash: str,
+    *,
+    api_key: str,
+    timeout: float = 600.0,
+    poll_seconds: float = 5.0,
+) -> dict:
+    """Block until the node has credited `tx_hash`.
+
+    The node is the authority on when a transfer counts: it waits for its own confirmation depth before crediting,
+    so a transaction that a block explorer already shows is not yet a share here. Polling is honest about that;
+    guessing from the chain would not be.
+    """
+    deadline = time.monotonic() + timeout
+    headers = {"authorization": f"Bearer {api_key}"}
+    with httpx.Client(timeout=_DEFAULT_TIMEOUT) as http:
+        while True:
+            response = http.get(
+                f"{node_url.rstrip('/')}/v1/account/deposits/{tx_hash}", headers=headers
+            )
+            response.raise_for_status()
+            seen = response.json()
+            if seen.get("credited"):
+                return seen
+            if time.monotonic() > deadline:
+                raise TimeoutError(f"{tx_hash} was not credited within {timeout}s")
+            time.sleep(poll_seconds)

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

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: ainize
+Version: 0.1.0
+Summary: Call an Ainize node with ordinary OpenAI code; pay for throughput by staking AIN
+License: MIT
+Project-URL: Homepage, https://github.com/ainblockchain/ainize
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.40
+Requires-Dist: eth-account>=0.13
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+
+# ainize (Python)
+
+Call an Ainize node with the OpenAI code you already have.
+
+```python
+import ainize
+
+client = ainize.connect("https://node.example", private_key="0x…")
+
+client.chat.completions.create(
+    model="qwen3.8-flash-next",
+    messages=[{"role": "user", "content": "hello"}],
+)
+```
+
+`connect()` signs one challenge to prove your address, and returns a real `openai.OpenAI` with `base_url` and
+`api_key` already set. Everything after that line is OpenAI's — its methods, its parameters, its exceptions.
+
+Already hold a key? `ainize.connect(url, api_key="ainize-sk-…")` skips the signing.
+
+## What you pay with
+
+A deposit, not a per-token charge. Send AIN or sAIN to the node; the operator holds it staked, and your share of
+the node's throughput is your share of what everyone asking at that moment has deposited. An idle deposit costs
+nobody anything, and the principal is not consumed.
+
+```python
+ainize.deposit_address("https://node.example")          # where to send
+ainize.await_deposit(url, tx_hash, api_key=client.api_key)   # wait until the node has credited it
+```
+
+The library never signs a transfer. It tells you where to send and waits for the node to notice; moving funds
+stays with the wallet you already trust.
+
+## Tests
+
+They drive a real node and a stub model — mocking the transport would test our idea of the node's replies rather
+than the node's replies, and the shapes are exactly where compatibility breaks. Run them from this directory, so
+the package on disk is the one imported:
+
+```bash
+python -m venv .venv && .venv/bin/pip install openai eth-account httpx pytest
+.venv/bin/python -m pytest
+```

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

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+ainize/__init__.py
+ainize/_connect.py
+ainize.egg-info/PKG-INFO
+ainize.egg-info/SOURCES.txt
+ainize.egg-info/dependency_links.txt
+ainize.egg-info/requires.txt
+ainize.egg-info/top_level.txt
+tests/test_connect.py

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

@@ -0,0 +1 @@
+

ainize-0.1.0/ainize.egg-info/requires.txt

@@ -0,0 +1,6 @@
+openai>=1.40
+eth-account>=0.13
+httpx>=0.27
+
+[dev]
+pytest>=8

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

@@ -0,0 +1 @@
+ainize

ainize-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ainize"
+version = "0.1.0"
+description = "Call an Ainize node with ordinary OpenAI code; pay for throughput by staking AIN"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+dependencies = [
+    "openai>=1.40",
+    "eth-account>=0.13",
+    "httpx>=0.27",
+]
+
+[project.urls]
+Homepage = "https://github.com/ainblockchain/ainize"
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+
+[tool.setuptools.packages.find]
+include = ["ainize*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

ainize-0.1.0/setup.cfg

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

ainize-0.1.0/tests/test_connect.py

@@ -0,0 +1,77 @@
+"""What `import ainize` promises: after one line, it is just OpenAI.
+
+These run the genuine `openai` client against a real node. A mocked transport would test our idea of the node's
+replies rather than the node's replies, and the shapes are exactly where the promise breaks.
+
+    cd sdk/python && .venv/bin/python -m pytest
+"""
+
+from __future__ import annotations
+
+import openai
+import pytest
+
+import ainize
+
+
+def test_connect_returns_a_real_openai_client(node_url, wallet_key):
+    client = ainize.connect(node_url, private_key=wallet_key)
+    assert isinstance(client, openai.OpenAI)
+    assert str(client.base_url).rstrip("/").endswith("/v1")
+
+
+def test_an_existing_key_skips_signing(node_url, issued_key):
+    client = ainize.connect(node_url, api_key=issued_key)
+    assert client.api_key == issued_key
+
+
+def test_neither_key_nor_private_key_is_an_error_naming_both(node_url):
+    with pytest.raises(ValueError) as raised:
+        ainize.connect(node_url)
+    assert "private_key" in str(raised.value)
+    assert "api_key" in str(raised.value)
+
+
+def test_models_are_listed_through_the_stock_client(node_url, issued_key):
+    client = ainize.connect(node_url, api_key=issued_key)
+    assert "qwen3.8-flash-next" in [m.id for m in client.models.list().data]
+
+
+def test_chat_completion_round_trips(node_url, issued_key):
+    client = ainize.connect(node_url, api_key=issued_key)
+    out = client.chat.completions.create(
+        model="qwen3.8-flash-next", messages=[{"role": "user", "content": "ping"}]
+    )
+    assert out.choices[0].message.content == "pong"
+    assert out.id.startswith("chatcmpl-")
+    assert out.choices[0].finish_reason == "stop"
+
+
+def test_streaming_yields_chunks(node_url, issued_key):
+    client = ainize.connect(node_url, api_key=issued_key)
+    chunks = list(
+        client.chat.completions.create(
+            model="qwen3.8-flash-next",
+            messages=[{"role": "user", "content": "ping"}],
+            stream=True,
+        )
+    )
+    assert chunks, "the stream ended without a single chunk"
+    assert chunks[0].object == "chat.completion.chunk"
+    assert "".join(c.choices[0].delta.content or "" for c in chunks) == "pong"
+
+
+def test_a_bad_key_raises_openais_own_error_type(node_url):
+    client = ainize.connect(node_url, api_key="ainize-sk-not-a-real-key")
+    with pytest.raises(openai.AuthenticationError):
+        client.chat.completions.create(
+            model="qwen3.8-flash-next", messages=[{"role": "user", "content": "ping"}]
+        )
+
+
+def test_an_unknown_model_raises_not_found(node_url, issued_key):
+    client = ainize.connect(node_url, api_key=issued_key)
+    with pytest.raises(openai.NotFoundError):
+        client.chat.completions.create(
+            model="gpt-4", messages=[{"role": "user", "content": "ping"}]
+        )