pinta-ai-sdk 0.2.2__tar.gz

pinta_ai_sdk-0.2.2/.gitignore

@@ -0,0 +1,21 @@
+# 빌드 산출물
+dist/
+build/
+*.egg-info/
+
+# 파이썬
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+
+# 도구 캐시
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.poc-results/
+
+# 로컬 설정
+.env

pinta_ai_sdk-0.2.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pinta AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pinta_ai_sdk-0.2.2/PACKAGE.md

@@ -0,0 +1,110 @@
+# Pinta AI SDK for Python agents
+
+Pinta adds observability, telemetry masking and local tool-call policy evaluation
+to Python agents. LangChain integration uses middleware; no sidecar is required.
+
+**Requirements:** Python 3.12 or newer. LangChain integration requires
+`langchain >= 1.0` with `create_agent`.
+
+The distribution name is **`pinta-ai-sdk`**; the Python import remains **`pinta`**.
+It is not the unrelated `pinta` distribution on PyPI. If you installed an earlier
+private `pinta-ai` wheel, uninstall that distribution before installing this one:
+both use the same Python namespace.
+
+## Install
+
+If your application already has a compatible LangChain installation:
+
+```bash
+python -m pip install pinta-ai-sdk
+```
+
+To install LangChain dependencies as well:
+
+```bash
+python -m pip install "pinta-ai-sdk[langchain]"
+```
+
+Check the installed version and run the bundled offline self-check:
+
+```bash
+python -c "import pinta; print(pinta.__version__)"
+python -m pinta.selfcheck
+```
+
+The self-check requires LangChain. It uses a deterministic local model and
+in-memory tools, does not contact a model provider or the Pinta backend, and does
+not prove that your application's telemetry has reached the management console.
+
+## Offline installation into an existing LangChain application
+
+On an internet-connected computer using the same Python minor version as the
+target server, download the SDK and its dependencies. Replace `VERSION` with
+the selected release number:
+
+```bash
+python -m pip download "pinta-ai-sdk==VERSION" -d sdk --only-binary=:all: --platform any
+```
+
+Transfer the entire `sdk` directory through your approved file-transfer channel.
+In the target application's Python environment:
+
+```bash
+python -m pip install --no-index --find-links=sdk "pinta-ai-sdk==VERSION"
+python -m pinta.selfcheck
+```
+
+This path deliberately omits the `langchain` extra: the application already
+provides LangChain. `--platform any` accepts platform-independent wheels only,
+instead of accidentally downloading a workstation-specific native dependency.
+Installing or upgrading LangChain itself requires a separate bundle compatible
+with the server's Python version, operating system and architecture.
+
+## Connect an application
+
+Set `PINTA_BACKEND_URL` and `PINTA_API_KEY` in the application process using your
+organization's approved endpoint and secret-management mechanism. Start with
+`PINTA_GUARD_MODE=monitor`; switch to `enforce` only after reviewing policies and
+normal application behavior.
+
+At process startup, configure Pinta. Add middleware at the agent factory and
+provide the authenticated application's user identity around each invocation:
+
+```python
+from langchain.agents import create_agent
+from pinta import PintaSettings, configure, get_runtime, pinta_context
+from pinta.langchain import PintaMiddleware
+
+configure(PintaSettings.from_env())
+agent = create_agent(model, tools=tools, middleware=[PintaMiddleware()])
+
+async def answer(user, session_id, messages):
+    async with pinta_context(
+        user_id=user.id, user_email=user.email, session_id=session_id,
+    ):
+        return await agent.ainvoke({"messages": messages})
+
+# In the application's async shutdown hook:
+# await get_runtime().ashutdown()
+```
+
+Here `model`, `tools` and `user` are supplied by your application. Installation
+alone does not instrument an agent or enable telemetry transmission. Outbound
+HTTPS to the configured Pinta endpoint is required for export and policy refresh;
+local evaluation and the self-check do not require that connection.
+
+## Scope and limitations
+
+- Masking protects Pinta telemetry, not original business inputs, tool results
+  or prompts sent to a model provider.
+- `monitor` evaluates without blocking. `enforce` blocks `DENY` and `REVIEW`
+  before the selected tool handler executes.
+- Policy evaluation errors fail open with diagnostics; masking errors redact
+  the affected telemetry value and are reported as failures.
+- Detection depends on configured policies and supported input shapes.
+  This SDK is not universally equivalent to every TypeScript runtime extractor
+  and does not guarantee detection of every credential or unsafe action.
+- Treat this alpha SDK as a version-pinned integration and validate your own
+  normal and violation cases before enforcement.
+
+MIT licensed. Learn more at [pinta.sh](https://pinta.sh).

pinta_ai_sdk-0.2.2/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.5
+Name: pinta-ai-sdk
+Version: 0.2.2
+Summary: Pinta AI runtime guard adaptor for Python agents (OpenTelemetry spans + tool-call guard)
+Project-URL: Homepage, https://pinta.sh
+Project-URL: Documentation, https://pypi.org/project/pinta-ai-sdk/
+Author: Pinta AI
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-spm,guardrails,langchain,observability,opentelemetry,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: opentelemetry-api>=1.44
+Requires-Dist: opentelemetry-sdk>=1.44
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=1.0; extra == 'langchain'
+Requires-Dist: langchain>=1.0; extra == 'langchain'
+Provides-Extra: poc
+Requires-Dist: langchain-core>=1.0; extra == 'poc'
+Requires-Dist: langchain-mcp-adapters<0.3,>=0.2.2; extra == 'poc'
+Requires-Dist: langchain>=1.0; extra == 'poc'
+Requires-Dist: langsmith<1,>=0.12; extra == 'poc'
+Requires-Dist: mcp<2,>=1.30; extra == 'poc'
+Description-Content-Type: text/markdown
+
+# Pinta AI SDK for Python agents
+
+Pinta adds observability, telemetry masking and local tool-call policy evaluation
+to Python agents. LangChain integration uses middleware; no sidecar is required.
+
+**Requirements:** Python 3.12 or newer. LangChain integration requires
+`langchain >= 1.0` with `create_agent`.
+
+The distribution name is **`pinta-ai-sdk`**; the Python import remains **`pinta`**.
+It is not the unrelated `pinta` distribution on PyPI. If you installed an earlier
+private `pinta-ai` wheel, uninstall that distribution before installing this one:
+both use the same Python namespace.
+
+## Install
+
+If your application already has a compatible LangChain installation:
+
+```bash
+python -m pip install pinta-ai-sdk
+```
+
+To install LangChain dependencies as well:
+
+```bash
+python -m pip install "pinta-ai-sdk[langchain]"
+```
+
+Check the installed version and run the bundled offline self-check:
+
+```bash
+python -c "import pinta; print(pinta.__version__)"
+python -m pinta.selfcheck
+```
+
+The self-check requires LangChain. It uses a deterministic local model and
+in-memory tools, does not contact a model provider or the Pinta backend, and does
+not prove that your application's telemetry has reached the management console.
+
+## Offline installation into an existing LangChain application
+
+On an internet-connected computer using the same Python minor version as the
+target server, download the SDK and its dependencies. Replace `VERSION` with
+the selected release number:
+
+```bash
+python -m pip download "pinta-ai-sdk==VERSION" -d sdk --only-binary=:all: --platform any
+```
+
+Transfer the entire `sdk` directory through your approved file-transfer channel.
+In the target application's Python environment:
+
+```bash
+python -m pip install --no-index --find-links=sdk "pinta-ai-sdk==VERSION"
+python -m pinta.selfcheck
+```
+
+This path deliberately omits the `langchain` extra: the application already
+provides LangChain. `--platform any` accepts platform-independent wheels only,
+instead of accidentally downloading a workstation-specific native dependency.
+Installing or upgrading LangChain itself requires a separate bundle compatible
+with the server's Python version, operating system and architecture.
+
+## Connect an application
+
+Set `PINTA_BACKEND_URL` and `PINTA_API_KEY` in the application process using your
+organization's approved endpoint and secret-management mechanism. Start with
+`PINTA_GUARD_MODE=monitor`; switch to `enforce` only after reviewing policies and
+normal application behavior.
+
+At process startup, configure Pinta. Add middleware at the agent factory and
+provide the authenticated application's user identity around each invocation:
+
+```python
+from langchain.agents import create_agent
+from pinta import PintaSettings, configure, get_runtime, pinta_context
+from pinta.langchain import PintaMiddleware
+
+configure(PintaSettings.from_env())
+agent = create_agent(model, tools=tools, middleware=[PintaMiddleware()])
+
+async def answer(user, session_id, messages):
+    async with pinta_context(
+        user_id=user.id, user_email=user.email, session_id=session_id,
+    ):
+        return await agent.ainvoke({"messages": messages})
+
+# In the application's async shutdown hook:
+# await get_runtime().ashutdown()
+```
+
+Here `model`, `tools` and `user` are supplied by your application. Installation
+alone does not instrument an agent or enable telemetry transmission. Outbound
+HTTPS to the configured Pinta endpoint is required for export and policy refresh;
+local evaluation and the self-check do not require that connection.
+
+## Scope and limitations
+
+- Masking protects Pinta telemetry, not original business inputs, tool results
+  or prompts sent to a model provider.
+- `monitor` evaluates without blocking. `enforce` blocks `DENY` and `REVIEW`
+  before the selected tool handler executes.
+- Policy evaluation errors fail open with diagnostics; masking errors redact
+  the affected telemetry value and are reported as failures.
+- Detection depends on configured policies and supported input shapes.
+  This SDK is not universally equivalent to every TypeScript runtime extractor
+  and does not guarantee detection of every credential or unsafe action.
+- Treat this alpha SDK as a version-pinned integration and validate your own
+  normal and violation cases before enforcement.
+
+MIT licensed. Learn more at [pinta.sh](https://pinta.sh).

pinta_ai_sdk-0.2.2/pyproject.toml

@@ -0,0 +1,87 @@
+[project]
+name = "pinta-ai-sdk"
+version = "0.2.2"
+description = "Pinta AI runtime guard adaptor for Python agents (OpenTelemetry spans + tool-call guard)"
+readme = "PACKAGE.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Pinta AI" }]
+keywords = ["langchain", "opentelemetry", "observability", "ai-spm", "guardrails", "security"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Security",
+    "Topic :: System :: Monitoring",
+    "Typing :: Typed",
+]
+dependencies = [
+    "opentelemetry-api>=1.44",
+    "opentelemetry-sdk>=1.44",
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+langchain = ["langchain>=1.0", "langchain-core>=1.0"]
+poc = [
+    "langchain>=1.0",
+    "langchain-core>=1.0",
+    "langsmith>=0.12,<1",
+    "mcp>=1.30,<2",
+    "langchain-mcp-adapters>=0.2.2,<0.3",
+]
+
+[project.urls]
+Homepage = "https://pinta.sh"
+Documentation = "https://pypi.org/project/pinta-ai-sdk/"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3",
+    "pytest-asyncio>=0.24",
+    "ruff>=0.6",
+    "mypy>=1.11",
+    "starlette>=0.40",
+    "deepagents>=0.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pinta"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/pinta",
+    "PACKAGE.md",
+    "LICENSE",
+    "pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+mypy_path = "src"
+packages = ["pinta"]
+
+[[tool.mypy.overrides]]
+module = ["langchain.*", "langchain_core.*", "langgraph.*"]
+ignore_missing_imports = true

pinta_ai_sdk-0.2.2/src/pinta/__init__.py

@@ -0,0 +1,50 @@
+"""Pinta AI adaptor for Python agents.
+
+Quickstart::
+
+    from pinta import configure, PintaSettings, pinta_context
+
+    runtime = configure(PintaSettings.from_env())
+    async with pinta_context(user_id="u1", user_email="a@corp.com", session_id="s1"):
+        ...  # every span in here shares one trace
+"""
+
+from pinta._version import __version__
+from pinta.core.config import PintaSettings
+from pinta.core.context import Identity, current_identity, pinta_context
+from pinta.core.guard import GuardClient, GuardDecision, GuardInput
+from pinta.core.propagation import Propagated, extract_propagation, outbound_headers
+from pinta.core.runtime import PintaRuntime, configure, get_runtime
+
+
+def instrument() -> list[str]:
+    """Patch agent factories so every agent gets PintaMiddleware (see ``pinta.auto``)."""
+    from pinta.auto import instrument as _instrument
+
+    return _instrument()
+
+
+def uninstrument() -> None:
+    from pinta.auto import uninstrument as _uninstrument
+
+    _uninstrument()
+
+
+__all__ = [
+    "GuardClient",
+    "GuardDecision",
+    "GuardInput",
+    "Identity",
+    "PintaRuntime",
+    "PintaSettings",
+    "Propagated",
+    "__version__",
+    "configure",
+    "current_identity",
+    "extract_propagation",
+    "get_runtime",
+    "instrument",
+    "outbound_headers",
+    "pinta_context",
+    "uninstrument",
+]

pinta_ai_sdk-0.2.2/src/pinta/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.2"

pinta_ai_sdk-0.2.2/src/pinta/asgi.py

@@ -0,0 +1,114 @@
+"""ASGI middleware that opens ``pinta_context`` for every HTTP request.
+
+Pure ASGI (no Starlette dependency): the ``resolver`` receives a ``starlette.requests.Request``
+when Starlette is installed, else the raw ASGI ``scope``. It returns an ``Identity`` (or a
+mapping of ``pinta_context`` keyword arguments), ``None`` to leave the request anonymous, and
+may be sync or async. Errors in the resolver are logged and the request continues anonymous.
+
+    app.add_middleware(PintaIdentityMiddleware, resolver=lambda req: Identity(
+        user_id=req.state.user.id, user_email=req.state.user.email,
+        session_id=req.headers.get("x-thread-id"),
+    ))
+
+Register it *before* the authentication middleware (Starlette wraps later ``add_middleware``
+calls outside earlier ones), so authentication has run when the resolver reads the user.
+Background jobs and queue workers have no request: wrap those in ``pinta_context`` yourself.
+
+``propagate=True``: for requests the resolver trusts with an identity, read the W3C
+``traceparent``/``baggage`` headers so the root span joins the caller's trace. Identity itself
+is never taken from headers — only trace linkage and the calling agent are, and only once the
+resolver has already declared the request trusted. ``propagate`` may also be a callable that
+decides per request (e.g. only the A2A endpoint) — it receives the same request object the
+resolver does and is consulted only when the resolver returned an identity.
+"""
+
+from __future__ import annotations
+
+import inspect
+import logging
+from collections.abc import Awaitable, Callable, Mapping
+from typing import Any
+
+from pinta.core.context import Identity, pinta_context
+from pinta.core.propagation import Propagated, extract_propagation
+
+log = logging.getLogger("pinta.asgi")
+
+Resolved = Identity | Mapping[str, Any] | None
+Resolver = Callable[[Any], Resolved | Awaitable[Resolved]]
+
+
+def _request_for(scope: dict[str, Any], receive: Any) -> Any:
+    try:
+        from starlette.requests import Request
+    except ImportError:  # pragma: no cover - starlette is optional
+        return scope
+    return Request(scope, receive)
+
+
+def _headers(scope: dict[str, Any]) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for raw_key, raw_value in scope.get("headers") or ():
+        out[bytes(raw_key).decode("latin-1").lower()] = bytes(raw_value).decode("latin-1")
+    return out
+
+
+class PintaIdentityMiddleware:
+    def __init__(
+        self,
+        app: Any,
+        resolver: Resolver,
+        *,
+        propagate: bool | Callable[[Any], bool] = False,
+    ) -> None:
+        self.app = app
+        self.resolver = resolver
+        self.propagate = propagate
+
+    async def _resolve(self, request: Any) -> Identity | None:
+        try:
+            result = self.resolver(request)
+            if inspect.isawaitable(result):
+                result = await result
+        except Exception:  # noqa: BLE001 - never break the request because of us
+            log.exception("pinta: identity resolver failed; request stays anonymous")
+            return None
+        if result is None:
+            return None
+        if isinstance(result, Identity):
+            return result
+        return Identity(**dict(result))
+
+    def _should_propagate(self, request: Any) -> bool:
+        if not callable(self.propagate):
+            return bool(self.propagate)
+        try:
+            return bool(self.propagate(request))
+        except Exception:  # noqa: BLE001 - never break the request because of us
+            log.exception("pinta: propagate predicate failed; request joins no trace")
+            return False
+
+    async def __call__(self, scope: dict[str, Any], receive: Any, send: Any) -> None:
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+        request = _request_for(scope, receive)
+        identity = await self._resolve(request)
+        if identity is None:
+            await self.app(scope, receive, send)
+            return
+        parent: Propagated | None = None
+        if self._should_propagate(request):
+            parent = extract_propagation(_headers(scope))
+        async with pinta_context(
+            user_id=identity.user_id,
+            user_email=identity.user_email,
+            session_id=identity.session_id,
+            conversation_id=identity.conversation_id,
+            attributes=identity.attributes,
+            parent=parent,
+        ):
+            await self.app(scope, receive, send)
+
+
+__all__ = ["PintaIdentityMiddleware", "Resolver"]

pinta_ai_sdk-0.2.2/src/pinta/auto.py

@@ -0,0 +1,117 @@
+"""Zero-touch instrumentation: patch the agent factories so every agent gets ``PintaMiddleware``.
+
+    import pinta
+    pinta.instrument()   # before the modules that build agents are imported
+
+Patches ``langchain.agents.create_agent`` (and its defining module) and, when deepagents is
+installed, ``deepagents.create_deep_agent`` — giving every ``SubAgent`` its own middleware with
+``agent={"name": ..., "kind": "subagent"}`` and the parent a ``subagents=[...]`` list so the
+manifest and the delegation edges are complete. Agents that already carry a ``PintaMiddleware``
+are left alone. ``uninstrument()`` restores the originals.
+
+Caveat of any monkeypatch: a module that did ``from langchain.agents import create_agent``
+*before* ``instrument()`` keeps the original function. Call ``instrument()`` first thing in the
+process (or use the explicit ``middleware=[PintaMiddleware()]`` form, which is the default
+recommendation).
+"""
+
+from __future__ import annotations
+
+import functools
+import importlib
+import logging
+from collections.abc import Callable, Sequence
+from typing import Any
+
+from pinta.langchain.middleware import PintaMiddleware
+
+log = logging.getLogger("pinta.instrument")
+
+_PATCHED: dict[tuple[str, str], Callable[..., Any]] = {}
+
+
+def _has_pinta(middleware: Sequence[Any] | None) -> bool:
+    return any(isinstance(m, PintaMiddleware) for m in middleware or ())
+
+
+def _with_pinta(middleware: Sequence[Any] | None, **kwargs: Any) -> list[Any]:
+    items = list(middleware or ())
+    if not _has_pinta(items):
+        items.append(PintaMiddleware(**kwargs))
+    return items
+
+
+def _wrap_create_agent(original: Callable[..., Any]) -> Callable[..., Any]:
+    @functools.wraps(original)
+    def create_agent(*args: Any, **kwargs: Any) -> Any:
+        kwargs["middleware"] = _with_pinta(kwargs.get("middleware"))
+        return original(*args, **kwargs)
+
+    return create_agent
+
+
+def _wrap_create_deep_agent(original: Callable[..., Any]) -> Callable[..., Any]:
+    @functools.wraps(original)
+    def create_deep_agent(*args: Any, **kwargs: Any) -> Any:
+        subagents = kwargs.get("subagents") or []
+        names: list[str] = []
+        patched: list[Any] = []
+        for sub in subagents:
+            if isinstance(sub, dict):
+                name = str(sub.get("name") or "")
+                names.append(name)
+                sub = {
+                    **sub,
+                    "middleware": _with_pinta(
+                        sub.get("middleware"), agent={"name": name, "kind": "subagent"}
+                    ),
+                }
+            patched.append(sub)
+        if subagents:
+            kwargs["subagents"] = patched
+        kwargs["middleware"] = _with_pinta(kwargs.get("middleware"), subagents=names)
+        return original(*args, **kwargs)
+
+    return create_deep_agent
+
+
+def _patch(
+    module_name: str, attr: str, wrap: Callable[[Callable[..., Any]], Callable[..., Any]]
+) -> None:
+    key = (module_name, attr)
+    if key in _PATCHED:
+        return
+    try:
+        module = importlib.import_module(module_name)
+    except ImportError:
+        return
+    original = getattr(module, attr, None)
+    if original is None:
+        return
+    _PATCHED[key] = original
+    setattr(module, attr, wrap(original))
+
+
+def instrument() -> list[str]:
+    """Patch the factories. Returns the fully-qualified names that were patched (idempotent)."""
+    for module_name in ("langchain.agents", "langchain.agents.factory"):
+        _patch(module_name, "create_agent", _wrap_create_agent)
+    for module_name in ("deepagents", "deepagents.graph"):
+        _patch(module_name, "create_deep_agent", _wrap_create_deep_agent)
+    names = [f"{m}.{a}" for m, a in _PATCHED]
+    log.info("pinta: instrumented %s", ", ".join(names) or "nothing")
+    return names
+
+
+def uninstrument() -> None:
+    """Restore every patched factory."""
+    for (module_name, attr), original in list(_PATCHED.items()):
+        setattr(importlib.import_module(module_name), attr, original)
+        del _PATCHED[(module_name, attr)]
+
+
+def is_instrumented() -> bool:
+    return bool(_PATCHED)
+
+
+__all__ = ["instrument", "is_instrumented", "uninstrument"]

pinta_ai_sdk-0.2.2/src/pinta/core/__init__.py

@@ -0,0 +1 @@
+"""Framework-free core: settings, identity context, guard client, span recorder, exporter."""