redis-context-gateway 0.1.0a1__tar.gz

redis_context_gateway-0.1.0a1/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: redis-context-gateway
+Version: 0.1.0a1
+Summary: Redis Context Gateway REST and MCP SDK
+License: MIT
+Author: Redis AI Services Team
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+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: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Dist: httpcore (>=1.0.9)
+Requires-Dist: httpx (>=0.28.1,<1)
+Requires-Dist: mcp (>=1.30.0,<2)
+Requires-Dist: pydantic (>=2.11.2)
+Description-Content-Type: text/markdown
+
+# redis-context-gateway
+
+Python SDK for Redis Context Gateway. The REST client is generated by Speakeasy from the Gateway control-plane API, the same way as the other Iris SDKs. A small helper connects agents to a Gateway's MCP endpoint with the official `mcp` library.
+
+Unpublished first increment, generated from `redislabsdev/iris@7b8fb322e`. Python 3.10 or later.
+
+## Control plane
+
+```python
+from redis_context_gateway import ContextGatewayClient
+
+with ContextGatewayClient(server_url=control_plane_url, admin_token=admin_token) as client:
+    gateway = client.gateways.create(display_name="Docs", tool_exposure_mode="search")
+    upstream = client.upstreams.create(
+        gateway_id=gateway.id,
+        display_name="Docs MCP",
+        namespace="docs",
+        connection={"endpoint": upstream_mcp_url},
+        authentication={"methods": [{"bearer": {"value": upstream_token}}]},
+    )
+```
+
+Every product call sends the admin token. The health probes (`client.health.live()`, `client.health.ready()`) send no credential. Async variants end in `_async`. See [USAGE.md](USAGE.md) and [docs/](docs/) for every operation and model.
+
+## Agents (MCP)
+
+```python
+from redis_context_gateway.mcp import connect
+
+async with connect(gateway.mcp_endpoint, agent_key) as session:
+    found = await session.call_tool("search_tools", {"query": "find an issue"})
+    result = await session.call_tool(
+        "run_tool", {"tool": {"upstreamId": upstream.id, "originalName": "get_issue"}, "toolArgs": {"id": 42}}
+    )
+```
+
+`connect` returns an initialized official `mcp.ClientSession`, so Lens instrumentation applies as is. The agent key is an Identity Service key with a `context-retriever` / `cr-gateway` / `use` grant for the Gateway. Search tools, `run_tool` and the result handle tools are ordinary tool calls. A tool failure comes back as a result with `isError: true`, not an exception.
+
+MCP reads default to a 300-second inactivity timeout, with 30-second connect, write and connection-pool budgets. Pass `timeout=10` to use ten seconds for every HTTP timeout, or `timeout=httpx.Timeout(30, read=600)` for a separate read budget. These are HTTP inactivity limits, not a total tool-call deadline. REST timeout defaults are unchanged.
+
+## Safety
+
+- Neither client follows redirects, so the admin token and agent keys stay on the Gateway.
+- Plain HTTP is refused unless the host is loopback (localhost, 127.0.0.0/8 or ::1).
+- Each request must match its own operation's method, path and query names, so an ID like `../../v1/gateways` fails before anything is sent. A custom HTTP client that can't turn redirects off is refused with a `TypeError`.
+- The SDK never reads credentials from environment variables. Pass them in explicitly. The `redis-iris` CLI and goal objects own `IRIS_CONTEXT_GATEWAY_*` settings and the `[context_gateway]` config table.
+- Upstream secrets are write-only: no response model carries them.
+- Generated payload debugging is disabled, even when `debug_logger` is supplied, because it would log request secrets. Application logging and custom HTTP transports are outside this guarantee. Do not log whole generated exceptions: validation diagnostics can retain supplied credentials, and response errors retain server-provided bodies.
+- No call is retried automatically.
+
+## Development
+
+```sh
+uv venv && uv pip install -e . pytest pytest-asyncio ruff
+# Python 3.11+: install the local Lens package for its integration test.
+uv pip install ../lens-python-sdk
+.venv/bin/python -m pytest tests
+```
+
+Hand-written files are `src/redis_context_gateway/_hooks/registration.py`, `src/redis_context_gateway/mcp.py`, `tests/` and this README, protected by `.genignore`. Everything else is regenerated by `node scripts/generate-context-gateway.mjs` from the repository root.
+

