persona-sdk-python 0.2.18__tar.gz → 0.2.20__tar.gz

{persona_sdk_python-0.2.18 → persona_sdk_python-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: persona-sdk-python
-Version: 0.2.18
+Version: 0.2.20
 Summary: Async Python SDK for the Persona AI platform
 Project-URL: Homepage, https://persona.applica.guru
 Project-URL: Repository, https://bitbucket.org/applicaguru/persona-sdk-python

persona_sdk_python-0.2.20/bitbucket-pipelines.yml

@@ -0,0 +1,18 @@
+image: python:3.12
+
+pipelines:
+  branches:
+    main:
+      - 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.18 → persona_sdk_python-0.2.20}/persona_sdk/__init__.py

@@ -3,14 +3,16 @@ 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.known_models import KnownModelsApi
 from persona_sdk.api.knowledge_bases import KnowledgeBasesApi
+from persona_sdk.api.markup_rules import MarkupRulesApi
 from persona_sdk.api.missions import MissionsApi
 from persona_sdk.api.projects import ProjectsApi
+from persona_sdk.api.providers import ProvidersApi
 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.api.human_tasks import HumanTasksApi
 from persona_sdk.auth import (
     ApiKeyAuthenticationProvider,
     AuthenticationProvider,
@@ -30,10 +32,11 @@ from persona_models.knowledge_bases import (
     KnowledgeBaseDocument,
     SearchChunksRequest,
 )
-from persona_models.known_models import KnownModel
+from persona_models.markup import MarkupRule
 from persona_models.mcp import GenerationRequest
 from persona_models.missions import CreateMissionRequest, Mission
 from persona_models.projects import Project
+from persona_models.providers import Provider, ProviderModel
 from persona_models.service_prices import ServicePrice, UsageCost
 from persona_models.sessions import GenerationResponse, Message, Session
 from persona_models.triggers import Trigger, TriggerExecutionResult
@@ -48,14 +51,16 @@ __all__ = [
     "AgentsApi",
     "CredentialsApi",
     "FeaturesApi",
-    "KnownModelsApi",
     "KnowledgeBasesApi",
+    "MarkupRulesApi",
     "MissionsApi",
     "ProjectsApi",
+    "ProvidersApi",
     "ServicePricesApi",
     "SessionsApi",
     "TriggersApi",
     "WorkflowsApi",
+    "HumanTasksApi",
     # Domain models (re-exported from persona-models)
     "Paginated",
     "AgentConfiguration",
@@ -66,12 +71,14 @@ __all__ = [
     "KnowledgeBase",
     "KnowledgeBaseDocument",
     "SearchChunksRequest",
-    "KnownModel",
     "GenerationRequest",
     "GenerationResponse",
     "CreateMissionRequest",
     "Mission",
     "Project",
+    "Provider",
+    "ProviderModel",
+    "MarkupRule",
     "ServicePrice",
     "UsageCost",
     "Message",
@@ -131,6 +138,7 @@ class PersonaSdk:
         )
         self.agents = AgentsApi(self.client)
         self.workflows = WorkflowsApi(self.workflows_client)
+        self.human_tasks = HumanTasksApi(self.workflows_client)
         self.triggers = TriggersApi(self.client)
         self.sessions = SessionsApi(self.client)
         self.credentials = CredentialsApi(self.client)
@@ -139,7 +147,8 @@ class PersonaSdk:
         self.features = FeaturesApi(self.client)
         self.missions = MissionsApi(self.client)
         self.service_prices = ServicePricesApi(self.client)
-        self.known_models = KnownModelsApi(self.client)
+        self.providers = ProvidersApi(self.client)
+        self.markup_rules = MarkupRulesApi(self.client)
 
     async def close(self):
         await self.client.close()

persona_sdk_python-0.2.20/persona_sdk/api/human_tasks.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Any
+
+from persona_sdk.client import PersonaClient
+
+
+class HumanTasksApi:
+    """
+    Human-in-the-loop tasks. A task is created when a workflow step
+    suspends waiting for a human (a declared ``human`` node or an agent
+    escalation); responding to it resumes the run.
+
+    Lives on the workflows service (same client as ``WorkflowsApi``).
+    Tasks are returned as plain dicts — the contract is owned by the
+    workflows service and intentionally not constrained here.
+    """
+
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(
+        self,
+        status: str | None = "pending",
+        assignee: str | None = None,
+        workflow_id: str | None = None,
+        execution_id: str | None = None,
+        page: int = 1,
+        size: int = 50,
+    ) -> dict[str, Any]:
+        """The project's human-task inbox (``Paginated[HumanTask]`` shape)."""
+        params: dict[str, Any] = {"page": page, "size": size}
+        if status:
+            params["status"] = status
+        if assignee:
+            params["assignee"] = assignee
+        if workflow_id:
+            params["workflowId"] = workflow_id
+        if execution_id:
+            params["executionId"] = execution_id
+        return await self._client.get("/human-tasks", params=params)
+
+    async def respond(
+        self,
+        human_task_id: str,
+        response: Any,
+        responded_by: str | None = None,
+    ) -> dict[str, Any]:
+        """Answer a pending human task and resume the suspended execution."""
+        body: dict[str, Any] = {"response": response}
+        if responded_by:
+            body["respondedBy"] = responded_by
+        return await self._client.post(
+            f"/human-tasks/{human_task_id}/respond", json=body
+        )

persona_sdk_python-0.2.20/persona_sdk/api/markup_rules.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Any
+
+from persona_models.common import Paginated
+from persona_models.markup import MarkupRule
+
+from persona_sdk._serde import dump_payload
+from persona_sdk.client import PersonaClient
+
+
+class MarkupRulesApi:
+    """Global markup rules (super admin)."""
+
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(
+        self, keyword: str | None = None, page: int = 1, size: int = 50
+    ) -> Paginated[MarkupRule]:
+        params: dict[str, Any] = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        data = await self._client.get("/markup-rules", params=params)
+        return Paginated[MarkupRule].model_validate(data)
+
+    async def get(self, markup_rule_id: str) -> MarkupRule:
+        data = await self._client.get(f"/markup-rules/{markup_rule_id}")
+        return MarkupRule.model_validate(data)
+
+    async def create(self, markup_rule: MarkupRule | dict[str, Any]) -> MarkupRule:
+        data = await self._client.post("/markup-rules", json=dump_payload(markup_rule))
+        return MarkupRule.model_validate(data)
+
+    async def update(
+        self, markup_rule_id: str, markup_rule: MarkupRule | dict[str, Any]
+    ) -> MarkupRule:
+        data = await self._client.put(
+            f"/markup-rules/{markup_rule_id}", json=dump_payload(markup_rule)
+        )
+        return MarkupRule.model_validate(data)
+
+    async def delete(self, markup_rule_id: str) -> None:
+        await self._client.delete(f"/markup-rules/{markup_rule_id}")

persona_sdk_python-0.2.20/persona_sdk/api/providers.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Any
+
+from persona_models.common import Paginated
+from persona_models.providers import Provider, ProviderModel
+
+from persona_sdk._serde import dump_payload
+from persona_sdk.client import PersonaClient
+
+
+class ProvidersApi:
+    """Managed LLM providers (super admin). Global or per-project; api keys are
+    stored encrypted and returned masked."""
+
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(
+        self,
+        project_id: str | None = None,
+        keyword: str | None = None,
+        page: int = 1,
+        size: int = 100,
+    ) -> Paginated[Provider]:
+        params: dict[str, Any] = {"page": page, "size": size}
+        if project_id:
+            params["projectId"] = project_id
+        if keyword:
+            params["keyword"] = keyword
+        data = await self._client.get("/providers", params=params)
+        return Paginated[Provider].model_validate(data)
+
+    async def get(self, provider_id: str) -> Provider:
+        data = await self._client.get(f"/providers/{provider_id}")
+        return Provider.model_validate(data)
+
+    async def create(self, provider: Provider | dict[str, Any]) -> Provider:
+        data = await self._client.post("/providers", json=dump_payload(provider))
+        return Provider.model_validate(data)
+
+    async def update(
+        self, provider_id: str, provider: Provider | dict[str, Any]
+    ) -> Provider:
+        data = await self._client.put(
+            f"/providers/{provider_id}", json=dump_payload(provider)
+        )
+        return Provider.model_validate(data)
+
+    async def delete(self, provider_id: str) -> None:
+        await self._client.delete(f"/providers/{provider_id}")
+
+    async def available(self) -> list[str]:
+        """Provider names litellm supports (for the 'add provider' picker). Admin."""
+        return await self._client.get("/providers/available")
+
+    async def names(self) -> list[str]:
+        """Names of providers configured for the caller (global + their project),
+        no credentials. Authenticated (not admin) — for the model selector."""
+        return await self._client.get("/provider-names")
+
+    async def models(self, provider: str) -> list[ProviderModel]:
+        """Model suggestions (chat, with capabilities) for a provider, from litellm."""
+        data = await self._client.get("/provider-models", params={"provider": provider})
+        return [ProviderModel.model_validate(m) for m in data]

persona_sdk_python-0.2.20/persona_sdk/api/workflows.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+from typing import Any
+
+from persona_models.common import Paginated
+from persona_models.workflows import Workflow
+
+from persona_sdk._serde import dump_payload
+from persona_sdk.client import PersonaClient
+
+
+class WorkflowsApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(
+        self, keyword: str | None = None, page: int = 1, size: int = 20
+    ) -> Paginated[Workflow]:
+        params: dict[str, Any] = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        data = await self._client.get("/workflows", params=params)
+        return Paginated[Workflow].model_validate(data)
+
+    async def get(self, workflow_id: str) -> Workflow:
+        data = await self._client.get(f"/workflows/{workflow_id}")
+        return Workflow.model_validate(data)
+
+    async def create(self, workflow: Workflow | dict[str, Any]) -> Workflow:
+        data = await self._client.post("/workflows", json=dump_payload(workflow))
+        return Workflow.model_validate(data)
+
+    async def update(
+        self, workflow_id: str, workflow: Workflow | dict[str, Any]
+    ) -> Workflow:
+        data = await self._client.put(
+            f"/workflows/{workflow_id}", json=dump_payload(workflow)
+        )
+        return Workflow.model_validate(data)
+
+    async def delete(self, workflow_id: str) -> dict[str, Any]:
+        return await self._client.delete(f"/workflows/{workflow_id}")
+
+    # ------------------------------------------------------------------ #
+    # Executions
+    #
+    # Executions, human tasks, traces and stats are returned as plain
+    # dicts: the execution contract is owned by the workflows service and
+    # intentionally not constrained here.
+    # ------------------------------------------------------------------ #
+
+    def _run_body(
+        self,
+        data: dict[str, Any] | None,
+        user_id: str | None,
+        callback_url: str | None,
+        events_hook: str | None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"initialData": data or {}}
+        if user_id:
+            body["userId"] = user_id
+        if callback_url:
+            body["callbackUrl"] = callback_url
+        if events_hook:
+            body["eventsHook"] = events_hook
+        return body
+
+    async def execute(
+        self,
+        workflow_id: str,
+        data: dict[str, Any] | None = None,
+        user_id: str | None = None,
+        callback_url: str | None = None,
+        events_hook: str | None = None,
+    ) -> dict[str, Any]:
+        """Run a workflow synchronously (returns when terminal or suspended)."""
+        return await self._client.post(
+            f"/workflows/{workflow_id}/executions",
+            json=self._run_body(data, user_id, callback_url, events_hook),
+        )
+
+    async def queue(
+        self,
+        workflow_id: str,
+        data: dict[str, Any] | None = None,
+        user_id: str | None = None,
+        callback_url: str | None = None,
+        events_hook: str | None = None,
+    ) -> dict[str, Any]:
+        """Queue a workflow for asynchronous execution (returns an ``Execution``)."""
+        return await self._client.post(
+            f"/workflows/{workflow_id}/executions/queue",
+            json=self._run_body(data, user_id, callback_url, events_hook),
+        )
+
+    async def list_executions(
+        self, workflow_id: str, page: int = 1, size: int = 20
+    ) -> dict[str, Any]:
+        """List executions for a workflow (``Paginated[Execution]`` shape)."""
+        params: dict[str, Any] = {"page": page, "size": size}
+        return await self._client.get(
+            f"/workflows/{workflow_id}/executions", params=params
+        )
+
+    async def get_execution(
+        self, workflow_id: str, execution_id: str
+    ) -> dict[str, Any]:
+        """Get a single execution (run) with its steps, status and outputs."""
+        return await self._client.get(
+            f"/workflows/{workflow_id}/executions/{execution_id}"
+        )
+
+    async def list_runs(
+        self,
+        status: str | None = None,
+        workflow_id: str | None = None,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        page: int = 1,
+        size: int = 20,
+    ) -> dict[str, Any]:
+        """List runs across all workflows in the project."""
+        params: dict[str, Any] = {"page": page, "size": size}
+        if status:
+            params["status"] = status
+        if workflow_id:
+            params["workflowId"] = workflow_id
+        if date_from:
+            params["dateFrom"] = date_from
+        if date_to:
+            params["dateTo"] = date_to
+        return await self._client.get("/executions", params=params)
+
+    async def cancel_execution(
+        self, workflow_id: str, execution_id: str
+    ) -> dict[str, Any]:
+        """Request cancellation of a running/waiting execution."""
+        return await self._client.post(
+            f"/workflows/{workflow_id}/executions/{execution_id}/cancel", json={}
+        )
+
+    async def rerun_execution(
+        self,
+        workflow_id: str,
+        execution_id: str,
+        from_node_id: str,
+        mode: str = "reuse_outputs",
+        user_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Re-run an execution from a given node. mode: 'reuse_outputs' | 'fresh'."""
+        body: dict[str, Any] = {"fromNodeId": from_node_id, "mode": mode}
+        if user_id:
+            body["userId"] = user_id
+        return await self._client.post(
+            f"/workflows/{workflow_id}/executions/{execution_id}/rerun", json=body
+        )
+
+    async def dry_run_node(
+        self,
+        workflow_id: str,
+        node_id: str,
+        inputs: dict[str, Any] | None = None,
+        user_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Execute a single node in isolation with the given inputs (debugging)."""
+        body: dict[str, Any] = {"inputs": inputs or {}}
+        if user_id:
+            body["userId"] = user_id
+        return await self._client.post(
+            f"/workflows/{workflow_id}/nodes/{node_id}/dry-run", json=body
+        )
+
+    async def get_step_trace(
+        self,
+        workflow_id: str,
+        execution_id: str,
+        step_id: str,
+        page: int = 1,
+        size: int = 200,
+    ) -> dict[str, Any]:
+        """Normalized action trace of an agent step (reasoning, tool calls, messages)."""
+        params: dict[str, Any] = {"page": page, "size": size}
+        return await self._client.get(
+            f"/workflows/{workflow_id}/executions/{execution_id}/steps/{step_id}/trace",
+            params=params,
+        )
+
+    # ------------------------------------------------------------------ #
+    # Stats
+    # ------------------------------------------------------------------ #
+
+    async def stats_overview(self) -> dict[str, Any]:
+        return await self._client.get("/stats/overview")
+
+    async def stats_executions_timeseries(
+        self,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        workflow_id: str | None = None,
+        bucket: str = "day",
+    ) -> Any:
+        params: dict[str, Any] = {"bucket": bucket}
+        if date_from:
+            params["dateFrom"] = date_from
+        if date_to:
+            params["dateTo"] = date_to
+        if workflow_id:
+            params["workflowId"] = workflow_id
+        return await self._client.get("/stats/executions/timeseries", params=params)
+
+    async def stats_failing_nodes(
+        self,
+        date_from: str | None = None,
+        workflow_id: str | None = None,
+        limit: int = 10,
+    ) -> Any:
+        params: dict[str, Any] = {"limit": limit}
+        if date_from:
+            params["dateFrom"] = date_from
+        if workflow_id:
+            params["workflowId"] = workflow_id
+        return await self._client.get(
+            "/stats/executions/failing-nodes", params=params
+        )
+
+    async def stats_human_response_times(
+        self, date_from: str | None = None
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {}
+        if date_from:
+            params["dateFrom"] = date_from
+        return await self._client.get(
+            "/stats/human-tasks/response-times", params=params
+        )

{persona_sdk_python-0.2.18 → persona_sdk_python-0.2.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "persona-sdk-python"
-version = "0.2.18"
+version = "0.2.20"
 description = "Async Python SDK for the Persona AI platform"
 readme = "README.md"
 requires-python = ">=3.10"

{persona_sdk_python-0.2.18 → persona_sdk_python-0.2.20}/uv.lock

@@ -116,7 +116,7 @@ dependencies = [
 [package.metadata]
 requires-dist = [
     { name = "httpx", specifier = ">=0.27.0" },
-    { name = "persona-models", specifier = ">=0.2.2" },
+    { name = "persona-models", specifier = ">=0.2.4" },
 ]
 
 [[package]]
@@ -226,14 +226,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906 },
     { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607 },
     { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769 },
-    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441 },
-    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291 },
-    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632 },
-    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905 },
-    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495 },
-    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388 },
-    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879 },
-    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017 },
     { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351 },
     { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363 },
     { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615 },

