axio-transport-google 0.9.2__tar.gz

axio_transport_google-0.9.2/.gitignore

@@ -0,0 +1,14 @@
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+*.egg-info/
+dist/
+build/
+_build/
+.DS_Store
+*.sqlite
+*.db

axio_transport_google-0.9.2/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: axio-transport-google
+Version: 0.9.2
+Summary: Google GenAI (Gemini) transport for Axio with image and video support
+Project-URL: Documentation, https://docs.axio-agent.com
+Project-URL: Homepage, https://github.com/mosquito/axio-agent
+Project-URL: Repository, https://github.com/mosquito/axio-agent
+License: MIT
+Keywords: agent,ai,gemini,genai,google,llm,transport
+Requires-Python: >=3.12
+Requires-Dist: axio
+Requires-Dist: axio-transport-anthropic[vertexai]
+Requires-Dist: google-auth[urllib3]>=2.0
+Provides-Extra: tui
+Requires-Dist: textual>=2.1.0; extra == 'tui'
+Description-Content-Type: text/markdown
+
+# axio-transport-google
+
+Google GenAI (Gemini) transport for Axio with image and video support.
+
+## API reference
+
+Request/response types are generated from the Vertex AI discovery documents:
+
+- **v1:** https://aiplatform.googleapis.com/$discovery/rest?version=v1
+- **v1beta1:** https://aiplatform.googleapis.com/$discovery/rest?version=v1beta1
+
+To regenerate TypedDict definitions after an API update:
+
+```bash
+python scripts/generate_types.py [--version v1beta1]
+```
+
+This produces `src/axio_transport_google/_generated_types.py`, which the transport
+uses for type annotations. Conformance tests in `tests/test_generated_types.py`
+validate that payload builders match the discovery schema.

axio_transport_google-0.9.2/README.md

@@ -0,0 +1,20 @@
+# axio-transport-google
+
+Google GenAI (Gemini) transport for Axio with image and video support.
+
+## API reference
+
+Request/response types are generated from the Vertex AI discovery documents:
+
+- **v1:** https://aiplatform.googleapis.com/$discovery/rest?version=v1
+- **v1beta1:** https://aiplatform.googleapis.com/$discovery/rest?version=v1beta1
+
+To regenerate TypedDict definitions after an API update:
+
+```bash
+python scripts/generate_types.py [--version v1beta1]
+```
+
+This produces `src/axio_transport_google/_generated_types.py`, which the transport
+uses for type annotations. Conformance tests in `tests/test_generated_types.py`
+validate that payload builders match the discovery schema.

axio_transport_google-0.9.2/pyproject.toml

@@ -0,0 +1,69 @@
+[project]
+name = "axio-transport-google"
+version = "0.9.2"
+description = "Google GenAI (Gemini) transport for Axio with image and video support"
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+keywords = ["llm", "agent", "ai", "google", "gemini", "genai", "transport"]
+dependencies = [
+    "axio",
+    "axio-transport-anthropic[vertexai]",
+    "google-auth[urllib3]>=2.0",
+]
+
+[project.optional-dependencies]
+tui = ["textual>=2.1.0"]
+
+[project.entry-points."axio.transport"]
+google = "axio_transport_google:GoogleTransport"
+google-vertex = "axio_transport_google:VertexAITransport"
+
+[project.entry-points."axio.transport.realtime"]
+gemini = "axio_transport_google.realtime:GeminiLiveTransport"
+vertex = "axio_transport_google.realtime:VertexLiveTransport"
+
+[project.entry-points."axio.transport.settings"]
+google = "axio_transport_google.tui:GoogleSettingsScreen"
+google-vertex = "axio_transport_google.tui:VertexSettingsScreen"
+
+[project.entry-points."axio.tools"]
+generate_image = "axio_transport_google.tools:generate_image"
+generate_video = "axio_transport_google.tools:generate_video"
+
+[project.urls]
+Documentation = "https://docs.axio-agent.com"
+Homepage = "https://github.com/mosquito/axio-agent"
+Repository = "https://github.com/mosquito/axio-agent"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/axio_transport_google"]
+sources = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 119
+output-format = "concise"
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.mypy]
+strict = true
+python_version = "3.12"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+    "mypy>=1.14",
+    "ruff>=0.9",
+    "pytest-cov>=7.1.0",
+]