redis_context_gateway-0.1.0a1/README.md

@@ -0,0 +1,60 @@
+# redis-context-gateway
+
+Python SDK for Redis Context Gateway. The REST client is generated by Speakeasy from the Gateway control-plane API, the same way as the other Iris SDKs. A small helper connects agents to a Gateway's MCP endpoint with the official `mcp` library.
+
+Unpublished first increment, generated from `redislabsdev/iris@7b8fb322e`. Python 3.10 or later.
+
+## Control plane
+
+```python
+from redis_context_gateway import ContextGatewayClient
+
+with ContextGatewayClient(server_url=control_plane_url, admin_token=admin_token) as client:
+    gateway = client.gateways.create(display_name="Docs", tool_exposure_mode="search")
+    upstream = client.upstreams.create(
+        gateway_id=gateway.id,
+        display_name="Docs MCP",
+        namespace="docs",
+        connection={"endpoint": upstream_mcp_url},
+        authentication={"methods": [{"bearer": {"value": upstream_token}}]},
+    )
+```
+
+Every product call sends the admin token. The health probes (`client.health.live()`, `client.health.ready()`) send no credential. Async variants end in `_async`. See [USAGE.md](USAGE.md) and [docs/](docs/) for every operation and model.
+
+## Agents (MCP)
+
+```python
+from redis_context_gateway.mcp import connect
+
+async with connect(gateway.mcp_endpoint, agent_key) as session:
+    found = await session.call_tool("search_tools", {"query": "find an issue"})
+    result = await session.call_tool(
+        "run_tool", {"tool": {"upstreamId": upstream.id, "originalName": "get_issue"}, "toolArgs": {"id": 42}}
+    )
+```
+
+`connect` returns an initialized official `mcp.ClientSession`, so Lens instrumentation applies as is. The agent key is an Identity Service key with a `context-retriever` / `cr-gateway` / `use` grant for the Gateway. Search tools, `run_tool` and the result handle tools are ordinary tool calls. A tool failure comes back as a result with `isError: true`, not an exception.
+
+MCP reads default to a 300-second inactivity timeout, with 30-second connect, write and connection-pool budgets. Pass `timeout=10` to use ten seconds for every HTTP timeout, or `timeout=httpx.Timeout(30, read=600)` for a separate read budget. These are HTTP inactivity limits, not a total tool-call deadline. REST timeout defaults are unchanged.
+
+## Safety
+
+- Neither client follows redirects, so the admin token and agent keys stay on the Gateway.
+- Plain HTTP is refused unless the host is loopback (localhost, 127.0.0.0/8 or ::1).
+- Each request must match its own operation's method, path and query names, so an ID like `../../v1/gateways` fails before anything is sent. A custom HTTP client that can't turn redirects off is refused with a `TypeError`.
+- The SDK never reads credentials from environment variables. Pass them in explicitly. The `redis-iris` CLI and goal objects own `IRIS_CONTEXT_GATEWAY_*` settings and the `[context_gateway]` config table.
+- Upstream secrets are write-only: no response model carries them.
+- Generated payload debugging is disabled, even when `debug_logger` is supplied, because it would log request secrets. Application logging and custom HTTP transports are outside this guarantee. Do not log whole generated exceptions: validation diagnostics can retain supplied credentials, and response errors retain server-provided bodies.
+- No call is retried automatically.
+
+## Development
+
+```sh
+uv venv && uv pip install -e . pytest pytest-asyncio ruff
+# Python 3.11+: install the local Lens package for its integration test.
+uv pip install ../lens-python-sdk
+.venv/bin/python -m pytest tests
+```
+
+Hand-written files are `src/redis_context_gateway/_hooks/registration.py`, `src/redis_context_gateway/mcp.py`, `tests/` and this README, protected by `.genignore`. Everything else is regenerated by `node scripts/generate-context-gateway.mjs` from the repository root.

