biznet 0.1.0__tar.gz

biznet-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install package with dev dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest -q

biznet-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,45 @@
+name: Publish to PyPI
+
+# Publishes exactly what a version tag points at. Tests gate the upload:
+# a red suite means no release.
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install package with dev dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest -q
+
+      - name: Check tag matches package version
+        run: |
+          pkg_version=$(python -c "import biznet; print(biznet.__version__)")
+          tag_version="${GITHUB_REF_NAME#v}"
+          if [ "$pkg_version" != "$tag_version" ]; then
+            echo "Tag $GITHUB_REF_NAME does not match biznet.__version__ ($pkg_version)"
+            exit 1
+          fi
+
+      - name: Build sdist and wheel
+        run: |
+          pip install build twine
+          python -m build
+          twine check dist/*
+
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+        run: twine upload dist/*

biznet-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.env

biznet-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: biznet
+Version: 0.1.0
+Summary: Python SDK for the BizNetAI merchant API
+Author: ConsumerGenie Corporation
+License: Proprietary
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: fastapi>=0.110; extra == 'dev'
+Requires-Dist: mcp>=1.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# biznet
+
+Python SDK for the BizNetAI merchant API. Part of ConsumerGenie Corporation.
+
+## Install
+
+```bash
+pip install biznet
+```
+
+## Usage
+
+```python
+from biznet import BizNet
+
+client = BizNet(api_key="sk_live_...", base_url="https://<api-id>.execute-api.us-east-2.amazonaws.com")
+```
+
+Both values fall back to environment variables: `BIZNET_API_KEY` and `BIZNET_BASE_URL`.
+
+An async client is available as `AsyncBizNet` with the same constructor.
+
+Resources available now:
+
+```python
+client.users.me()          # GET  /v1/users/me
+client.users.status()      # GET  /v1/users/me/status
+client.users.deactivate()  # DELETE /v1/users/me
+
+client.keys.issue(env="test", scopes=[])  # POST /v1/keys, returns the secret once
+client.keys.list()                        # GET  /v1/keys
+client.keys.revoke(key_id)                # DELETE /v1/keys/{key_id}
+
+client.products.create(title, description, price)  # POST /v1/products -> Product
+client.products.get(product_id)                    # GET  /v1/products/{id} -> Product
+client.products.delete(product_id)                 # DELETE, soft delete
+job_id = client.products.bulk_create([{...}])      # POST /v1/products/bulk
+
+client.jobs.status(job_id)                # GET /v1/jobs/{id} -> Job
+client.jobs.wait(job_id, timeout=300)     # poll with backoff until done/failed
+
+client.adapters.connect("woocommerce", store_url=..., consumer_key=..., consumer_secret=...)
+job_id = client.adapters.sync("woocommerce")       # POST .../sync
+client.adapters.sync_status("woocommerce", job_id) # GET .../sync/status -> Job
+
+client.policies.upload("returns.md")      # multipart; path or (name, bytes)
+client.policies.list()                    # GET /v1/rag/policies
+client.policies.delete("returns.md")      # DELETE by filename
+```
+
+Chat, UCP, and deploy live on the Merchant-node service (Cloud Run), a separate
+host from the AWS API. Set `node_url` on the client or `BIZNET_NODE_URL`:
+
+```python
+client.chat.complete(session_id, message)        # POST {node}/chat-sync
+async for event in aclient.chat.stream(session_id, message):
+    ...                                          # typed SSE events
+
+client.ucp.configure(slug, business_name, stripe_account_id)
+client.ucp.status()
+
+client.deploy.shared()      # provision on shared infra (default)
+client.deploy.dedicated()   # dedicated Cloud Run services
+client.deploy.status()
+client.deploy.deprovision()
+```
+
+`biznet.resources.deploy.create_ucp_router(api_key)` returns a FastAPI router
+serving `GET /.well-known/ucp` on a merchant's own domain (requires fastapi).
+
+## MerchantNode
+
+Run an MCP server on your own infra. Override only what your system supports;
+the 8 operational tools ship with mock defaults, and the 4 UCP checkout tools
+call the BizNet UCP service (set `BIZNET_UCP_URL`). Requires the mcp extra:
+`pip install "biznet[mcp]"`.
+
+```python
+from biznet import MerchantNode
+
+class MyStore(MerchantNode):
+    async def get_stock_level(self, product_id: str) -> int:
+        return my_inventory.count(product_id)
+
+MyStore(api_key="sk_live_...").run()  # stdio; or run(transport="sse")
+```
+
+## CLI
+
+`biznetai deploy` finds the MerchantNode subclass in the current directory,
+packages it with requirements.txt, and provisions it on BizNet infrastructure:
+
+```bash
+export BIZNET_API_KEY=sk_live_...
+export BIZNET_NODE_URL=https://<merchant-node-host>
+biznetai deploy                 # shared infra (default)
+biznetai deploy --tier dedicated
+```
+
+It streams provisioning status and prints the service URLs when live.
+
+## Behavior
+
+- Every request carries `X-API-Key`. Set `client.api_key` to rotate the key in place.
+- Every request carries an `X-Request-Id` (uuid4). The same id is reused across
+  retries and echoed back by the server for tracing.
+- 429 and 5xx responses retry up to 3 attempts with jittered exponential backoff.
+- Non-2xx responses raise typed exceptions mapped from the API error envelope
+  `{code, message, request_id}`: `AuthError`, `NotFoundError`, `ValidationError`,
+  `RateLimitError`, `InternalError`.
+- SSE chat streams parse into typed `StreamEvent`s: `text`, `products`, `checkout`,
+  `tool_call`, `error`, `done`.
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```

biznet-0.1.0/README.md

@@ -0,0 +1,120 @@
+# biznet
+
+Python SDK for the BizNetAI merchant API. Part of ConsumerGenie Corporation.
+
+## Install
+
+```bash
+pip install biznet
+```
+
+## Usage
+
+```python
+from biznet import BizNet
+
+client = BizNet(api_key="sk_live_...", base_url="https://<api-id>.execute-api.us-east-2.amazonaws.com")
+```
+
+Both values fall back to environment variables: `BIZNET_API_KEY` and `BIZNET_BASE_URL`.
+
+An async client is available as `AsyncBizNet` with the same constructor.
+
+Resources available now:
+
+```python
+client.users.me()          # GET  /v1/users/me
+client.users.status()      # GET  /v1/users/me/status
+client.users.deactivate()  # DELETE /v1/users/me
+
+client.keys.issue(env="test", scopes=[])  # POST /v1/keys, returns the secret once
+client.keys.list()                        # GET  /v1/keys
+client.keys.revoke(key_id)                # DELETE /v1/keys/{key_id}
+
+client.products.create(title, description, price)  # POST /v1/products -> Product
+client.products.get(product_id)                    # GET  /v1/products/{id} -> Product
+client.products.delete(product_id)                 # DELETE, soft delete
+job_id = client.products.bulk_create([{...}])      # POST /v1/products/bulk
+
+client.jobs.status(job_id)                # GET /v1/jobs/{id} -> Job
+client.jobs.wait(job_id, timeout=300)     # poll with backoff until done/failed
+
+client.adapters.connect("woocommerce", store_url=..., consumer_key=..., consumer_secret=...)
+job_id = client.adapters.sync("woocommerce")       # POST .../sync
+client.adapters.sync_status("woocommerce", job_id) # GET .../sync/status -> Job
+
+client.policies.upload("returns.md")      # multipart; path or (name, bytes)
+client.policies.list()                    # GET /v1/rag/policies
+client.policies.delete("returns.md")      # DELETE by filename
+```
+
+Chat, UCP, and deploy live on the Merchant-node service (Cloud Run), a separate
+host from the AWS API. Set `node_url` on the client or `BIZNET_NODE_URL`:
+
+```python
+client.chat.complete(session_id, message)        # POST {node}/chat-sync
+async for event in aclient.chat.stream(session_id, message):
+    ...                                          # typed SSE events
+
+client.ucp.configure(slug, business_name, stripe_account_id)
+client.ucp.status()
+
+client.deploy.shared()      # provision on shared infra (default)
+client.deploy.dedicated()   # dedicated Cloud Run services
+client.deploy.status()
+client.deploy.deprovision()
+```
+
+`biznet.resources.deploy.create_ucp_router(api_key)` returns a FastAPI router
+serving `GET /.well-known/ucp` on a merchant's own domain (requires fastapi).
+
+## MerchantNode
+
+Run an MCP server on your own infra. Override only what your system supports;
+the 8 operational tools ship with mock defaults, and the 4 UCP checkout tools
+call the BizNet UCP service (set `BIZNET_UCP_URL`). Requires the mcp extra:
+`pip install "biznet[mcp]"`.
+
+```python
+from biznet import MerchantNode
+
+class MyStore(MerchantNode):
+    async def get_stock_level(self, product_id: str) -> int:
+        return my_inventory.count(product_id)
+
+MyStore(api_key="sk_live_...").run()  # stdio; or run(transport="sse")
+```
+
+## CLI
+
+`biznetai deploy` finds the MerchantNode subclass in the current directory,
+packages it with requirements.txt, and provisions it on BizNet infrastructure:
+
+```bash
+export BIZNET_API_KEY=sk_live_...
+export BIZNET_NODE_URL=https://<merchant-node-host>
+biznetai deploy                 # shared infra (default)
+biznetai deploy --tier dedicated
+```
+
+It streams provisioning status and prints the service URLs when live.
+
+## Behavior
+
+- Every request carries `X-API-Key`. Set `client.api_key` to rotate the key in place.
+- Every request carries an `X-Request-Id` (uuid4). The same id is reused across
+  retries and echoed back by the server for tracing.
+- 429 and 5xx responses retry up to 3 attempts with jittered exponential backoff.
+- Non-2xx responses raise typed exceptions mapped from the API error envelope
+  `{code, message, request_id}`: `AuthError`, `NotFoundError`, `ValidationError`,
+  `RateLimitError`, `InternalError`.
+- SSE chat streams parse into typed `StreamEvent`s: `text`, `products`, `checkout`,
+  `tool_call`, `error`, `done`.
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```

biznet-0.1.0/biznet/__init__.py

@@ -0,0 +1,31 @@
+# biznet: Python SDK for the BizNetAI merchant API.
+from .client import AsyncBizNet, BizNet
+from .exceptions import (
+    AuthError,
+    BizNetError,
+    InternalError,
+    NotFoundError,
+    RateLimitError,
+    ValidationError,
+)
+from .merchant_node import MerchantNode
+from .models import Job, Product
+from .streaming import StreamEvent
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AsyncBizNet",
+    "BizNet",
+    "BizNetError",
+    "AuthError",
+    "NotFoundError",
+    "ValidationError",
+    "RateLimitError",
+    "InternalError",
+    "StreamEvent",
+    "Job",
+    "MerchantNode",
+    "Product",
+    "__version__",
+]

biznet-0.1.0/biznet/auth.py

@@ -0,0 +1,22 @@
+# auth.py
+# X-API-Key injection for every request. The key is read through a callable at
+# request time, not captured at construction, so setting client.api_key rotates
+# the key without rebuilding the httpx client or its connection pool.
+from __future__ import annotations
+
+from typing import Callable, Generator
+
+import httpx
+
+API_KEY_HEADER = "X-API-Key"
+
+
+class ApiKeyAuth(httpx.Auth):
+    def __init__(self, get_key: Callable[[], str]):
+        self._get_key = get_key
+
+    def auth_flow(
+        self, request: httpx.Request
+    ) -> Generator[httpx.Request, httpx.Response, None]:
+        request.headers[API_KEY_HEADER] = self._get_key()
+        yield request

biznet-0.1.0/biznet/cli.py

@@ -0,0 +1,157 @@
+# cli.py
+# `biznetai` console entry point. `biznetai deploy` packages the MerchantNode
+# subclass in the current directory and ships it to the Merchant-node deploy
+# endpoint, then follows provisioning until the service is live.
+from __future__ import annotations
+
+import importlib.util
+import io
+import os
+import sys
+import tarfile
+import time
+from pathlib import Path
+from typing import Optional, Tuple
+
+import click
+import httpx
+
+from .merchant_node import MerchantNode
+
+_TERMINAL_STATUSES = {"running", "ready", "failed", "error"}
+_SKIP_PREFIXES = ("test_", "_", ".")
+
+
+def discover_merchant_node(
+    directory: Path, file: Optional[Path] = None
+) -> Tuple[Path, str]:
+    """Find the MerchantNode subclass to deploy. Returns (module_path, class_name).
+
+    Importing executes the candidate modules, same as any deploy tool that
+    loads user code (uvicorn, gunicorn). Files prefixed test_/_ are skipped.
+    """
+    candidates = [file] if file else sorted(
+        p for p in directory.glob("*.py") if not p.name.startswith(_SKIP_PREFIXES)
+    )
+    failures = []
+    for path in candidates:
+        spec = importlib.util.spec_from_file_location(path.stem, path)
+        module = importlib.util.module_from_spec(spec)
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            failures.append(f"{path.name}: {e}")
+            continue
+        for obj in vars(module).values():
+            if (
+                isinstance(obj, type)
+                and issubclass(obj, MerchantNode)
+                and obj is not MerchantNode
+            ):
+                return path, obj.__name__
+    detail = f" (import failures: {'; '.join(failures)})" if failures else ""
+    raise click.ClickException(
+        f"No MerchantNode subclass found in {directory}{detail}. "
+        "Create a class that subclasses biznet.MerchantNode, or pass --file."
+    )
+
+
+def package_node(module_path: Path) -> bytes:
+    """tar.gz of the node module plus requirements.txt when present."""
+    buffer = io.BytesIO()
+    with tarfile.open(fileobj=buffer, mode="w:gz") as tar:
+        tar.add(module_path, arcname=module_path.name)
+        requirements = module_path.parent / "requirements.txt"
+        if requirements.exists():
+            tar.add(requirements, arcname="requirements.txt")
+    return buffer.getvalue()
+
+
+@click.group()
+@click.version_option(package_name="biznet", prog_name="biznetai")
+def main() -> None:
+    """BizNetAI merchant tooling."""
+
+
+@main.command()
+@click.option(
+    "--tier", "deployment_type",
+    type=click.Choice(["shared", "dedicated"]), default="shared",
+    help="shared (default) or dedicated Cloud Run services.",
+)
+@click.option(
+    "--file", "file_path", type=click.Path(exists=True, path_type=Path),
+    default=None, help="Module containing the MerchantNode subclass.",
+)
+@click.option("--api-key", envvar="BIZNET_API_KEY", required=True,
+              help="Defaults to BIZNET_API_KEY.")
+@click.option("--node-url", envvar="BIZNET_NODE_URL", required=True,
+              help="Merchant-node service URL. Defaults to BIZNET_NODE_URL.")
+@click.option("--timeout", default=600.0, show_default=True,
+              help="Seconds to wait for provisioning.")
+@click.option("--poll-interval", default=2.0, hidden=True)
+def deploy(
+    deployment_type: str,
+    file_path: Optional[Path],
+    api_key: str,
+    node_url: str,
+    timeout: float,
+    poll_interval: float,
+) -> None:
+    """Package the MerchantNode in this directory and deploy it."""
+    node_url = node_url.rstrip("/")
+    module_path, class_name = discover_merchant_node(Path.cwd(), file_path)
+    click.echo(f"Deploying {class_name} from {module_path.name} ({deployment_type})")
+
+    package = package_node(module_path)
+    headers = {"X-API-Key": api_key}
+
+    with httpx.Client(timeout=60.0, headers=headers) as http:
+        response = http.post(
+            f"{node_url}/v1/deploy",
+            data={
+                "deployment_type": deployment_type,
+                "module": module_path.name,
+                "node_class": class_name,
+            },
+            files={"package": (f"{module_path.stem}.tar.gz", package,
+                               "application/gzip")},
+        )
+        if response.status_code >= 400:
+            raise click.ClickException(
+                f"Deploy failed ({response.status_code}): {response.text[:500]}"
+            )
+        click.echo("Provisioning started.")
+
+        # Follow provisioning until the service reaches a terminal state.
+        deadline = time.monotonic() + timeout
+        last_status = None
+        while True:
+            status_response = http.get(f"{node_url}/v1/deploy/status")
+            if status_response.status_code >= 400:
+                raise click.ClickException(
+                    f"Status check failed ({status_response.status_code})."
+                )
+            payload = status_response.json()
+            status = payload.get("status", "unknown")
+            if status != last_status:
+                click.echo(f"  status: {status}")
+                last_status = status
+            if status in _TERMINAL_STATUSES:
+                if status in ("failed", "error"):
+                    raise click.ClickException(
+                        payload.get("error") or "Provisioning failed."
+                    )
+                for name, url in (payload.get("service_urls") or {}).items():
+                    click.echo(f"  {name}: {url}")
+                click.echo("Deployed.")
+                return
+            if time.monotonic() >= deadline:
+                raise click.ClickException(
+                    f"Provisioning still '{status}' after {timeout:.0f}s."
+                )
+            time.sleep(poll_interval)
+
+
+if __name__ == "__main__":
+    main()