a2al 0.1.0__tar.gz

a2al-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: a2al
+Version: 0.1.0
+Summary: Python client for a2al: spawn a2ald and call its REST API
+Author: A2AL Authors
+License: MPL-2.0
+Project-URL: Homepage, https://github.com/a2al/a2al
+Project-URL: Repository, https://github.com/a2al/a2al
+Project-URL: Bug Tracker, https://github.com/a2al/a2al/issues
+Keywords: a2al,a2a,agent,ai,sidecar
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Programming Language :: Python :: 3
+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: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# a2al (Python)
+
+Python client for [a2al](https://github.com/a2al/a2al): spawns a local `a2ald` daemon and exposes a typed REST client for its API.
+
+## Installation
+
+```sh
+pip install a2al
+```
+
+Pre-built `a2ald` binaries are bundled inside platform wheels for:
+
+| Platform | Architecture |
+|----------|-------------|
+| Linux    | x86_64, arm64 |
+| macOS    | x86_64, arm64 |
+| Windows  | x86_64 |
+
+On unsupported platforms, install `a2ald` manually and ensure it is on `PATH`, or set `A2ALD_PATH` to the executable path.
+
+## Usage
+
+```python
+from a2al import Daemon, Client
+
+with Daemon() as d:
+    c = Client(d.api_base, token=d.api_token)
+    print(c.health())
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `A2ALD_PATH` | Override path to the `a2ald` executable |
+| `A2AL_API_TOKEN` | Bearer token when the daemon enforces auth |
+
+## Requirements
+
+- Python 3.10+
+- No third-party dependencies (standard library only)

a2al-0.1.0/README.md

@@ -0,0 +1,41 @@
+# a2al (Python)
+
+Python client for [a2al](https://github.com/a2al/a2al): spawns a local `a2ald` daemon and exposes a typed REST client for its API.
+
+## Installation
+
+```sh
+pip install a2al
+```
+
+Pre-built `a2ald` binaries are bundled inside platform wheels for:
+
+| Platform | Architecture |
+|----------|-------------|
+| Linux    | x86_64, arm64 |
+| macOS    | x86_64, arm64 |
+| Windows  | x86_64 |
+
+On unsupported platforms, install `a2ald` manually and ensure it is on `PATH`, or set `A2ALD_PATH` to the executable path.
+
+## Usage
+
+```python
+from a2al import Daemon, Client
+
+with Daemon() as d:
+    c = Client(d.api_base, token=d.api_token)
+    print(c.health())
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `A2ALD_PATH` | Override path to the `a2ald` executable |
+| `A2AL_API_TOKEN` | Bearer token when the daemon enforces auth |
+
+## Requirements
+
+- Python 3.10+
+- No third-party dependencies (standard library only)

a2al-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "a2al"
+version = "0.1.0"
+description = "Python client for a2al: spawn a2ald and call its REST API"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MPL-2.0" }
+authors = [{ name = "A2AL Authors" }]
+keywords = ["a2al", "a2a", "agent", "ai", "sidecar"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Operating System :: OS Independent",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://github.com/a2al/a2al"
+Repository = "https://github.com/a2al/a2al"
+"Bug Tracker" = "https://github.com/a2al/a2al/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+a2al = ["bin/*"]

a2al-0.1.0/setup.cfg

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

a2al-0.1.0/src/a2al/__init__.py

@@ -0,0 +1,5 @@
+"""A2AL Python sidecar for the a2ald daemon."""
+
+from ._sidecar import Client, Daemon
+
+__all__ = ["Client", "Daemon"]

a2al-0.1.0/src/a2al/_sidecar.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import atexit
+import json
+import os
+import shutil
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any, Mapping, Optional
+
+
+def _find_exe() -> str:
+    exe = "a2ald.exe" if sys.platform == "win32" else "a2ald"
+    embedded = Path(__file__).parent / "bin" / exe
+    if embedded.is_file() and os.access(str(embedded), os.X_OK):
+        return str(embedded)
+    return exe
+
+
+def _free_port() -> int:
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind(("127.0.0.1", 0))
+    _host, port = s.getsockname()
+    s.close()
+    return int(port)
+
+
+class Daemon:
+    """Runs a2ald with a temp data dir and dynamic API port.
+
+    Usage (recommended — ensures cleanup on exit)::
+
+        with Daemon() as d:
+            c = Client(d.api_base, token=d.api_token)
+            ...
+
+    Alternatively call ``start()`` / ``close()`` explicitly, or rely on the
+    ``atexit`` handler registered by ``start()`` as a fallback.
+
+    Note: ``_free_port`` binds and releases a port before passing it to a2ald,
+    so a brief race window exists. In practice this is benign for local loopback.
+    """
+
+    def __init__(
+        self,
+        a2ald_exe: Optional[str] = None,
+        api_token: Optional[str] = None,
+        extra_args: Optional[list[str]] = None,
+    ) -> None:
+        self._exe = a2ald_exe or os.environ.get("A2ALD_PATH") or _find_exe()
+        self._api_token = api_token if api_token is not None else os.environ.get("A2AL_API_TOKEN")
+        self._extra = extra_args or []
+        self._proc: Optional[subprocess.Popen[bytes]] = None
+        self._dd: Optional[str] = None
+        self.api_base: Optional[str] = None
+
+    @property
+    def api_token(self) -> Optional[str]:
+        return self._api_token
+
+    def start(self, timeout: float = 45.0) -> None:
+        if self._proc is not None:
+            return
+        self._dd = tempfile.mkdtemp(prefix="a2al-")
+        port = _free_port()
+        self.api_base = f"http://127.0.0.1:{port}"
+        args = [
+            self._exe,
+            "--data-dir",
+            self._dd,
+            "--api-addr",
+            f"127.0.0.1:{port}",
+            *self._extra,
+        ]
+        env = os.environ.copy()
+        if self._api_token:
+            env["A2AL_API_TOKEN"] = self._api_token
+        self._proc = subprocess.Popen(
+            args,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            stdin=subprocess.DEVNULL,
+            env=env,
+        )
+        atexit.register(self.close)
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if self._proc.poll() is not None:
+                raise RuntimeError("a2ald exited during startup")
+            try:
+                urllib.request.urlopen(self.api_base + "/health", timeout=1.0)
+                return
+            except (urllib.error.URLError, OSError):
+                time.sleep(0.15)
+        raise TimeoutError("a2ald /health not ready")
+
+    def close(self) -> None:
+        if self._proc is not None:
+            self._proc.terminate()
+            try:
+                self._proc.wait(timeout=8)
+            except subprocess.TimeoutExpired:
+                self._proc.kill()
+            self._proc = None
+        if self._dd:
+            shutil.rmtree(self._dd, ignore_errors=True)
+            self._dd = None
+        self.api_base = None
+
+    def __enter__(self) -> Daemon:
+        self.start()
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+
+class Client:
+    """JSON REST client for a2ald (localhost)."""
+
+    def __init__(self, base_url: str, token: Optional[str] = None) -> None:
+        self.base = base_url.rstrip("/")
+        self.token = token
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: Optional[Mapping[str, Any]] = None,
+        timeout: float = 120.0,
+    ) -> Any:
+        data = None
+        headers: dict[str, str] = {"Content-Type": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+        req = urllib.request.Request(
+            self.base + path, data=data, headers=headers, method=method
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                raw = resp.read().decode("utf-8")
+                if not raw:
+                    return None
+                return json.loads(raw)
+        except urllib.error.HTTPError as exc:
+            body_bytes = exc.read()
+            try:
+                err_body = json.loads(body_bytes)
+                msg = err_body.get("error") or str(err_body)
+            except Exception:
+                msg = body_bytes.decode("utf-8", errors="replace")[:300]
+            raise RuntimeError(f"HTTP {exc.code}: {msg}") from exc
+
+    def health(self) -> Any:
+        return self._request("GET", "/health", None)
+
+    def config_get(self) -> Any:
+        return self._request("GET", "/config", None)
+
+    def agents_list(self) -> Any:
+        return self._request("GET", "/agents", None)
+
+    def identity_generate(self) -> Any:
+        return self._request("POST", "/identity/generate", {})
+
+    def agent_register(self, payload: Mapping[str, Any]) -> Any:
+        return self._request("POST", "/agents", dict(payload))
+
+    def agent_publish(self, aid: str) -> Any:
+        return self._request("POST", f"/agents/{aid}/publish", {})
+
+    def resolve(self, aid: str) -> Any:
+        return self._request("POST", f"/resolve/{aid}", {})
+
+    def connect(self, aid: str, local_aid: str = "") -> Any:
+        body: dict[str, str] = {}
+        if local_aid:
+            body["local_aid"] = local_aid
+        return self._request("POST", f"/connect/{aid}", body)

a2al-0.1.0/src/a2al.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: a2al
+Version: 0.1.0
+Summary: Python client for a2al: spawn a2ald and call its REST API
+Author: A2AL Authors
+License: MPL-2.0
+Project-URL: Homepage, https://github.com/a2al/a2al
+Project-URL: Repository, https://github.com/a2al/a2al
+Project-URL: Bug Tracker, https://github.com/a2al/a2al/issues
+Keywords: a2al,a2a,agent,ai,sidecar
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Programming Language :: Python :: 3
+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: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# a2al (Python)
+
+Python client for [a2al](https://github.com/a2al/a2al): spawns a local `a2ald` daemon and exposes a typed REST client for its API.
+
+## Installation
+
+```sh
+pip install a2al
+```
+
+Pre-built `a2ald` binaries are bundled inside platform wheels for:
+
+| Platform | Architecture |
+|----------|-------------|
+| Linux    | x86_64, arm64 |
+| macOS    | x86_64, arm64 |
+| Windows  | x86_64 |
+
+On unsupported platforms, install `a2ald` manually and ensure it is on `PATH`, or set `A2ALD_PATH` to the executable path.
+
+## Usage
+
+```python
+from a2al import Daemon, Client
+
+with Daemon() as d:
+    c = Client(d.api_base, token=d.api_token)
+    print(c.health())
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `A2ALD_PATH` | Override path to the `a2ald` executable |
+| `A2AL_API_TOKEN` | Bearer token when the daemon enforces auth |
+
+## Requirements
+
+- Python 3.10+
+- No third-party dependencies (standard library only)

a2al-0.1.0/src/a2al.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+src/a2al/__init__.py
+src/a2al/_sidecar.py
+src/a2al.egg-info/PKG-INFO
+src/a2al.egg-info/SOURCES.txt
+src/a2al.egg-info/dependency_links.txt
+src/a2al.egg-info/top_level.txt

a2al-0.1.0/src/a2al.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

a2al-0.1.0/src/a2al.egg-info/top_level.txt

@@ -0,0 +1 @@
+a2al