redis_context_gateway-0.1.0a1/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. The package enables type hints.

redis_context_gateway-0.1.0a1/pyproject.toml

@@ -0,0 +1,57 @@
+
+[project]
+name = "redis-context-gateway"
+version = "0.1.0-alpha.1"
+description = "Redis Context Gateway REST and MCP SDK"
+authors = [{ name = "Redis AI Services Team" },]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "httpcore >=1.0.9",
+    "httpx >=0.28.1,<1",
+    "mcp >=1.30.0,<2",
+    "pydantic >=2.11.2",
+]
+license = { text = "MIT" }
+
+[tool.poetry]
+packages = [
+    { include = "redis_context_gateway", from = "src" }
+]
+include = ["py.typed", "src/redis_context_gateway/py.typed"]
+
+[tool.setuptools.package-data]
+"*" = ["py.typed", "src/redis_context_gateway/py.typed"]
+
+[virtualenvs]
+in-project = true
+
+[tool.poetry.group.dev.dependencies]
+mypy = "==1.15.0"
+pylint = "==3.2.3"
+pyright = "==1.1.398"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"
+pythonpath = ["src"]
+
+[tool.mypy]
+disable_error_code = "misc"
+explicit_package_bases = true
+mypy_path = "src"
+
+[[tool.mypy.overrides]]
+module = "typing_inspect"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "jsonpath"
+ignore_missing_imports = true
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"

redis_context_gateway-0.1.0a1/src/redis_context_gateway/__init__.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from ._version import (
+    __title__,
+    __version__,
+    __openapi_doc_version__,
+    __gen_version__,
+    __user_agent__,
+)
+from .sdk import *
+from .sdkconfiguration import *
+
+
+VERSION: str = __version__
+OPENAPI_DOC_VERSION = __openapi_doc_version__
+SPEAKEASY_GENERATOR_VERSION = __gen_version__
+USER_AGENT = __user_agent__

redis_context_gateway-0.1.0a1/src/redis_context_gateway/_hooks/__init__.py

@@ -0,0 +1,5 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .sdkhooks import *
+from .types import *
+from .registration import *

redis_context_gateway-0.1.0a1/src/redis_context_gateway/_hooks/registration.py