persona_sdk_python-0.2.18/bitbucket-pipelines.yml

@@ -1,17 +0,0 @@
-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.18/persona_sdk/api/known_models.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from persona_models.common import Paginated
-from persona_models.known_models import KnownModel
-
-from persona_sdk._serde import dump_payload
-from persona_sdk.client import PersonaClient
-
-
-class KnownModelsApi:
-    def __init__(self, client: PersonaClient):
-        self._client = client
-
-    async def list(
-        self, keyword: str | None = None, page: int = 1, size: int = 100
-    ) -> Paginated[KnownModel]:
-        params: dict[str, Any] = {"page": page, "size": size}
-        if keyword:
-            params["keyword"] = keyword
-        data = await self._client.get("/known-models", params=params)
-        return Paginated[KnownModel].model_validate(data)
-
-    async def get(self, known_model_id: str) -> KnownModel:
-        data = await self._client.get(f"/known-models/{known_model_id}")
-        return KnownModel.model_validate(data)
-
-    async def create(
-        self, known_model: KnownModel | dict[str, Any]
-    ) -> KnownModel:
-        data = await self._client.post(
-            "/known-models", json=dump_payload(known_model)
-        )
-        return KnownModel.model_validate(data)
-
-    async def update(
-        self,
-        known_model_id: str,
-        known_model: KnownModel | dict[str, Any],
-    ) -> KnownModel:
-        data = await self._client.put(
-            f"/known-models/{known_model_id}", json=dump_payload(known_model)
-        )
-        return KnownModel.model_validate(data)
-
-    async def delete(self, known_model_id: str) -> KnownModel:
-        data = await self._client.delete(f"/known-models/{known_model_id}")
-        return KnownModel.model_validate(data)