axio_transport_google-0.9.2/scripts/generate_types.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""Generate TypedDict definitions from Google Vertex AI discovery document.
+
+API reference (discovery docs):
+  https://aiplatform.googleapis.com/$discovery/rest?version=v1
+  https://aiplatform.googleapis.com/$discovery/rest?version=v1beta1
+
+Usage:
+  python scripts/generate_types.py [--version v1beta1] [--output src/axio_transport_google/_generated_types.py]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import textwrap
+import urllib.request
+from typing import Any, cast
+
+DISCOVERY_URL = "https://aiplatform.googleapis.com/$discovery/rest?version={version}"
+
+# Schemas relevant to the generateContent API, in dependency order.
+# Keys: short name used in generated code. Values: full discovery schema id.
+SCHEMA_MAP = {
+    "Blob": "Blob",
+    "FileData": "FileData",
+    "FunctionCall": "FunctionCall",
+    "FunctionResponse": "FunctionResponse",
+    "FunctionResponsePart": "FunctionResponsePart",
+    "ExecutableCode": "ExecutableCode",
+    "CodeExecutionResult": "CodeExecutionResult",
+    "VideoMetadata": "VideoMetadata",
+    "Part": "Part",
+    "Content": "Content",
+    "FunctionDeclaration": "FunctionDeclaration",
+    "Tool": "Tool",
+    "FunctionCallingConfig": "FunctionCallingConfig",
+    "ToolConfig": "ToolConfig",
+    "ThinkingConfig": "GenerationConfigThinkingConfig",
+    "GenerationConfig": "GenerationConfig",
+    "SafetySetting": "SafetySetting",
+    "GenerateContentRequest": "GenerateContentRequest",
+    "Candidate": "Candidate",
+    "UsageMetadata": "GenerateContentResponseUsageMetadata",
+    "PromptFeedback": "GenerateContentResponsePromptFeedback",
+    "GenerateContentResponse": "GenerateContentResponse",
+}
+
+# Mapping from discovery type strings to Python type annotations
+TYPE_MAP: dict[str, str] = {
+    "string": "str",
+    "integer": "int",
+    "number": "float",
+    "boolean": "bool",
+    "any": "Any",
+}
+
+
+def fetch_discovery(version: str) -> dict[str, Any]:
+    url = DISCOVERY_URL.format(version=version)
+    print(f"Fetching {url} ...", file=sys.stderr)
+    with urllib.request.urlopen(url) as resp:
+        return cast(dict[str, Any], json.loads(resp.read()))
+
+
+def resolve_schema_name(full_id: str, version_prefix: str) -> str | None:
+    """Extract the short schema name from the full discovery ID."""
+    if full_id.startswith(version_prefix):
+        return full_id[len(version_prefix) :]
+    return None
+
+
+def ref_to_short_name(ref: str, version_prefix: str) -> str | None:
+    """Convert a $ref value to our short TypedDict name, if it's in SCHEMA_MAP."""
+    short = resolve_schema_name(ref, version_prefix)
+    if short is None:
+        return None
+    for td_name, schema_suffix in SCHEMA_MAP.items():
+        if short == schema_suffix:
+            return td_name
+    return None
+
+
+def python_type_for_property(prop: dict[str, Any], version_prefix: str, required: bool = True) -> str:
+    """Convert a discovery property definition to a Python type annotation."""
+    if "$ref" in prop:
+        td_name = ref_to_short_name(prop["$ref"], version_prefix)
+        if td_name:
+            return td_name
+        return "dict[str, Any]"
+
+    prop_type = prop.get("type", "any")
+
+    if prop_type == "array":
+        items = prop.get("items", {})
+        item_type = python_type_for_property(items, version_prefix)
+        return f"list[{item_type}]"
+
+    if prop_type == "object":
+        additional = prop.get("additionalProperties", {})
+        if additional:
+            val_type = python_type_for_property(additional, version_prefix)
+            return f"dict[str, {val_type}]"
+        return "dict[str, Any]"
+
+    if "enum" in prop:
+        literals = [f'"{v}"' for v in prop["enum"]]
+        single_line = f"Literal[{', '.join(literals)}]"
+        if len(single_line) <= 80:
+            return single_line
+        # Multi-line Literal for long enum lists
+        inner = ",\n    ".join(literals)
+        return f"Literal[\n    {inner},\n]"
+
+    return TYPE_MAP.get(prop_type, "Any")
+
+
+def generate_typeddict(
+    td_name: str,
+    schema: dict[str, Any],
+    version_prefix: str,
+) -> str:
+    """Generate a TypedDict class definition from a discovery schema."""
+    properties = schema.get("properties", {})
+    if not properties:
+        return f"class {td_name}(TypedDict, total=False):\n    pass\n"
+
+    lines = [f"class {td_name}(TypedDict, total=False):"]
+
+    desc = schema.get("description", "")
+    if desc:
+        wrapped = textwrap.fill(desc, width=100, initial_indent="    ", subsequent_indent="    ")
+        lines.append(f'    """{wrapped[4:]}"""')
+        lines.append("")
+
+    for prop_name, prop_def in sorted(properties.items()):
+        py_type = python_type_for_property(prop_def, version_prefix)
+        prop_desc = prop_def.get("description", "")
+        if prop_desc:
+            short_desc = prop_desc.split(".")[0].strip()
+            if len(short_desc) > 90:
+                short_desc = short_desc[:87] + "..."
+            lines.append(f"    # {short_desc}")
+        if "\n" in py_type:
+            # Multi-line type (e.g. long Literal) — indent to field level
+            indented = py_type.replace("\n", "\n    ")
+            lines.append(f"    {prop_name}: {indented}")
+        else:
+            line = f"    {prop_name}: {py_type}"
+            if len(line) > 119:
+                # Break long single-line annotations
+                lines.append(f"    {prop_name}: (")
+                lines.append(f"        {py_type}")
+                lines.append("    )")
+            else:
+                lines.append(line)
+
+    return "\n".join(lines) + "\n"
+
+
+def generate_all(discovery: dict[str, Any], version: str) -> str:
+    """Generate the full _generated_types.py file content."""
+    schemas = discovery.get("schemas", {})
+
+    if version == "v1":
+        version_prefix = "GoogleCloudAiplatformV1"
+    else:
+        version_prefix = "GoogleCloudAiplatformV1beta1"
+
+    header = f'''\
+"""TypedDict definitions for Google Vertex AI generateContent API.
+
+Auto-generated from the Vertex AI discovery document ({version}).
+Do not edit manually — regenerate with:
+  python scripts/generate_types.py --version {version}
+
+API reference (discovery docs):
+  https://aiplatform.googleapis.com/$discovery/rest?version=v1
+  https://aiplatform.googleapis.com/$discovery/rest?version=v1beta1
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal, TypedDict  # noqa: UP035
+
+'''
+
+    parts: list[str] = [header]
+
+    # Track which schemas we actually found
+    generated: list[str] = []
+    missing: list[str] = []
+
+    for td_name, schema_suffix in SCHEMA_MAP.items():
+        full_id = f"{version_prefix}{schema_suffix}"
+        schema = schemas.get(full_id)
+        if schema is None:
+            missing.append(f"# WARNING: schema {full_id!r} not found in discovery doc")
+            continue
+        parts.append(generate_typeddict(td_name, schema, version_prefix))
+        parts.append("")
+        generated.append(td_name)
+
+    # __all__ for explicit exports
+    all_items = [f'    "{n}",' for n in generated]
+    all_block = "__all__ = [\n" + "\n".join(all_items) + "\n]\n"
+    parts.insert(1, all_block)
+    parts.insert(2, "")
+
+    if missing:
+        parts.append("\n".join(missing) + "\n")
+
+    for m in missing:
+        print(m, file=sys.stderr)
+
+    return "\n".join(parts)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--version",
+        default="v1beta1",
+        choices=["v1", "v1beta1"],
+        help="Discovery document version (default: v1beta1)",
+    )
+    parser.add_argument(
+        "--output",
+        default="src/axio_transport_google/_generated_types.py",
+        help="Output file path",
+    )
+    parser.add_argument(
+        "--input",
+        default=None,
+        help="Read discovery doc from file instead of fetching",
+    )
+    args = parser.parse_args()
+
+    if args.input:
+        with open(args.input) as f:
+            discovery = json.load(f)
+    else:
+        discovery = fetch_discovery(args.version)
+
+    content = generate_all(discovery, args.version)
+
+    with open(args.output, "w") as f:
+        f.write(content)
+    print(f"Generated {args.output} ({len(SCHEMA_MAP)} schemas)", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()