@@ -0,0 +1,142 @@
+import ipaddress
+import re
+from collections.abc import Iterable
+from typing import Any, cast
+
+import httpx
+
+from ..utils.logger import NoOpLogger
+from .types import BeforeRequestHook, Hooks, SDKInitHook
+
+# This file is only ever generated once on the first generation and then is free to be modified.
+# Any hooks you wish to add should be registered in the init_hooks function. Feel free to define them
+# in this file or in separate files in the hooks folder.
+
+_ID = "[0-9a-f]{32}"
+_PAGE = frozenset({"nextToken", "maxResults"})
+
+
+def _route(method, path, queries: Iterable[str] = ()):
+    return method, re.compile(path), frozenset(queries)
+
+
+# The request shape of every operation in the pinned openapi-context-gateway.json. A path
+# parameter is narrowed to the spec's own pattern. tests/test_control_plane.py fails when this
+# table and the pinned paths disagree, so a regenerated SDK can't drift from it silently.
+CONTROL_PLANE_ROUTES = {
+    "ListGateways": _route("GET", "/v1/gateways", _PAGE),
+    "CreateGateway": _route("POST", "/v1/gateways"),
+    "DeleteGateway": _route("DELETE", f"/v1/gateways/{_ID}", {"expectedRevision"}),
+    "GetGateway": _route("GET", f"/v1/gateways/{_ID}"),
+    "UpdateGateway": _route("PATCH", f"/v1/gateways/{_ID}"),
+    "ListUpstreams": _route("GET", f"/v1/gateways/{_ID}/upstreams", _PAGE),
+    "CreateUpstream": _route("POST", f"/v1/gateways/{_ID}/upstreams"),
+    "DeleteUpstream": _route(
+        "DELETE",
+        f"/v1/gateways/{_ID}/upstreams/{_ID}",
+        {"expectedRevision", "ignoreIndexSweepFailure"},
+    ),
+    "GetUpstream": _route("GET", f"/v1/gateways/{_ID}/upstreams/{_ID}"),
+    "UpdateUpstream": _route("PATCH", f"/v1/gateways/{_ID}/upstreams/{_ID}"),
+    "RefreshUpstreamCatalog": _route(
+        "POST", f"/v1/gateways/{_ID}/upstreams/{_ID}/refresh"
+    ),
+    "ListUpstreamTools": _route("GET", f"/v1/gateways/{_ID}/upstreams/{_ID}/tools"),
+    "Live": _route("GET", "/v1/health/live"),
+    "Ready": _route("GET", "/v1/health/ready"),
+}
+
+
+def _is_loopback(host: str) -> bool:
+    if host.lower() == "localhost":
+        return True
+    try:
+        return ipaddress.ip_address(host).is_loopback
+    except ValueError:
+        return False
+
+
+def require_safe_transport_url(url) -> None:
+    """Refuse a URL that would carry a credential in clear text off this machine.
+
+    HTTPS is always allowed. Plain HTTP is allowed only to a loopback host (``localhost``,
+    ``127.0.0.0/8`` or ``::1``) for local development.
+    """
+    parsed = httpx.URL(str(url))
+    if parsed.scheme == "https":
+        return
+    if parsed.scheme == "http" and _is_loopback(parsed.host):
+        return
+    raise ValueError(
+        f"Context Gateway URL {parsed.scheme}://{parsed.host} must use HTTPS. "
+        "Plain HTTP is allowed only to localhost, 127.0.0.0/8 or ::1."
+    )
+
+
+def _encoded_path(url: httpx.URL) -> str:
+    return url.raw_path.split(b"?", 1)[0].decode("ascii")
+
+
+class SafeTransport(SDKInitHook):
+    """Disable redirects and generated payload logging for credential-bearing calls."""
+
+    def sdk_init(self, config):
+        # Generated debug logging includes write-only Upstream credentials.
+        config.debug_logger = NoOpLogger()
+        for client in (config.client, config.async_client):
+            if client is None:
+                continue
+            if not hasattr(client, "follow_redirects"):
+                raise TypeError(
+                    f"{type(client).__name__} has no follow_redirects attribute, so the "
+                    "Context Gateway SDK can't turn redirects off and keep the admin token "
+                    "on the Gateway. Pass an httpx.Client or httpx.AsyncClient, or a client "
+                    "with a follow_redirects attribute."
+                )
+            cast(Any, client).follow_redirects = False
+        return config
+
+
+class SafeRequest(BeforeRequestHook):
+    """Send a request only over HTTPS (or loopback HTTP) and only in its operation's shape.
+
+    The generated SDK puts path parameters into the URL unencoded, so an ID such as
+    ``../../v1/gateways`` or ``x?y=1#`` would reach a different resource. Every request must
+    match the method, path and query names of its own operation in the pinned spec.
+    """
+
+    def before_request(self, hook_ctx, request):
+        require_safe_transport_url(request.url)
+        route = CONTROL_PLANE_ROUTES.get(hook_ctx.operation_id)
+        if route is None:
+            raise ValueError(
+                f"Unknown Context Gateway operation {hook_ctx.operation_id!r}. "
+                "Add its path to CONTROL_PLANE_ROUTES."
+            )
+        method, path, queries = route
+        base_url = hook_ctx.base_url or hook_ctx.config.get_server_details()[0]
+        base_path = _encoded_path(httpx.URL(base_url)).rstrip("/")
+        request_path = _encoded_path(request.url)
+        names = {name for name, _ in request.url.params.multi_items()}
+        if (
+            request.method != method
+            # An ID ending in "#" leaves an empty fragment that url.fragment reports as "".
+            or "#" in str(request.url)
+            or not request_path.startswith(base_path)
+            or not path.fullmatch(request_path[len(base_path) :])
+            or not names <= queries
+        ):
+            raise ValueError(
+                f"Refusing {hook_ctx.operation_id}: request path {request_path!r} does not "
+                f"match {method} {path.pattern}. Gateway and Upstream IDs are 32 lowercase "
+                "hexadecimal characters."
+            )
+        return request
+
+
+def init_hooks(hooks: Hooks):
+    """Add hooks by calling hooks.register{sdk_init/before_request/after_success/after_error}Hook
+    with an instance of a hook that implements that specific Hook interface
+    Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance"""
+    hooks.register_sdk_init_hook(SafeTransport())
+    hooks.register_before_request_hook(SafeRequest())