persona_sdk_python-0.2.18/persona_sdk/api/workflows.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from persona_models.common import Paginated
-from persona_models.workflows import Workflow
-
-from persona_sdk._serde import dump_payload
-from persona_sdk.client import PersonaClient
-
-
-class WorkflowsApi:
-    def __init__(self, client: PersonaClient):
-        self._client = client
-
-    async def list(
-        self, keyword: str | None = None, page: int = 1, size: int = 20
-    ) -> Paginated[Workflow]:
-        params: dict[str, Any] = {"page": page, "size": size}
-        if keyword:
-            params["keyword"] = keyword
-        data = await self._client.get("/workflows", params=params)
-        return Paginated[Workflow].model_validate(data)
-
-    async def get(self, workflow_id: str) -> Workflow:
-        data = await self._client.get(f"/workflows/{workflow_id}")
-        return Workflow.model_validate(data)
-
-    async def create(self, workflow: Workflow | dict[str, Any]) -> Workflow:
-        data = await self._client.post("/workflows", json=dump_payload(workflow))
-        return Workflow.model_validate(data)
-
-    async def update(
-        self, workflow_id: str, workflow: Workflow | dict[str, Any]
-    ) -> Workflow:
-        data = await self._client.put(
-            f"/workflows/{workflow_id}", json=dump_payload(workflow)
-        )
-        return Workflow.model_validate(data)
-
-    async def delete(self, workflow_id: str) -> dict[str, Any]:
-        return await self._client.delete(f"/workflows/{workflow_id}")
-
-    async def execute(
-        self, workflow_id: str, data: dict[str, Any] | None = None
-    ) -> dict[str, Any]:
-        """Execute a workflow synchronously.
-
-        Returns the workflow ``Execution`` (``status``, ``steps``, ``output``,
-        ``error``, ...) as a plain dict; the execution contract is owned by the
-        workflows service and intentionally not constrained here.
-        """
-        return await self._client.post(
-            f"/workflows/{workflow_id}/execute", json=data or {}
-        )
-
-    async def queue(
-        self, workflow_id: str, data: dict[str, Any] | None = None
-    ) -> dict[str, Any]:
-        """Queue a workflow for asynchronous execution (returns an ``Execution``)."""
-        return await self._client.post(
-            f"/workflows/{workflow_id}/queue", json=data or {}
-        )
-
-    async def list_executions(
-        self, workflow_id: str, page: int = 1, size: int = 20
-    ) -> dict[str, Any]:
-        """List executions for a workflow (``Paginated[Execution]`` shape)."""
-        params: dict[str, Any] = {"page": page, "size": size}
-        return await self._client.get(
-            f"/workflows/{workflow_id}/executions", params=params
-        )