atlanai 0.1.0__tar.gz

atlanai-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: atlanai
+Version: 0.1.0
+Summary: Unified Atlan Agent Gateway management and tracing SDK
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: python-dateutil<3,>=2.8.2
+Requires-Dist: typing-extensions<5,>=4.12
+Requires-Dist: urllib3<3,>=2.3
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-api<2,>=1.39.0; extra == "tracing"
+Requires-Dist: opentelemetry-sdk<2,>=1.39.0; extra == "tracing"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http<2,>=1.39.0; extra == "tracing"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == "langchain"
+
+# atlanai
+
+Unified Python SDK for Atlan agents.
+
+Use `AtlanClient` for the public Agent Gateway management API. Generated
+clients are available under `client.raw` and `atlanai.raw`. Management
+has no OpenTelemetry dependency or import-time tracing side effect.
+
+Install `atlanai[tracing]` and import `atlanai.tracing` for the
+OpenTelemetry-native tracing pipeline. Tracing has its own explicit API key,
+workspace, exporter, and lifecycle; it does not reuse the management bearer or
+generated REST transport. Existing `atlan_ai` and `atlan_ai.langchain` imports
+remain available during the compatibility window.
+
+## Local install
+
+From the repository root, install management only:
+
+```bash
+uv venv .venv
+source .venv/bin/activate
+uv pip install --editable ./python
+```
+
+Install optional tracing and LangChain support:
+
+```bash
+uv pip install --editable './python[tracing,langchain]'
+```
+
+Management takes its Gateway origin and bearer explicitly:
+
+```python
+import os
+
+from atlanai import AtlanClient
+
+with AtlanClient(
+    os.environ["ATLANAI_GATEWAY_URL"],
+    bearer_token=os.environ["ATLANAI_TOKEN"],
+) as client:
+    page = client.agents.agent_list_agents(limit=10)
+    print(len(page.items))
+```
+
+See [the complete local setup guide](../docs/getting-started.md) for direct
+Registry configuration and the separate tracing environment. The
+[generated Python reference](../docs/reference/README.md) covers every raw
+operation and model.

atlanai-0.1.0/README.md

@@ -0,0 +1,49 @@
+# atlanai
+
+Unified Python SDK for Atlan agents.
+
+Use `AtlanClient` for the public Agent Gateway management API. Generated
+clients are available under `client.raw` and `atlanai.raw`. Management
+has no OpenTelemetry dependency or import-time tracing side effect.
+
+Install `atlanai[tracing]` and import `atlanai.tracing` for the
+OpenTelemetry-native tracing pipeline. Tracing has its own explicit API key,
+workspace, exporter, and lifecycle; it does not reuse the management bearer or
+generated REST transport. Existing `atlan_ai` and `atlan_ai.langchain` imports
+remain available during the compatibility window.
+
+## Local install
+
+From the repository root, install management only:
+
+```bash
+uv venv .venv
+source .venv/bin/activate
+uv pip install --editable ./python
+```
+
+Install optional tracing and LangChain support:
+
+```bash
+uv pip install --editable './python[tracing,langchain]'
+```
+
+Management takes its Gateway origin and bearer explicitly:
+
+```python
+import os
+
+from atlanai import AtlanClient
+
+with AtlanClient(
+    os.environ["ATLANAI_GATEWAY_URL"],
+    bearer_token=os.environ["ATLANAI_TOKEN"],
+) as client:
+    page = client.agents.agent_list_agents(limit=10)
+    print(len(page.items))
+```
+
+See [the complete local setup guide](../docs/getting-started.md) for direct
+Registry configuration and the separate tracing environment. The
+[generated Python reference](../docs/reference/README.md) covers every raw
+operation and model.

atlanai-0.1.0/pyproject.toml