redis_context_gateway-0.1.0a1/src/redis_context_gateway/_hooks/sdkhooks.py

@@ -0,0 +1,76 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+from .types import (
+    SDKInitHook,
+    BeforeRequestContext,
+    BeforeRequestHook,
+    AfterSuccessContext,
+    AfterSuccessHook,
+    AfterErrorContext,
+    AfterErrorHook,
+    Hooks,
+)
+from .registration import init_hooks
+from typing import List, Optional, Tuple
+from redis_context_gateway.sdkconfiguration import SDKConfiguration
+
+
+class SDKHooks(Hooks):
+    def __init__(self) -> None:
+        self.sdk_init_hooks: List[SDKInitHook] = []
+        self.before_request_hooks: List[BeforeRequestHook] = []
+        self.after_success_hooks: List[AfterSuccessHook] = []
+        self.after_error_hooks: List[AfterErrorHook] = []
+        init_hooks(self)
+
+    def register_sdk_init_hook(self, hook: SDKInitHook) -> None:
+        self.sdk_init_hooks.append(hook)
+
+    def register_before_request_hook(self, hook: BeforeRequestHook) -> None:
+        self.before_request_hooks.append(hook)
+
+    def register_after_success_hook(self, hook: AfterSuccessHook) -> None:
+        self.after_success_hooks.append(hook)
+
+    def register_after_error_hook(self, hook: AfterErrorHook) -> None:
+        self.after_error_hooks.append(hook)
+
+    def sdk_init(self, config: SDKConfiguration) -> SDKConfiguration:
+        for hook in self.sdk_init_hooks:
+            config = hook.sdk_init(config)
+        return config
+
+    def before_request(
+        self, hook_ctx: BeforeRequestContext, request: httpx.Request
+    ) -> httpx.Request:
+        for hook in self.before_request_hooks:
+            out = hook.before_request(hook_ctx, request)
+            if isinstance(out, Exception):
+                raise out
+            request = out
+
+        return request
+
+    def after_success(
+        self, hook_ctx: AfterSuccessContext, response: httpx.Response
+    ) -> httpx.Response:
+        for hook in self.after_success_hooks:
+            out = hook.after_success(hook_ctx, response)
+            if isinstance(out, Exception):
+                raise out
+            response = out
+        return response
+
+    def after_error(
+        self,
+        hook_ctx: AfterErrorContext,
+        response: Optional[httpx.Response],
+        error: Optional[Exception],
+    ) -> Tuple[Optional[httpx.Response], Optional[Exception]]:
+        for hook in self.after_error_hooks:
+            result = hook.after_error(hook_ctx, response, error)
+            if isinstance(result, Exception):
+                raise result
+            response, error = result
+        return response, error

redis_context_gateway-0.1.0a1/src/redis_context_gateway/_hooks/types.py

