polos-sdk 0.1.0__py3-none-any.whl

polos_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,650 @@
+Metadata-Version: 2.4
+Name: polos-sdk
+Version: 0.1.0
+Summary: Polos SDK for Python - Durable Agent Execution
+Project-URL: Homepage, https://github.com/polos-dev/polos
+Project-URL: Repository, https://github.com/polos-dev/polos
+Project-URL: Documentation, https://docs.polos.dev
+Project-URL: Issues, https://github.com/polos-dev/polos/issues
+Author: Polos Team
+License: Apache-2.0
+Keywords: agents,ai,async,durable-execution,llm,orchestration,workflow
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software 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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: anyio>=4.0.0
+Requires-Dist: fastapi>=0.104.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.20.0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: uvicorn>=0.24.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.39.0; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.10.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: fireworks
+Requires-Dist: openai>=1.0.0; extra == 'fireworks'
+Provides-Extra: gemini
+Requires-Dist: openai>=1.0.0; extra == 'gemini'
+Provides-Extra: groq
+Requires-Dist: openai>=1.0.0; extra == 'groq'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Provides-Extra: together
+Requires-Dist: openai>=1.0.0; extra == 'together'
+Description-Content-Type: text/markdown
+
+# Polos Python SDK
+
+Durable execution engine for Python. Build reliable AI agents and workflows that can survive failures, handle long-running tasks, and coordinate complex processes.
+
+## Features
+
+- 🤖 **AI Agents** - Build LLM-powered agents with tool calling, streaming, and conversation history
+- 🔄 **Durable Workflows** - Workflows survive failures and resume from checkpoints
+- ⏰ **Long-Running** - Execute workflows that run for hours or days
+- 🔗 **Workflow Orchestration** - Chain workflows together and build complex processes
+- 🛠️ **Tools** - Define reusable tools that agents can call
+- 🐍 **Native Python** - Async/await support, type hints, and Pythonic APIs
+- 📊 **Observability** - Built-in tracing, events, and monitoring
+- 🔒 **Isolated Execution** - Each workflow runs in a secure environment
+
+## Installation
+
+```bash
+pip install polos-worker
+```
+
+Or with UV (recommended):
+```bash
+uv add polos-worker
+```
+
+### Optional Dependencies
+
+Install provider-specific dependencies for LLM support:
+
+```bash
+# OpenAI
+pip install polos-worker[openai]
+
+# Anthropic
+pip install polos-worker[anthropic]
+
+# Google Gemini
+pip install polos-worker[gemini]
+
+# Groq
+pip install polos-worker[groq]
+
+# Fireworks
+pip install polos-worker[fireworks]
+
+# Together AI
+pip install polos-worker[together]
+
+# All providers
+pip install polos-worker[openai,anthropic,gemini,groq,fireworks,together]
+```
+
+## Quick Start
+
+### 1. Configure the SDK
+
+```python
+from polos import configure
+
+configure(
+    api_url='http://localhost:8080',
+    api_key='your-api-key',  # Optional if running in dev mode
+    project_id='your-project-id'
+)
+```
+
+Or use environment variables:
+```bash
+export POLOS_API_URL=http://localhost:8080
+export POLOS_API_KEY=your-api-key
+export POLOS_PROJECT_ID=your-project-id
+```
+
+### 2. Define a Workflow
+
+```python
+from polos import workflow, WorkflowContext
+
+@workflow(id="hello_world")
+async def hello_world(ctx: WorkflowContext, payload: dict):
+    """A simple workflow."""
+    name = payload.get('name', 'World')
+    return {'message': f'Hello, {name}!'}
+```
+
+### 3. Create an Agent
+
+```python
+from polos import Agent
+
+weather_agent = Agent(
+    id="weather-agent",
+    provider="openai",
+    model="gpt-5-mini",
+    system_prompt="You are a helpful weather assistant",
+    tools=[get_weather]  # Your custom tools
+)
+```
+
+### 4. Run Your Code
+
+Start a worker to execute workflows and agents:
+
+```bash
+# Using the Python worker
+python -m polos.runtime.worker
+
+# Or use the Node.js worker (supports Python workflows)
+npm install -g polos-worker
+polos-worker start
+```
+
+## Core Concepts
+
+### Workflows
+
+Workflows are durable functions that can survive failures and resume execution:
+
+```python
+from polos import workflow, WorkflowContext, WorkflowState
+
+class MyState(WorkflowState):
+    counter: int = 0
+    messages: list[str] = []
+
+@workflow(id="my_workflow", state_schema=MyState)
+async def my_workflow(ctx: WorkflowContext, payload: dict):
+    # Access state
+    ctx.state.counter += 1
+    ctx.state.messages.append(payload.get('message', ''))
+    
+    # Use step.run() for durable execution
+    result = await ctx.step.run("process_data", process_data, payload)
+    
+    return {'result': result, 'counter': ctx.state.counter}
+```
+
+### Agents
+
+Agents are LLM-powered workflows with tool calling capabilities:
+
+```python
+from polos import Agent, max_steps, executed_tool
+
+# Define a tool
+from polos import tool
+
+@tool
+def get_weather(ctx, location: str) -> str:
+    """Get weather for a location."""
+    # Your weather API call here
+    return f"Weather in {location}: 72°F, sunny"
+
+# Create an agent
+weather_agent = Agent(
+    id="weather-agent",
+    provider="openai",
+    model="gpt-5-mini",
+    system_prompt="You are a helpful weather assistant",
+    tools=[get_weather],
+    stop_conditions=[max_steps(10), executed_tool("get_weather")]
+)
+
+# Use the agent
+result = await weather_agent.run("What's the weather in NYC?")
+print(result.result)  # Agent's response
+
+# Or stream the response
+stream_result = await weather_agent.stream("What's the weather in NYC?")
+async for event in stream_result.events:
+    if event.event_type == "text_delta":
+        print(event.data.get("content", ""), end="", flush=True)
+```
+
+### Tools
+
+Tools are functions that agents can call:
+
+```python
+from polos import tool, WorkflowContext
+
+@tool
+def calculate(ctx: WorkflowContext, expression: str) -> float:
+    """Evaluate a mathematical expression."""
+    return eval(expression)  # In production, use a safe evaluator
+
+@tool
+def search_web(ctx: WorkflowContext, query: str) -> str:
+    """Search the web for information."""
+    # Your search implementation
+    return f"Results for: {query}"
+```
+
+### Hooks
+
+Hooks allow you to intercept workflow execution:
+
+```python
+from polos import hook, HookContext, HookResult, HookAction
+
+@hook
+def log_execution(ctx: WorkflowContext, hook_ctx: HookContext) -> HookResult:
+    """Log workflow execution."""
+    print(f"Workflow {ctx.workflow_id} started")
+    return HookResult.continue_with()
+
+@workflow(id="my_workflow", on_start=log_execution)
+async def my_workflow(ctx: WorkflowContext, payload: dict):
+    return {'result': 'done'}
+```
+
+### Guardrails
+
+Guardrails validate and modify agent outputs:
+
+```python
+from polos import guardrail, GuardrailContext, GuardrailResult
+
+@guardrail
+def check_profanity(ctx: GuardrailContext) -> GuardrailResult:
+    """Check for profanity in agent output."""
+    content = ctx.content or ""
+    if any(word in content.lower() for word in ["bad", "word"]):
+        return GuardrailResult.fail("Content contains inappropriate language")
+    return GuardrailResult.continue_with()
+
+weather_agent = Agent(
+    id="weather-agent",
+    provider="openai",
+    model="gpt-5-mini",
+    guardrails=[check_profanity]
+)
+```
+
+## Advanced Features
+
+### State Management
+
+Workflows can maintain state across executions:
+
+```python
+from polos import workflow, WorkflowContext, WorkflowState
+
+class CounterState(WorkflowState):
+    count: int = 0
+    history: list[str] = []
+
+@workflow(id="counter", state_schema=CounterState)
+async def counter(ctx: WorkflowContext, payload: dict):
+    ctx.state.count += 1
+    ctx.state.history.append(payload.get('action', ''))
+    return {'count': ctx.state.count}
+```
+
+### Step Execution
+
+Use `ctx.step` for durable execution:
+
+```python
+@workflow(id="my_workflow")
+async def my_workflow(ctx: WorkflowContext, payload: dict):
+    # Run a step (durable)
+    result = await ctx.step.run("step_name", my_function, arg1, arg2)
+    
+    # Invoke another workflow and wait
+    result = await ctx.step.invoke_and_wait("other_workflow", other_workflow, payload)
+    
+    # Invoke another workflow (fire and forget)
+    handle = await ctx.step.invoke("other_workflow", other_workflow, payload)
+    
+    # Wait for a workflow to complete
+    result = await ctx.step.wait_for(handle)
+    
+    return result
+```
+
+### Events
+
+Publish and subscribe to events:
+
+```python
+from polos import events
+
+# Publish an event
+await events.publish(
+    topic="user/123",
+    event_type="message",
+    data={"text": "Hello"}
+)
+
+# Stream events
+async for event in events.stream_topic("user/123"):
+    print(f"Event: {event.event_type} - {event.data}")
+```
+
+### Scheduled Workflows
+
+Schedule workflows to run on a schedule:
+
+```python
+@workflow(
+    id="daily_report",
+    schedule="0 9 * * *"  # 9 AM daily
+)
+async def daily_report(ctx: WorkflowContext, payload: dict):
+    # Generate daily report
+    return {'report': '...'}
+```
+
+### Queues
+
+Use queues for concurrency control:
+
+```python
+from polos import Queue
+
+my_queue = Queue(name="processing", concurrency_limit=5)
+
+@workflow(id="processor", queue=my_queue)
+async def processor(ctx: WorkflowContext, payload: dict):
+    # Process item
+    return {'status': 'processed'}
+```
+
+### Batch Execution
+
+Execute workflows in batch:
+
+```python
+from polos import batch
+
+results = await batch.run(
+    workflow_id="my_workflow",
+    inputs=[
+        {"value": 1},
+        {"value": 2},
+        {"value": 3}
+    ]
+)
+
+for result in results:
+    print(result.result)
+```
+
+## Testing
+
+The SDK includes comprehensive unit tests. Run tests with:
+
+```bash
+# Install test dependencies
+uv sync --dev
+
+# Run all tests
+uv run pytest
+
+# Run with coverage
+uv run pytest --cov=polos --cov-report=html
+
+# Run specific test file
+uv run pytest tests/unit/test_core/test_workflow.py
+```
+
+See [`TESTING_PLAN.md`](./TESTING_PLAN.md) for testing guidelines.
+
+## Development Setup
+
+### Using UV (Recommended)
+
+```bash
+# Fork the repository on GitHub first: https://github.com/polos-dev/polos
+# Then clone your fork
+git clone https://github.com/YOUR_USERNAME/polos.git
+cd polos/sdk/python
+
+# Install dependencies (creates venv automatically)
+uv sync
+
+# Format code with Ruff
+uv run ruff format .
+
+# Lint code
+uv run ruff check .
+
+# Run tests
+uv run pytest
+
+# Build package
+uv build
+```
+
+### Using pip
+
+```bash
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+
+# Install in development mode
+pip install -e ".[dev]"
+
+# Format code
+ruff format .
+
+# Lint code
+ruff check .
+
+# Run tests
+pytest
+```
+
+### Pre-commit Hooks
+
+The project uses pre-commit hooks for code quality:
+
+```bash
+# Install pre-commit
+pip install pre-commit
+
+# Install hooks
+pre-commit install
+
+# Run hooks manually
+pre-commit run --all-files
+```
+
+## Project Structure
+
+```
+sdk/python/
+├── polos/                  # Main package
+│   ├── agents/             # Agent implementation
+│   ├── core/               # Core workflow/step/context
+│   ├── features/           # Events, schedules, tracing
+│   ├── llm/                # LLM providers
+│   ├── middleware/         # Hooks and guardrails
+│   ├── runtime/            # Worker and client
+│   ├── tools/              # Tool implementation
+│   ├── types/              # Type definitions
+│   └── utils/              # Utility functions
+├── tests/                  # Test suite
+│   └── unit/               # Unit tests
+├── pyproject.toml          # Project configuration
+└── README.md               # This file
+```
+
+## API Reference
+
+### Core Functions
+
+#### `@workflow(id, queue, schedule, state_schema, ...)`
+
+Decorator to register a workflow function.
+
+**Parameters:**
+- `id` (str): Unique workflow identifier
+- `queue` (str | Queue | dict, optional): Queue configuration
+- `schedule` (str | dict, optional): Cron schedule or schedule config
+- `state_schema` (type[WorkflowState], optional): State schema class
+- `on_start` (Callable | list, optional): Hooks to run on start
+- `on_end` (Callable | list, optional): Hooks to run on end
+
+**Example:**
+```python
+@workflow(id="my_workflow", state_schema=MyState)
+async def my_workflow(ctx: WorkflowContext, payload: dict):
+    return {'result': 'done'}
+```
+
+#### `Agent(id, provider, model, ...)`
+
+Create an AI agent.
+
+**Parameters:**
+- `id` (str): Unique agent identifier
+- `provider` (str): LLM provider ("openai", "anthropic", etc.)
+- `model` (str): Model name (e.g., "gpt-4o", "claude-sonnet-4-5")
+- `system_prompt` (str, optional): System prompt
+- `tools` (list, optional): List of tools
+- `stop_conditions` (list, optional): Stop condition callables
+- `guardrails` (list, optional): Guardrail callables
+
+**Example:**
+```python
+agent = Agent(
+    id="my-agent",
+    provider="openai",
+    model="gpt-5-mini",
+    tools=[my_tool]
+)
+```
+
+#### `@tool`
+
+Decorator to register a tool function.
+
+**Example:**
+```python
+@tool
+def my_tool(ctx: WorkflowContext, arg: str) -> str:
+    return f"Processed: {arg}"
+```
+
+### Context Objects
+
+#### `WorkflowContext`
+
+Context object passed to workflow functions.
+
+**Properties:**
+- `workflow_id` (str): Workflow identifier
+- `execution_id` (str): Current execution ID
+- `root_execution_id` (str): Root execution ID
+- `state` (WorkflowState): Workflow state
+- `step` (Step): Step helper for durable execution
+
+#### `AgentContext`
+
+Context object passed to agent functions (extends `WorkflowContext`).
+
+**Additional Properties:**
+- `agent_id` (str): Agent identifier
+- `conversation_id` (str, optional): Conversation ID for history
+
+## Environment Variables
+
+- `POLOS_API_URL` - Orchestrator URL (default: `http://localhost:8080`)
+- `POLOS_API_KEY` - API key for authentication
+- `POLOS_PROJECT_ID` - Project ID for multi-project support
+
+## Architecture
+
+Polos uses a push-based worker architecture:
+
+```
+┌─────────────┐
+│   Client    │ ── trigger ──> ┌──────────────┐
+└─────────────┘                │ Orchestrator │
+                               │  (Rust API)  │
+                               └──────────────┘
+                                      │
+                                   invokes
+                                      ↓
+┌─────────────┐              ┌──────────────┐
+│  Executor   │ <── pushes ──│    Worker    │
+│  (Python)   │              │   (Python)   │
+└─────────────┘              └──────────────┘
+```
+
+1. **Client** triggers workflow/agent via SDK
+2. **Orchestrator** queues execution in database
+3. **Orchestrator** pushes execution to worker via HTTP
+4. **Worker** receives execution request and executes workflow/agent in process
+5. **Worker** reports result back to orchestrator
+6. **Orchestrator** marks execution complete
+7. **Client** receives result
+
+## Contributing
+
+We welcome contributions! See [CONTRIBUTING.md](../../CONTRIBUTING.md) for guidelines.
+
+### Development Workflow
+
+1. **Fork the repository** on GitHub: https://github.com/polos-dev/polos
+2. **Clone your fork**:
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/polos.git
+   cd polos/sdk/python
+   ```
+3. **Add upstream remote** (optional, for syncing with main repo):
+   ```bash
+   git remote add upstream https://github.com/polos-dev/polos.git
+   ```
+4. Create a feature branch
+5. Make your changes
+6. Run tests: `uv run pytest`
+7. Format code: `uv run ruff format .`
+8. Lint code: `uv run ruff check .`
+9. Submit a pull request to `polos-dev/polos`
+
+## License
+
+MIT License - see [LICENSE](../../LICENSE) for details.
+
+## Support
+
+- 📖 [Documentation](https://docs.polos.dev)
+- 💬 [Discord Community](https://discord.gg/polos)
+- 🐛 [Issue Tracker](https://github.com/polos-dev/polos/issues)
+- 📧 [Email Support](mailto:support@polos.dev)
+
+## Related Projects
+
+- [Polos Orchestrator](../../orchestrator) - Rust-based orchestrator
+- [Polos UI](../../ui) - Web interface for monitoring and management
+
+---
+
+Built with ❤️ by the Polos team

polos_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,55 @@
+polos/__init__.py,sha256=WTVHY01DfbioRF7A130k7SLizsC9UJZoySmz9lJ_VnA,2402
+polos/agents/__init__.py,sha256=z6Pyyzbd8fKf2oA49hQ_1srj0nyCrS8XsuWAMYExz3c,122
+polos/agents/agent.py,sha256=Y1JZvhqrEoirwbMvP948G-95iWB4kJAv9qBswmXGxP8,26426
+polos/agents/conversation_history.py,sha256=W4efQU4p7yyMAkAw8jFkA9YEkQn-7giZKr0lkyBUJ-w,3918
+polos/agents/stop_conditions.py,sha256=2qV27F4J8SfOHDZ3iGqUUELuBLmLIK08Fj7WOapo8cQ,9456
+polos/agents/stream.py,sha256=d6L2e7RmmN275tuAcugFiqRq7snUndgXoPGSoCBMR6g,25127
+polos/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polos/core/context.py,sha256=vkwM4cQ93p1-K_muT6obxYV_dzgsPDOC3HT-OKNF6jE,5053
+polos/core/state.py,sha256=MKWaGM1kLQEw0Q2VWD-PXB3CkK1tiqoTmeoQRwIpngg,774
+polos/core/step.py,sha256=6uZcbbyk_zo7sR76PVw_9hXdgfpRyf5veDsoQwJcKrk,51700
+polos/core/workflow.py,sha256=xGGNye2bb5B7W2RWsVFmYb5fz8349sGeAWZXjJgUuD0,51093
+polos/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polos/features/events.py,sha256=7viS9ryCeEnOaAO4blsLH45ulBPknDa9ISfif0jmhig,14237
+polos/features/schedules.py,sha256=SpnQLOHKShZJA-Hteoqto5eTiq3Sin4-y8-K2RTQouw,3077
+polos/features/tracing.py,sha256=xOaj9WLqK7B9IwRUDyCDVZ7IGhVPDxQ1YB1UQ3aFK2w,22736
+polos/features/wait.py,sha256=c2NUz1BPG56EGIdxQwuDhydnyztqD5B9KBTlaimdofE,2504
+polos/llm/__init__.py,sha256=SYLl5KdW3ah2lF5kpNsAuT-86MrNtsUDKXmznNsW8Fk,170
+polos/llm/generate.py,sha256=FuuY2vPeka7q8cpQ4pHzygmkO_pnvAadLP65xyFgESI,6491
+polos/llm/stream.py,sha256=oBPDL2t5srTMYKeKTm7dhVmTjWRgV-ynPhPKGM6ud98,6732
+polos/llm/providers/__init__.py,sha256=xFiGlL4P1_3IxVXYFIphXWLBEnillFcRVmpa34YEysk,192
+polos/llm/providers/anthropic.py,sha256=1aAbDIG8pYhTD2aOFBKK87Qh_LZDmZU5nGqqDh29opQ,26488
+polos/llm/providers/azure.py,sha256=-_IxZhu6tCgoQ9TdmltUrimKVC6kw4DsU6eDIsitzOQ,1487
+polos/llm/providers/base.py,sha256=w7HkErRbP0eKJPh-vFu4KZXhYnH_SBbeLk1jt55tpT4,6922
+polos/llm/providers/fireworks.py,sha256=qg5UeRVy9mekJEd_OFU4VXvQpTMzpKMsZYCs1fS2ZEQ,1414
+polos/llm/providers/gemini.py,sha256=yq4mWN-RG6LjZfKeP-P2JeBxHip754m0yLBoDX8bPlg,1342
+polos/llm/providers/groq.py,sha256=oPIyy3eGTtyEWZOfuOxTZYMbu-Gz8OZ9t3RYDmENiE8,1285
+polos/llm/providers/openai.py,sha256=MCPUiz_V25Suivdb-GAflop_oOPznnGbLjwZHOD4vC0,42487
+polos/llm/providers/together.py,sha256=VAMV-y_nTOJCSNvVXvFg2WGxRdhVpHTYswX9wLjsROg,1344
+polos/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polos/middleware/guardrail.py,sha256=EKkKEh4qEIsaDDRztzYEYG128NOyM8T-KstSZxlPNT0,4840
+polos/middleware/guardrail_executor.py,sha256=hvXEC5J2mfBGEaXIXwmCtfopi0boawKJkTtZsOMz2IM,9411
+polos/middleware/hook.py,sha256=qhzjQP5I6DkL4GbdIrauDTesUQh067whyt1PxbP8qH8,4780
+polos/middleware/hook_executor.py,sha256=732Kw89deLjDZPJyKQ0ZDlmOinp7dksBZenBdPSkpfg,3669
+polos/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polos/runtime/batch.py,sha256=hrzHi2oP5jJ6SJemESnkWI22v3m_GIMgh38fOscmM8k,2879
+polos/runtime/client.py,sha256=iiJOU4zeNHHv61uzWNO7TablP4IQFPWcROMXRoSaQd0,32984
+polos/runtime/queue.py,sha256=QeLgCVnMemchj7FdT_K5zsy-86iNTOqf2Wm3s1Cg-lA,1257
+polos/runtime/worker.py,sha256=5KF0IgknIFNDhnZiFx2m7MLUXysgmt_np-1dI5euFf0,56398
+polos/runtime/worker_server.py,sha256=HtWCyufL184R-aAIU_p0vVhwlWH4PDseQjZ2qPKpEns,10120
+polos/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polos/tools/tool.py,sha256=OmaNBCQgA8e5uRJTO88pNR3eP1BDQiK2jvxkrPYdrag,22483
+polos/types/__init__.py,sha256=Va3Yg1JbuDIzXFt5czG2hrN7DZL19k04DNBguUf-JlA,360
+polos/types/types.py,sha256=wqYKLqm8nZ2Ba5BEDJpMgS88XzzeGV9zzX_ntGP8lpw,2919
+polos/utils/__init__.py,sha256=E9PPg23MCxh-82TlQeD4-VNo0gQo3rJDQxaw7EVbVfo,636
+polos/utils/agent.py,sha256=DR_f67DcuJY1vJQSNgDFeHkFZH9auvef2Zcv2W7mrYY,675
+polos/utils/client_context.py,sha256=drSXD_4zPwn83KaNbp3B7vQcDH9IUbni1hT7TSG2DGU,1157
+polos/utils/config.py,sha256=VXfccQgtVTX5ieFnHosB8xqcoHecDT2hJ09rJMnKvWw,399
+polos/utils/output_schema.py,sha256=wJSZviqPCcqWrDfUlBFHCKYmuOqNZTqw4hYhqGZFI10,14235
+polos/utils/retry.py,sha256=Igz4degC0IUWnsJsRKVIrkNjYm57DG467EcLbmMOMuM,1398
+polos/utils/serializer.py,sha256=5BvdBSXPKGwO0F3FubiXV8vuMyW3AC1-4Jwz3Bc7eik,5486
+polos/utils/tracing.py,sha256=SkBktU12KyIQcl8q1wjyTX7QfGwyzdzEcBY8QTX_t6Y,1021
+polos/utils/worker_singleton.py,sha256=7-MOx9VFlyC-8waB7OMg6xER5NB7Ld7ofMku9yoitDo,1081
+polos_sdk-0.1.0.dist-info/METADATA,sha256=66gs2_-Sk0xinDRF7KD6pR8JfY8Q0I2zmOijV_aibFQ,16924
+polos_sdk-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+polos_sdk-0.1.0.dist-info/RECORD,,

polos_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any