@@ -0,0 +1,81 @@
+[build-system]
+requires = ["setuptools>=77,<82"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "atlanai"
+version = "0.1.0"
+description = "Unified Atlan Agent Gateway management and tracing SDK"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+dependencies = [
+  "pydantic>=2.10,<3",
+  "python-dateutil>=2.8.2,<3",
+  "typing-extensions>=4.12,<5",
+  "urllib3>=2.3,<3",
+]
+
+[project.optional-dependencies]
+tracing = [
+  "opentelemetry-api>=1.39.0,<2",
+  "opentelemetry-sdk>=1.39.0,<2",
+  "opentelemetry-exporter-otlp-proto-http>=1.39.0,<2",
+]
+langchain = [
+  "langchain-core>=0.3",
+]
+
+[dependency-groups]
+dev = [
+  "anthropic>=0.40",
+  "langfuse>=3.0",
+  "mypy>=1.13",
+  "openai>=1.60",
+  "opentelemetry-instrumentation-anthropic>=0.40",
+  "opentelemetry-instrumentation-openai>=0.40",
+  "pytest>=8.0",
+  "pyyaml>=6.0",
+  "ruff>=0.8",
+  "types-PyYAML>=6.0",
+]
+
+[tool.uv]
+exclude-newer = "2026-08-11T00:00:00Z"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+atlanai = ["manifest.json", "resources.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests", "tracing_tests"]
+addopts = "-q"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+src = ["src", "tests", "tracing_tests", "scripts"]
+extend-exclude = ["src/atlanai/raw"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+python_version = "3.10"
+files = ["src/atlanai/tracing", "src/atlanai/tracing", "scripts", "tracing_tests"]
+disallow_untyped_defs = true
+warn_return_any = true
+warn_unreachable = true
+strict_equality = true
+no_implicit_optional = true
+warn_unused_ignores = true
+
+[[tool.mypy.overrides]]
+module = ["langgraph.*"]
+ignore_missing_imports = true

atlanai-0.1.0/setup.cfg

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

atlanai-0.1.0/src/atlanai/__init__.py

@@ -0,0 +1,12 @@
+from .client import AtlanClient, ServiceNamespace
+from .errors import AtlanAPIError
+from .operations import operation_manifest, operations
+
+__all__ = [
+    "AtlanAPIError",
+    "AtlanClient",
+    "ServiceNamespace",
+    "operation_manifest",
+    "operations",
+]
+__version__ = "0.1.0"

atlanai-0.1.0/src/atlanai/_resources.py

@@ -0,0 +1,124 @@
+"""The resource-oriented surface, built from the shipped resource map.
+
+Services are a deployment detail — they are base paths. Resources are what
+callers think in, so the client exposes resources rather than services:
+``client.sessions.messages.create(...)`` instead of
+``client.agents.agent_create_session_message(session_id=..., ...)``.
+
+The map is derived from the operation manifest and committed, so this module
+holds no naming rules of its own. Every call still lands on the generated
+method through :class:`ServiceNamespace`, which is what applies the request
+timeout, the workspace header, the body coercion, and error normalization.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from importlib import resources as importlib_resources
+from types import MappingProxyType
+from typing import Any
+
+
+SCHEMA_VERSION = 1
+
+
+def resource_map() -> dict[str, Any]:
+    """The committed resource map that ships inside the package."""
+    data = importlib_resources.files(__package__).joinpath("resources.json").read_bytes()
+    document = json.loads(data)
+    if document.get("schema_version") != SCHEMA_VERSION:
+        raise RuntimeError(
+            f"resources.json declares schema_version "
+            f"{document.get('schema_version')}; this build understands "
+            f"{SCHEMA_VERSION}"
+        )
+    return document
+
+
+class Resource:
+    """One resource: its own operations, plus any resources nested under it."""
+
+    __slots__ = ("_name", "_namespace", "_methods", "_children")
+
+    def __init__(
+        self,
+        name: str,
+        namespace: Any,
+        methods: Mapping[str, str],
+        children: Mapping[str, "Resource"],
+    ) -> None:
+        self._name = name
+        self._namespace = namespace
+        self._methods = MappingProxyType(dict(methods))
+        self._children = MappingProxyType(dict(children))
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def operations(self) -> Mapping[str, str]:
+        """This resource's method names, mapped to their generated names."""
+        return self._methods
+
+    def __getattr__(self, name: str) -> Any:
+        generated = self._methods.get(name)
+        if generated is not None:
+            # Through the namespace, not the generated API directly: that is
+            # where the timeout, workspace header, body coercion and error
+            # normalization live.
+            return getattr(self._namespace, generated)
+        child = self._children.get(name)
+        if child is not None:
+            return child
+        raise AttributeError(
+            f"resource {self._name!r} has no operation or nested resource {name!r}"
+        )
+
+    def __dir__(self) -> list[str]:
+        # So editors and `dir()` show the real surface rather than just slots.
+        return sorted({*self._methods, *self._children, "name", "operations"})
+
+    def _rebound(self, namespaces: Mapping[str, Any]) -> "Resource":
+        """Copy this resource onto another set of namespaces."""
+        service = self._namespace.name
+        return Resource(
+            self._name,
+            namespaces[service],
+            self._methods,
+            {name: child._rebound(namespaces) for name, child in self._children.items()},
+        )
+
+
+def build_resources(
+    document: Mapping[str, Any], namespaces: Mapping[str, Any]
+) -> dict[str, Resource]:
+    """Build the top-level resources, nesting children under their parents.
+
+    Resource keys are dotted paths (``agents.traces``), so the deepest are
+    constructed first and handed to their parent.
+    """
+    entries = document["resources"]
+    children: dict[str, dict[str, Resource]] = {}
+    # Deepest first, so a parent always finds its children already built.
+    for key in sorted(entries, key=lambda k: k.count("."), reverse=True):
+        entry = entries[key]
+        methods = {
+            method: detail["python"] for method, detail in entry["methods"].items()
+        }
+        parent, _, leaf = key.rpartition(".")
+        resource = Resource(
+            key, namespaces[entry["service"]], methods, children.pop(key, {})
+        )
+        if parent:
+            children.setdefault(parent, {})[leaf] = resource
+        else:
+            children.setdefault("", {})[leaf] = resource
+
+    top = children.pop("", {})
+    if children:
+        # A nested resource whose parent has no operations of its own would be
+        # unreachable, which is a map defect rather than something to paper over.
+        raise RuntimeError(f"resource map has orphaned children: {sorted(children)}")
+    return top