@@ -0,0 +1,124 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from abc import ABC, abstractmethod
+import httpx
+from redis_context_gateway.sdkconfiguration import SDKConfiguration
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+
+class HookContext:
+    config: SDKConfiguration
+    base_url: str
+    operation_id: str
+    oauth2_scopes: Optional[List[str]] = None
+    security_source: Optional[Union[Any, Callable[[], Any]]] = None
+    tags: Optional[List[str]] = None
+    extensions: Optional[Dict[str, Any]] = None
+
+    def __init__(
+        self,
+        config: SDKConfiguration,
+        base_url: str,
+        operation_id: str,
+        oauth2_scopes: Optional[List[str]],
+        security_source: Optional[Union[Any, Callable[[], Any]]],
+        tags: Optional[List[str]],
+        extensions: Optional[Dict[str, Any]],
+    ):
+        self.config = config
+        self.base_url = base_url
+        self.operation_id = operation_id
+        self.oauth2_scopes = oauth2_scopes
+        self.security_source = security_source
+        self.tags = tags
+        self.extensions = extensions
+
+
+class BeforeRequestContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(
+            hook_ctx.config,
+            hook_ctx.base_url,
+            hook_ctx.operation_id,
+            hook_ctx.oauth2_scopes,
+            hook_ctx.security_source,
+            hook_ctx.tags,
+            hook_ctx.extensions,
+        )
+
+
+class AfterSuccessContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(
+            hook_ctx.config,
+            hook_ctx.base_url,
+            hook_ctx.operation_id,
+            hook_ctx.oauth2_scopes,
+            hook_ctx.security_source,
+            hook_ctx.tags,
+            hook_ctx.extensions,
+        )
+
+
+class AfterErrorContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(
+            hook_ctx.config,
+            hook_ctx.base_url,
+            hook_ctx.operation_id,
+            hook_ctx.oauth2_scopes,
+            hook_ctx.security_source,
+            hook_ctx.tags,
+            hook_ctx.extensions,
+        )
+
+
+class SDKInitHook(ABC):
+    @abstractmethod
+    def sdk_init(self, config: SDKConfiguration) -> SDKConfiguration:
+        pass
+
+
+class BeforeRequestHook(ABC):
+    @abstractmethod
+    def before_request(
+        self, hook_ctx: BeforeRequestContext, request: httpx.Request
+    ) -> Union[httpx.Request, Exception]:
+        pass
+
+
+class AfterSuccessHook(ABC):
+    @abstractmethod
+    def after_success(
+        self, hook_ctx: AfterSuccessContext, response: httpx.Response
+    ) -> Union[httpx.Response, Exception]:
+        pass
+
+
+class AfterErrorHook(ABC):
+    @abstractmethod
+    def after_error(
+        self,
+        hook_ctx: AfterErrorContext,
+        response: Optional[httpx.Response],
+        error: Optional[Exception],
+    ) -> Union[Tuple[Optional[httpx.Response], Optional[Exception]], Exception]:
+        pass
+
+
+class Hooks(ABC):
+    @abstractmethod
+    def register_sdk_init_hook(self, hook: SDKInitHook):
+        pass
+
+    @abstractmethod
+    def register_before_request_hook(self, hook: BeforeRequestHook):
+        pass
+
+    @abstractmethod
+    def register_after_success_hook(self, hook: AfterSuccessHook):
+        pass
+
+    @abstractmethod
+    def register_after_error_hook(self, hook: AfterErrorHook):
+        pass

redis_context_gateway-0.1.0a1/src/redis_context_gateway/_version.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import importlib.metadata
+
+__title__: str = "redis-context-gateway"
+__version__: str = "0.1.0-alpha.1"
+__openapi_doc_version__: str = "0.0.1"
+__gen_version__: str = "2.948.4"
+__user_agent__: str = (
+    "speakeasy-sdk/python 0.1.0-alpha.1 2.948.4 0.0.1 redis-context-gateway"
+)
+
+try:
+    if __package__ is not None:
+        __version__ = importlib.metadata.version(__package__)
+except importlib.metadata.PackageNotFoundError:
+    pass