persona-sdk-python 0.1.2__tar.gz → 0.2.3__tar.gz

persona_sdk_python-0.2.3/DEPLOY.md

@@ -0,0 +1,112 @@
+# Deploy to PyPI
+
+Operational guide for publishing `persona-sdk-python` to PyPI.
+
+Reference: same strategy used by `applica-iam-client`.
+
+---
+
+## Prerequisites
+
+### 1. PyPI account
+
+- Go to https://pypi.org/account/register/
+- If the account already exists (e.g. the one used for `applica-iam-client`), skip this step
+
+### 2. PyPI API Token
+
+1. Login at https://pypi.org
+2. Go to **Account Settings** → **API tokens**
+3. Click **Add API token**
+   - Name: `persona-sdk-python-deploy`
+   - Scope: **Entire account** (for the first release, you can restrict to the project later)
+4. Copy the token (starts with `pypi-...`) — it is shown only once
+
+### 3. Configure the token on Bitbucket
+
+1. Go to the Bitbucket repository for `persona-sdk-python`
+2. **Repository settings** → **Pipelines** → **Repository variables**
+3. Add:
+   - **Name:** `PYPI_TOKEN`
+   - **Value:** the copied token (e.g. `pypi-AgEIcH...`)
+   - **Secured:** checked
+
+---
+
+## Automated Release (Bitbucket Pipelines)
+
+Every push to `main` automatically publishes a new version.
+
+The version is computed as `0.1.{BITBUCKET_BUILD_NUMBER}`, so it auto-increments
+(e.g. build #1 → `0.1.1`, build #14 → `0.1.14`, build #203 → `0.1.203`).
+
+When you want a major/minor bump, change the prefix in `bitbucket-pipelines.yml`
+(e.g. from `0.1.` to `0.2.` or `1.0.`).
+
+### Flow:
+
+```
+git push origin main
+       │
+       ▼
+Pipeline triggers
+       │
+       ▼
+Updates version in pyproject.toml (0.1.$BUILD_NUMBER)
+       │
+       ▼
+Build (sdist + wheel)
+       │
+       ▼
+Upload to PyPI via twine with $PYPI_TOKEN
+       │
+       ▼
+Creates git tag (0.1.$BUILD_NUMBER) and pushes it
+```
+
+---
+
+## Manual Release (from local machine)
+
+If you want to publish without the pipeline, from your terminal:
+
+```bash
+cd /path/to/persona-sdk-python
+
+# 1. Update the version in pyproject.toml
+# Edit the line: version = "0.1.X"
+
+# 2. Build
+pip install build
+python -m build
+
+# 3. Upload
+pip install twine
+twine upload dist/* -u __token__ -p pypi-YOUR_TOKEN_HERE
+
+# 4. Tag
+git tag -a 0.1.X -m "0.1.X"
+git push origin 0.1.X
+```
+
+---
+
+## Verification
+
+After release, verify that the package is available:
+
+```bash
+pip install persona-sdk-python --upgrade
+```
+
+Or check at: https://pypi.org/project/persona-sdk-python/
+
+---
+
+## First Release — Checklist
+
+- [ ] PyPI account created/existing
+- [ ] API Token generated on PyPI
+- [ ] Token configured as `PYPI_TOKEN` in Bitbucket repository variables
+- [ ] Push to `main` → pipeline runs → package published
+- [ ] `pip install persona-sdk-python` works

{persona_sdk_python-0.1.2 → persona_sdk_python-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: persona-sdk-python
-Version: 0.1.2
+Version: 0.2.3
 Summary: Python SDK client for Persona AI platform
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0

persona_sdk_python-0.2.3/bitbucket-pipelines.yml

@@ -0,0 +1,17 @@
+image: python:3.12
+
+pipelines:
+  default:
+    - step:
+        name: Publish to PyPI
+        caches:
+          - pip
+        script:
+          - apt-get update && apt-get install -y git
+          - pip install build twine
+          - export VERSION=0.2.$BITBUCKET_BUILD_NUMBER
+          - sed -i "s/^version = .*/version = \"$VERSION\"/" pyproject.toml
+          - python -m build
+          - twine upload dist/* -u __token__ -p $PYPI_TOKEN
+          - git tag -a $VERSION -m "$VERSION"
+          - git push origin $VERSION

persona_sdk_python-0.2.3/persona_sdk/__init__.py

@@ -0,0 +1,100 @@
+from typing import Union
+
+from persona_sdk.api.agents import AgentsApi
+from persona_sdk.api.credentials import CredentialsApi
+from persona_sdk.api.features import FeaturesApi
+from persona_sdk.api.knowledge_bases import KnowledgeBasesApi
+from persona_sdk.api.missions import MissionsApi
+from persona_sdk.api.projects import ProjectsApi
+from persona_sdk.api.service_prices import ServicePricesApi
+from persona_sdk.api.sessions import SessionsApi
+from persona_sdk.api.triggers import TriggersApi
+from persona_sdk.api.workflows import WorkflowsApi
+from persona_sdk.auth import (
+    ApiKeyAuthenticationProvider,
+    AuthenticationProvider,
+    BearerTokenAuthenticationProvider,
+)
+from persona_sdk.client import PersonaClient
+
+__all__ = [
+    "PersonaSdk",
+    "PersonaClient",
+    "AuthenticationProvider",
+    "ApiKeyAuthenticationProvider",
+    "BearerTokenAuthenticationProvider",
+    "AgentsApi",
+    "CredentialsApi",
+    "FeaturesApi",
+    "KnowledgeBasesApi",
+    "MissionsApi",
+    "ProjectsApi",
+    "ServicePricesApi",
+    "SessionsApi",
+    "TriggersApi",
+    "WorkflowsApi",
+]
+
+
+class PersonaSdk:
+    """
+    Persona SDK facade.
+
+    Args:
+        base_url: Base URL of persona-core (e.g. https://persona.applica.guru/api).
+        auth: An ``AuthenticationProvider`` (preferred) or a plain string with
+            the API key / JWT token. Strings are wrapped in
+            ``ApiKeyAuthenticationProvider`` for backwards compatibility.
+        proxy: Optional HTTP proxy URL.
+        workflows_url: Optional separate base URL for the workflows service.
+            If provided, a second client is created using the same auth.
+        api_key: Deprecated keyword-only alias for ``auth``. Provided for
+            backwards compatibility with previous SDK versions.
+
+    Examples:
+        Using an API key (legacy)::
+
+            sdk = PersonaSdk("http://localhost:8000", "prs_my_key")
+
+        Using an IAM Bearer token::
+
+            from persona_sdk import BearerTokenAuthenticationProvider
+            sdk = PersonaSdk(
+                "http://localhost:8000",
+                BearerTokenAuthenticationProvider(jwt_token),
+            )
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        auth: Union[str, AuthenticationProvider, None] = None,
+        proxy: str = None,
+        workflows_url: str = None,
+        api_key: str = None,
+    ):
+        # Backwards compatibility: keep the legacy `api_key` keyword
+        if auth is None:
+            if api_key is None:
+                raise ValueError("Either 'auth' or 'api_key' must be provided")
+            auth = api_key
+
+        self.client = PersonaClient(base_url, auth, proxy=proxy)
+        self.workflows_client = (
+            PersonaClient(workflows_url, auth) if workflows_url else self.client
+        )
+        self.agents = AgentsApi(self.client)
+        self.workflows = WorkflowsApi(self.workflows_client)
+        self.triggers = TriggersApi(self.client)
+        self.sessions = SessionsApi(self.client)
+        self.credentials = CredentialsApi(self.client)
+        self.knowledge_bases = KnowledgeBasesApi(self.client)
+        self.projects = ProjectsApi(self.client)
+        self.features = FeaturesApi(self.client)
+        self.missions = MissionsApi(self.client)
+        self.service_prices = ServicePricesApi(self.client)
+
+    async def close(self):
+        await self.client.close()
+        if self.workflows_client is not self.client:
+            await self.workflows_client.close()

persona_sdk_python-0.2.3/persona_sdk/auth/__init__.py

@@ -0,0 +1,11 @@
+"""Authentication providers for the Persona SDK."""
+
+from persona_sdk.auth.api_key_auth import ApiKeyAuthenticationProvider
+from persona_sdk.auth.base import AuthenticationProvider
+from persona_sdk.auth.bearer_token_auth import BearerTokenAuthenticationProvider
+
+__all__ = [
+    "AuthenticationProvider",
+    "ApiKeyAuthenticationProvider",
+    "BearerTokenAuthenticationProvider",
+]

persona_sdk_python-0.2.3/persona_sdk/auth/api_key_auth.py

@@ -0,0 +1,14 @@
+"""API key authentication provider (sends x-persona-apikey header)."""
+
+from persona_sdk.auth.base import AuthenticationProvider
+
+
+class ApiKeyAuthenticationProvider(AuthenticationProvider):
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    def headers(self) -> dict[str, str]:
+        return {"x-persona-apikey": self.api_key}
+
+    def credentials(self) -> str:
+        return self.api_key

persona_sdk_python-0.2.3/persona_sdk/auth/base.py

@@ -0,0 +1,17 @@
+"""Base authentication provider interface."""
+
+from abc import ABC, abstractmethod
+
+
+class AuthenticationProvider(ABC):
+    """Abstract base class for authentication providers."""
+
+    @abstractmethod
+    def headers(self) -> dict[str, str]:
+        """Return the HTTP headers required for authentication."""
+        ...
+
+    @abstractmethod
+    def credentials(self) -> str:
+        """Return the raw credentials (api key or token)."""
+        ...

persona_sdk_python-0.2.3/persona_sdk/auth/bearer_token_auth.py

@@ -0,0 +1,14 @@
+"""Bearer token authentication provider (sends Authorization: Bearer header)."""
+
+from persona_sdk.auth.base import AuthenticationProvider
+
+
+class BearerTokenAuthenticationProvider(AuthenticationProvider):
+    def __init__(self, token: str):
+        self.token = token
+
+    def headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self.token}"}
+
+    def credentials(self) -> str:
+        return self.token

{persona_sdk_python-0.1.2 → persona_sdk_python-0.2.3}/persona_sdk/client.py

@@ -1,5 +1,12 @@
+from typing import Union
+
 import httpx
 
+from persona_sdk.auth import (
+    ApiKeyAuthenticationProvider,
+    AuthenticationProvider,
+)
+
 
 class PersonaClient:
     """
@@ -7,21 +14,42 @@ class PersonaClient:
 
     Args:
         base_url: The base URL of the Persona API (e.g. http://localhost:8000).
-        api_key: The API key or JWT token for authentication.
-            The x-persona-apikey header accepts both plain API keys and JWT tokens.
-            JWT tokens are automatically detected and validated by the server.
+        auth: An ``AuthenticationProvider`` (recommended) or a plain string
+            containing the API key / JWT token. Strings are wrapped in
+            ``ApiKeyAuthenticationProvider`` and sent as ``x-persona-apikey``
+            for backwards compatibility.
+        proxy: Optional HTTP proxy URL.
+
+    Note:
+        The ``x-persona-apikey`` header accepts both plain API keys and
+        internal MCP JWT tokens. For IAM Bearer authentication use
+        ``BearerTokenAuthenticationProvider``.
     """
 
-    def __init__(self, base_url: str, api_key: str, proxy: str = None):
+    def __init__(
+        self,
+        base_url: str,
+        auth: Union[str, AuthenticationProvider],
+        proxy: str = None,
+    ):
         self.base_url = base_url.rstrip("/")
-        self.api_key = api_key
+        if isinstance(auth, str):
+            self.auth_provider: AuthenticationProvider = ApiKeyAuthenticationProvider(auth)
+        else:
+            self.auth_provider = auth
+
         self._client = httpx.AsyncClient(
             base_url=self.base_url,
-            headers={"x-persona-apikey": self.api_key},
+            headers=self.auth_provider.headers(),
             timeout=30.0,
             proxy=proxy,
         )
 
+    @property
+    def api_key(self) -> str:
+        """Backwards-compatible alias returning the credentials string."""
+        return self.auth_provider.credentials()
+
     async def get(self, path: str, params: dict = None) -> dict:
         response = await self._client.get(path, params=params)
         response.raise_for_status()

{persona_sdk_python-0.1.2 → persona_sdk_python-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "persona-sdk-python"
-version = "0.1.2"
+version = "0.2.3"
 description = "Python SDK client for Persona AI platform"
 requires-python = ">=3.10"
 dependencies = [