evolvingmachines-evolve 0.0.55.dev1355__py3-none-any.whl

evolve/integrations.py

@@ -0,0 +1,173 @@
+"""Managed integrations async helpers."""
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from .bridge import BridgeManager
+
+
+@dataclass
+class IntegrationAuthResult:
+    """Result from an integration auth request."""
+    url: str
+    account_id: Optional[str] = None
+
+
+@dataclass
+class IntegrationAccount:
+    """Connected account for a managed app integration."""
+    user_id: str
+    app: str
+    status: str
+    app_name: Optional[str] = None
+    app_icon: Optional[str] = None
+    account_label: Optional[str] = None
+    account_id: Optional[str] = None
+
+
+@dataclass
+class IntegrationAccountUpdateResult:
+    """Result from updating a connected account."""
+    success: bool
+    account_id: str
+    account_label: Optional[str] = None
+
+
+@dataclass
+class IntegrationAccountDeleteResult:
+    """Result from deleting a connected account."""
+    success: bool
+    account_id: str
+
+
+async def auth(
+    *,
+    user_id: str,
+    app: str,
+    account_label: Optional[str] = None,
+    api_key: Optional[str] = None,
+    dashboard_url: Optional[str] = None,
+) -> IntegrationAuthResult:
+    """Create an auth URL for one app account."""
+    bridge = BridgeManager()
+    try:
+        await bridge.start()
+        params: Dict[str, object] = {'user_id': user_id, 'app': app}
+        if account_label is not None:
+            params['account_label'] = account_label
+        if api_key:
+            params['api_key'] = api_key
+        if dashboard_url:
+            params['dashboard_url'] = dashboard_url
+        response = await bridge.call('integrations_auth', params)
+        return IntegrationAuthResult(
+            url=response['url'],
+            account_id=response.get('account_id'),
+        )
+    finally:
+        await bridge.stop()
+
+
+class _Accounts:
+    async def list(
+        self,
+        *,
+        user_ids: List[str],
+        app: Optional[str] = None,
+        statuses: Optional[List[str]] = None,
+        api_key: Optional[str] = None,
+        dashboard_url: Optional[str] = None,
+    ) -> List[IntegrationAccount]:
+        """List connected accounts for one or more integration users."""
+        bridge = BridgeManager()
+        try:
+            await bridge.start()
+            params: Dict[str, object] = {'user_ids': user_ids}
+            if app:
+                params['app'] = app
+            if statuses:
+                params['statuses'] = statuses
+            if api_key:
+                params['api_key'] = api_key
+            if dashboard_url:
+                params['dashboard_url'] = dashboard_url
+            response = await bridge.call('integrations_accounts_list', params)
+            return [
+                IntegrationAccount(
+                    user_id=account['user_id'],
+                    app=account['app'],
+                    status=account['status'],
+                    app_name=account.get('app_name'),
+                    app_icon=account.get('app_icon'),
+                    account_label=account.get('account_label'),
+                    account_id=account.get('account_id'),
+                )
+                for account in response['accounts']
+            ]
+        finally:
+            await bridge.stop()
+
+    async def update(
+        self,
+        *,
+        account_id: str,
+        account_label: Optional[str] = None,
+        api_key: Optional[str] = None,
+        dashboard_url: Optional[str] = None,
+    ) -> IntegrationAccountUpdateResult:
+        """Set, update, or clear a connected account label."""
+        bridge = BridgeManager()
+        try:
+            await bridge.start()
+            params: Dict[str, object] = {'account_id': account_id}
+            if account_label is not None:
+                params['account_label'] = account_label
+            if api_key:
+                params['api_key'] = api_key
+            if dashboard_url:
+                params['dashboard_url'] = dashboard_url
+            response = await bridge.call('integrations_account_update', params)
+            return IntegrationAccountUpdateResult(
+                success=response['success'],
+                account_id=response['account_id'],
+                account_label=response.get('account_label'),
+            )
+        finally:
+            await bridge.stop()
+
+    async def delete(
+        self,
+        *,
+        account_id: str,
+        api_key: Optional[str] = None,
+        dashboard_url: Optional[str] = None,
+    ) -> IntegrationAccountDeleteResult:
+        """Delete a connected account."""
+        bridge = BridgeManager()
+        try:
+            await bridge.start()
+            params: Dict[str, object] = {'account_id': account_id}
+            if api_key:
+                params['api_key'] = api_key
+            if dashboard_url:
+                params['dashboard_url'] = dashboard_url
+            response = await bridge.call('integrations_account_delete', params)
+            return IntegrationAccountDeleteResult(
+                success=response['success'],
+                account_id=response['account_id'],
+            )
+        finally:
+            await bridge.stop()
+
+
+accounts = _Accounts()
+
+
+__all__ = [
+    'auth',
+    'accounts',
+    'IntegrationAuthResult',
+    'IntegrationAccount',
+    'IntegrationAccountUpdateResult',
+    'IntegrationAccountDeleteResult',
+]

evolve/managed_secrets.py

@@ -0,0 +1,175 @@
+"""Standalone managed secrets client."""
+
+import asyncio
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+from . import _http
+from .config import ManagedSecretsClientConfig
+
+
+DEFAULT_DASHBOARD_URL = 'https://dashboard.evolvingmachines.ai'
+
+
+@dataclass
+class ManagedSecretMetadata:
+    id: str
+    name: str
+    allowed_hosts: List[str]
+    allowed_path_prefixes: List[str]
+    allowed_methods: List[str]
+    created_at: str
+    updated_at: str
+    last_used_at: Optional[str]
+    #: The row's label — secrets are unique by (name, label), 'default' when
+    #: none was chosen at store time. None: servers older than the label
+    #: lane omit it.
+    label: Optional[str] = None
+    #: The row's delivery mode: 'brokered' (the value never enters any
+    #: sandbox — placeholder env + egress-proxy swap toward allowed_hosts)
+    #: or 'direct' (the raw value is placed in the sandbox environment —
+    #: URL-parameter keys, gRPC, websockets). None: servers older than the
+    #: delivery lane omit it and always broker.
+    delivery: Optional[str] = None
+
+
+def _metadata_from_dict(data: Dict[str, Any]) -> ManagedSecretMetadata:
+    return ManagedSecretMetadata(
+        id=data['id'],
+        name=data['name'],
+        allowed_hosts=list(data.get('allowedHosts') or data.get('allowed_hosts') or []),
+        allowed_path_prefixes=list(data.get('allowedPathPrefixes') or data.get('allowed_path_prefixes') or []),
+        allowed_methods=list(data.get('allowedMethods') or data.get('allowed_methods') or []),
+        created_at=data.get('createdAt') or data.get('created_at') or '',
+        updated_at=data.get('updatedAt') or data.get('updated_at') or '',
+        last_used_at=data.get('lastUsedAt') or data.get('last_used_at'),
+        label=data.get('label'),
+        delivery=data.get('delivery'),
+    )
+
+
+@dataclass
+class ManagedSecretWriteResult:
+    #: 'created' for a fresh (name, label) identity; 'updated' when the
+    #: request restated the stored value byte-for-byte and the row converged
+    #: (the one path where delivery and scoping are editable). A DIFFERENT
+    #: value under an existing identity never overwrites — the server
+    #: refuses typed (HTTP 409, code ``secret_exists``).
+    status: str
+    secret: ManagedSecretMetadata
+
+
+@dataclass
+class ManagedSecretDeleteResult:
+    ok: bool
+    name: str
+    #: The label of the row that was deleted (resolution may have defaulted it).
+    label: str
+
+
+class ManagedSecretsClient:
+    """Dashboard-stored managed secrets: list metadata, set and delete.
+
+    ``set`` speaks the API-key write door (``POST /api/managed-secrets``):
+    the VALUE rides the HTTPS body and is sealed server-side with the vault
+    cipher — the same posture the inline job-secrets door on job create
+    established; no read ever returns it. LLM provider keys (BYOK) are not
+    writable here — they gate billing and stay behind the signed-in
+    dashboard session.
+    """
+
+    def __init__(self, config: Optional[ManagedSecretsClientConfig] = None):
+        self.config = config or ManagedSecretsClientConfig()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def close(self):
+        return None
+
+    async def list(self) -> List[ManagedSecretMetadata]:
+        result = await self._request_json('/api/managed-secrets')
+        return [_metadata_from_dict(item) for item in result.get('secrets', [])]
+
+    async def set(
+        self,
+        *,
+        name: str,
+        value: str,
+        delivery: str,
+        label: Optional[str] = None,
+        allowed_hosts: Optional[List[str]] = None,
+        allowed_path_prefixes: Optional[List[str]] = None,
+        allowed_methods: Optional[List[str]] = None,
+    ) -> ManagedSecretWriteResult:
+        """Create or update an env secret (identity = (name, label)).
+
+        ``delivery`` is required: 'brokered' needs the allowed_hosts /
+        allowed_path_prefixes / allowed_methods scoping triple, 'direct'
+        refuses it. An existing identity converges only on a byte-equal
+        restatement of the stored value; a different value refuses typed —
+        rotate by delete + set, or use another label.
+        """
+        body: Dict[str, Any] = {'name': name, 'value': value, 'delivery': delivery}
+        if label is not None:
+            body['label'] = label
+        if allowed_hosts is not None:
+            body['allowed_hosts'] = list(allowed_hosts)
+        if allowed_path_prefixes is not None:
+            body['allowed_path_prefixes'] = list(allowed_path_prefixes)
+        if allowed_methods is not None:
+            body['allowed_methods'] = list(allowed_methods)
+        result = await self._request_json('/api/managed-secrets', method='POST', body=body)
+        return ManagedSecretWriteResult(
+            status=str(result.get('status') or ''),
+            secret=_metadata_from_dict(result.get('secret') or {}),
+        )
+
+    async def delete(
+        self, *, name: str, label: Optional[str] = None
+    ) -> ManagedSecretDeleteResult:
+        """Delete an env secret by (name, label).
+
+        An omitted label resolves by the shared law: the 'default' row, else
+        the single row, else a typed ambiguity refusal naming every label.
+        """
+        body: Dict[str, Any] = {'name': name}
+        if label is not None:
+            body['label'] = label
+        result = await self._request_json('/api/managed-secrets', method='DELETE', body=body)
+        return ManagedSecretDeleteResult(
+            ok=bool(result.get('ok')),
+            name=str(result.get('name') or name),
+            label=str(result.get('label') or ''),
+        )
+
+    async def _request_json(
+        self,
+        path: str,
+        *,
+        method: str = 'GET',
+        body: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        return await asyncio.to_thread(
+            _http.request_json,
+            f'{_dashboard_base_url(self.config)}{path}',
+            api_key=_resolve_api_key(self.config),
+            error_prefix='Managed secrets',
+            method=method,
+            body=body,
+        )
+
+
+def _dashboard_base_url(config: ManagedSecretsClientConfig) -> str:
+    return (config.dashboard_url or os.environ.get('EVOLVE_DASHBOARD_URL') or DEFAULT_DASHBOARD_URL).rstrip('/')
+
+
+def _resolve_api_key(config: ManagedSecretsClientConfig) -> str:
+    api_key = config.api_key or os.environ.get('EVOLVE_API_KEY')
+    if not api_key:
+        raise ValueError('Managed secrets require EVOLVE_API_KEY or ManagedSecretsClientConfig(api_key=...)')
+    return api_key

evolve/pipeline/__init__.py

@@ -0,0 +1,59 @@
+"""Pipeline - Fluent API for chaining Swarm operations."""
+
+from .pipeline import Pipeline, TerminalPipeline
+from .types import (
+    # Step configs
+    MapConfig,
+    FilterConfig,
+    ReduceConfig,
+    # Results
+    StepResult,
+    PipelineResult,
+    # Events
+    PipelineEvents,
+    PipelineEventMap,
+    StepEvent,
+    StepStartEvent,
+    StepCompleteEvent,
+    StepErrorEvent,
+    ItemRetryEvent,
+    WorkerCompleteEvent,
+    VerifierCompleteEvent,
+    CandidateCompleteEvent,
+    JudgeCompleteEvent,
+    # Types
+    EmitOption,
+    EventName,
+    Step,
+    StepType,
+)
+
+__all__ = [
+    # Main classes
+    'Pipeline',
+    'TerminalPipeline',
+    # Step configs
+    'MapConfig',
+    'FilterConfig',
+    'ReduceConfig',
+    # Results
+    'StepResult',
+    'PipelineResult',
+    # Events
+    'PipelineEvents',
+    'PipelineEventMap',
+    'StepEvent',
+    'StepStartEvent',
+    'StepCompleteEvent',
+    'StepErrorEvent',
+    'ItemRetryEvent',
+    'WorkerCompleteEvent',
+    'VerifierCompleteEvent',
+    'CandidateCompleteEvent',
+    'JudgeCompleteEvent',
+    # Types
+    'EmitOption',
+    'EventName',
+    'Step',
+    'StepType',
+]