# PocketFlow Tracing with Langfuse
This [repository](https://github.com/redreamality/pocketflow-tracing) provides comprehensive observability for PocketFlow workflows using [Langfuse](https://langfuse.com/) as the tracing backend. With minimal code changes (just adding a decorator), you can automatically trace all node executions, inputs, outputs, and errors in your PocketFlow workflows. Checkout the [blog](https://redreamality.com/blog/pocketflow-tracing) post for more details.
## 🎯 Features
### Core Tracing
- **Automatic Tracing**: Trace entire flows with a single decorator
- **Node-Level Observability**: Automatically trace `prep`, `exec`, and `post` phases of each node
- **Input/Output Tracking**: Capture all data flowing through your workflow
- **Error Tracking**: Automatically capture and trace exceptions
- **Minimal Code Changes**: Just add `@trace_flow()` to your flow classes
- **Langfuse Integration**: Leverage Langfuse's powerful observability platform
### 🚀 Advanced Async Support
- **Comprehensive Async Context Management**: Proper context propagation across async boundaries
- **Advanced Lifecycle Tracking**: Detailed tracking of async node states including suspend/resume events
- **Async Flow Composition**: Support for nested, concurrent, and batch async flows
- **Robust Error Handling**: Comprehensive error management for async operations including cancellation, timeouts, and recovery
- **Performance Monitoring**: Built-in performance tracking for async operations
- **Concurrent Flow Execution**: Execute multiple flows concurrently with proper isolation
- **Backward Compatibility**: Existing synchronous code continues to work unchanged
## 🚀 Quick Start
### 1. Installation
Install the package using pip:
```bash
pip install pocketflow-tracing
```
Or install from source:
```bash
git clone https://github.com/The-Pocket/PocketFlow.git
cd PocketFlow/cookbook/pocketflow-tracing
pip install .
```
For development installation:
```bash
pip install -e ".[dev]"
```
### 2. Environment Setup
Copy the example environment file and configure your Langfuse credentials:
```bash
cp .env.example .env
```
Then edit the `.env` file with your actual Langfuse configuration:
```env
LANGFUSE_SECRET_KEY=your-langfuse-secret-key
LANGFUSE_PUBLIC_KEY=your-langfuse-public-key
LANGFUSE_HOST=your-langfuse-host-url
POCKETFLOW_TRACING_DEBUG=true
```
**Note**: Replace the placeholder values with your actual Langfuse credentials and host URL.
### 3. Basic Usage
```python
from pocketflow import Node, Flow
from pocketflow_tracing import trace_flow
class MyNode(Node):
def prep(self, shared):
return shared["input"]
def exec(self, data):
return f"Processed: {data}"
def post(self, shared, prep_res, exec_res):
shared["output"] = exec_res
return "default"
@trace_flow() # 🎉 That's it! Your flow is now traced
class MyFlow(Flow):
def __init__(self):
super().__init__(start=MyNode())
# Run your flow - tracing happens automatically
flow = MyFlow()
shared = {"input": "Hello World"}
flow.run(shared)
```
## 📊 What Gets Traced
When you apply the `@trace_flow()` decorator, the system automatically traces:
### Flow Level
- **Flow Start/End**: Overall execution time and status
- **Input Data**: Initial shared state when flow starts
- **Output Data**: Final shared state when flow completes
- **Errors**: Any exceptions that occur during flow execution
### Node Level
For each node in your flow, the system traces:
- **prep() Phase**:
- Input: `shared` data
- Output: `prep_res` returned by prep method
- Execution time and any errors
- **exec() Phase**:
- Input: `prep_res` from prep phase
- Output: `exec_res` returned by exec method
- Execution time and any errors
- Retry attempts (if configured)
- **post() Phase**:
- Input: `shared`, `prep_res`, `exec_res`
- Output: Action string returned
- Execution time and any errors
## 🔧 Configuration Options
### Basic Configuration
```python
from tracing import trace_flow, TracingConfig
# Use environment variables (default)
@trace_flow()
class MyFlow(Flow):
pass
# Custom flow name
@trace_flow(flow_name="CustomFlowName")
class MyFlow(Flow):
pass
# Custom session and user IDs
@trace_flow(session_id="session-123", user_id="user-456")
class MyFlow(Flow):
pass
```
### Advanced Configuration
```python
from tracing import TracingConfig
# Create custom configuration
config = TracingConfig(
langfuse_secret_key="your-secret-key",
langfuse_public_key="your-public-key",
langfuse_host="https://your-langfuse-instance.com",
debug=True,
trace_inputs=True,
trace_outputs=True,
trace_errors=True
)
@trace_flow(config=config)
class MyFlow(Flow):
pass
```
## 📁 Examples
### Basic Synchronous Flow
See `examples/basic_example.py` for a complete example of tracing a simple synchronous flow.
```bash
cd examples
python basic_example.py
```
### Asynchronous Flow
See `examples/async_example.py` for basic async tracing and `examples/comprehensive_async_example.py` for advanced async features.
```bash
cd examples
python async_example.py
# For comprehensive async features demonstration
python comprehensive_async_example.py
```
### 🚀 Advanced Async Usage
The enhanced async support provides comprehensive tracing for complex async patterns:
#### Concurrent Flow Execution
```python
import asyncio
from pocketflow_tracing import trace_flow
@trace_flow(flow_name="ConcurrentFlow")
class ConcurrentFlow(AsyncFlow):
# ... your async flow definition ...
async def run_concurrent_flows():
flows = [ConcurrentFlow() for _ in range(5)]
shared_data = [{"input": f"data_{i}"} for i in range(5)]
# Execute flows concurrently with proper tracing
results = await asyncio.gather(*[
flow.run_async(shared)
for flow, shared in zip(flows, shared_data)
])
return results
```
#### Error Handling and Recovery
```python
class RobustAsyncNode(AsyncNode):
def __init__(self, max_retries=3):
super().__init__(max_retries=max_retries, wait=1.0)
async def exec_async(self, prep_res):
# This will automatically retry on failure
return await risky_async_operation(prep_res)
async def exec_fallback_async(self, prep_res, exc):
# Fallback when all retries are exhausted
return await safe_fallback_operation(prep_res)
```
#### Nested Flow Composition
```python
@trace_flow(flow_name="MainFlow")
class MainFlow(AsyncFlow):
async def run_async(self, shared):
# Run main processing
result = await super().run_async(shared)
# Run nested analysis flow with proper context
if result == "success":
analysis_flow = AnalysisFlow()
analysis_result = await analysis_flow.run_async(shared)
shared["analysis"] = analysis_result
return result
```
For complete migration guidance, see [docs/async_migration_guide.md](docs/async_migration_guide.md).
## 🔍 Viewing Traces
After running your traced flows, visit your Langfuse dashboard to view the traces:
**Dashboard URL**: Use the URL you configured in `LANGFUSE_HOST` environment variable
In the dashboard you'll see:
- **Traces**: One trace per flow execution
- **Spans**: Individual node phases (prep, exec, post)
- **Input/Output Data**: All data flowing through your workflow
- **Performance Metrics**: Execution times for each phase
- **Error Details**: Stack traces and error messages
The tracings in examples.
Detailed tracing for a node.
## 🛠️ Advanced Usage
### Custom Tracer Configuration
```python
from tracing import TracingConfig, LangfuseTracer
# Create custom configuration
config = TracingConfig.from_env()
config.debug = True
# Use tracer directly (for advanced use cases)
tracer = LangfuseTracer(config)
```
### Environment Variables
You can customize tracing behavior with these environment variables:
```env
# Required Langfuse configuration
LANGFUSE_SECRET_KEY=your-secret-key
LANGFUSE_PUBLIC_KEY=your-public-key
LANGFUSE_HOST=your-langfuse-host
# Optional tracing configuration
POCKETFLOW_TRACING_DEBUG=true
POCKETFLOW_TRACE_INPUTS=true
POCKETFLOW_TRACE_OUTPUTS=true
POCKETFLOW_TRACE_PREP=true
POCKETFLOW_TRACE_EXEC=true
POCKETFLOW_TRACE_POST=true
POCKETFLOW_TRACE_ERRORS=true
# Optional session/user tracking
POCKETFLOW_SESSION_ID=your-session-id
POCKETFLOW_USER_ID=your-user-id
```
## 🐛 Troubleshooting
### Common Issues
1. **"langfuse package not installed"**
```bash
pip install langfuse
```
2. **"Langfuse client initialization failed"**
- Check your `.env` file configuration
- Verify Langfuse server is running at the specified host
- Check network connectivity
3. **"No traces appearing in dashboard"**
- Ensure `POCKETFLOW_TRACING_DEBUG=true` to see debug output
- Check that your flow is actually being executed
- Verify Langfuse credentials are correct
### Debug Mode
Enable debug mode to see detailed tracing information:
```env
POCKETFLOW_TRACING_DEBUG=true
```
This will print detailed information about:
- Langfuse client initialization
- Trace and span creation
- Data serialization
- Error messages
## 📚 API Reference
### `@trace_flow()`
Decorator to add Langfuse tracing to PocketFlow flows.
**Parameters:**
- `config` (TracingConfig, optional): Custom configuration. If None, loads from environment.
- `flow_name` (str, optional): Custom name for the flow. If None, uses class name.
- `session_id` (str, optional): Session ID for grouping related traces.
- `user_id` (str, optional): User ID for the trace.
### `TracingConfig`
Configuration class for tracing settings.
**Methods:**
- `TracingConfig.from_env()`: Create config from environment variables
- `validate()`: Check if configuration is valid
- `to_langfuse_kwargs()`: Convert to Langfuse client kwargs
### `LangfuseTracer`
Core tracer class for Langfuse integration.
**Methods:**
- `start_trace()`: Start a new trace
- `end_trace()`: End the current trace
- `start_node_span()`: Start a span for node execution
- `end_node_span()`: End a node execution span
- `flush()`: Flush pending traces to Langfuse
## 🤝 Contributing
This cookbook is designed to be a starting point for PocketFlow observability. Feel free to extend and customize it for your specific needs!
## 📄 License
This cookbook follows the same license as PocketFlow.
Raw data
{
"_id": null,
"home_page": null,
"name": "pocketflow-tracing",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.11",
"maintainer_email": "Remy <redreamality@gmail.com>",
"keywords": "pocketflow, tracing, observability, langfuse, workflow, monitoring, llm, ai",
"author": null,
"author_email": "Remy <redreamality@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/ff/96/5b5f4089fb47552e35a36475ba61236b3f9d62dfe91ac551951d61a06d13/pocketflow_tracing-0.1.3.tar.gz",
"platform": null,
"description": "# PocketFlow Tracing with Langfuse\r\n\r\nThis [repository](https://github.com/redreamality/pocketflow-tracing) provides comprehensive observability for PocketFlow workflows using [Langfuse](https://langfuse.com/) as the tracing backend. With minimal code changes (just adding a decorator), you can automatically trace all node executions, inputs, outputs, and errors in your PocketFlow workflows. Checkout the [blog](https://redreamality.com/blog/pocketflow-tracing) post for more details.\r\n\r\n## \ud83c\udfaf Features\r\n\r\n### Core Tracing\r\n- **Automatic Tracing**: Trace entire flows with a single decorator\r\n- **Node-Level Observability**: Automatically trace `prep`, `exec`, and `post` phases of each node\r\n- **Input/Output Tracking**: Capture all data flowing through your workflow\r\n- **Error Tracking**: Automatically capture and trace exceptions\r\n- **Minimal Code Changes**: Just add `@trace_flow()` to your flow classes\r\n- **Langfuse Integration**: Leverage Langfuse's powerful observability platform\r\n\r\n### \ud83d\ude80 Advanced Async Support\r\n- **Comprehensive Async Context Management**: Proper context propagation across async boundaries\r\n- **Advanced Lifecycle Tracking**: Detailed tracking of async node states including suspend/resume events\r\n- **Async Flow Composition**: Support for nested, concurrent, and batch async flows\r\n- **Robust Error Handling**: Comprehensive error management for async operations including cancellation, timeouts, and recovery\r\n- **Performance Monitoring**: Built-in performance tracking for async operations\r\n- **Concurrent Flow Execution**: Execute multiple flows concurrently with proper isolation\r\n- **Backward Compatibility**: Existing synchronous code continues to work unchanged\r\n\r\n## \ud83d\ude80 Quick Start\r\n\r\n### 1. Installation\r\n\r\nInstall the package using pip:\r\n\r\n```bash\r\npip install pocketflow-tracing\r\n```\r\n\r\nOr install from source:\r\n\r\n```bash\r\ngit clone https://github.com/The-Pocket/PocketFlow.git\r\ncd PocketFlow/cookbook/pocketflow-tracing\r\npip install .\r\n```\r\n\r\nFor development installation:\r\n\r\n```bash\r\npip install -e \".[dev]\"\r\n```\r\n\r\n### 2. Environment Setup\r\n\r\nCopy the example environment file and configure your Langfuse credentials:\r\n\r\n```bash\r\ncp .env.example .env\r\n```\r\n\r\nThen edit the `.env` file with your actual Langfuse configuration:\r\n\r\n```env\r\nLANGFUSE_SECRET_KEY=your-langfuse-secret-key\r\nLANGFUSE_PUBLIC_KEY=your-langfuse-public-key\r\nLANGFUSE_HOST=your-langfuse-host-url\r\nPOCKETFLOW_TRACING_DEBUG=true\r\n```\r\n\r\n**Note**: Replace the placeholder values with your actual Langfuse credentials and host URL.\r\n\r\n### 3. Basic Usage\r\n\r\n```python\r\nfrom pocketflow import Node, Flow\r\nfrom pocketflow_tracing import trace_flow\r\n\r\nclass MyNode(Node):\r\n def prep(self, shared):\r\n return shared[\"input\"]\r\n \r\n def exec(self, data):\r\n return f\"Processed: {data}\"\r\n \r\n def post(self, shared, prep_res, exec_res):\r\n shared[\"output\"] = exec_res\r\n return \"default\"\r\n\r\n@trace_flow() # \ud83c\udf89 That's it! Your flow is now traced\r\nclass MyFlow(Flow):\r\n def __init__(self):\r\n super().__init__(start=MyNode())\r\n\r\n# Run your flow - tracing happens automatically\r\nflow = MyFlow()\r\nshared = {\"input\": \"Hello World\"}\r\nflow.run(shared)\r\n```\r\n\r\n## \ud83d\udcca What Gets Traced\r\n\r\nWhen you apply the `@trace_flow()` decorator, the system automatically traces:\r\n\r\n### Flow Level\r\n- **Flow Start/End**: Overall execution time and status\r\n- **Input Data**: Initial shared state when flow starts\r\n- **Output Data**: Final shared state when flow completes\r\n- **Errors**: Any exceptions that occur during flow execution\r\n\r\n### Node Level\r\nFor each node in your flow, the system traces:\r\n\r\n- **prep() Phase**: \r\n - Input: `shared` data\r\n - Output: `prep_res` returned by prep method\r\n - Execution time and any errors\r\n\r\n- **exec() Phase**:\r\n - Input: `prep_res` from prep phase\r\n - Output: `exec_res` returned by exec method\r\n - Execution time and any errors\r\n - Retry attempts (if configured)\r\n\r\n- **post() Phase**:\r\n - Input: `shared`, `prep_res`, `exec_res`\r\n - Output: Action string returned\r\n - Execution time and any errors\r\n\r\n## \ud83d\udd27 Configuration Options\r\n\r\n### Basic Configuration\r\n\r\n```python\r\nfrom tracing import trace_flow, TracingConfig\r\n\r\n# Use environment variables (default)\r\n@trace_flow()\r\nclass MyFlow(Flow):\r\n pass\r\n\r\n# Custom flow name\r\n@trace_flow(flow_name=\"CustomFlowName\")\r\nclass MyFlow(Flow):\r\n pass\r\n\r\n# Custom session and user IDs\r\n@trace_flow(session_id=\"session-123\", user_id=\"user-456\")\r\nclass MyFlow(Flow):\r\n pass\r\n```\r\n\r\n### Advanced Configuration\r\n\r\n```python\r\nfrom tracing import TracingConfig\r\n\r\n# Create custom configuration\r\nconfig = TracingConfig(\r\n langfuse_secret_key=\"your-secret-key\",\r\n langfuse_public_key=\"your-public-key\", \r\n langfuse_host=\"https://your-langfuse-instance.com\",\r\n debug=True,\r\n trace_inputs=True,\r\n trace_outputs=True,\r\n trace_errors=True\r\n)\r\n\r\n@trace_flow(config=config)\r\nclass MyFlow(Flow):\r\n pass\r\n```\r\n\r\n## \ud83d\udcc1 Examples\r\n\r\n### Basic Synchronous Flow\r\nSee `examples/basic_example.py` for a complete example of tracing a simple synchronous flow.\r\n\r\n```bash\r\ncd examples\r\npython basic_example.py\r\n```\r\n\r\n### Asynchronous Flow\r\nSee `examples/async_example.py` for basic async tracing and `examples/comprehensive_async_example.py` for advanced async features.\r\n\r\n```bash\r\ncd examples\r\npython async_example.py\r\n\r\n# For comprehensive async features demonstration\r\npython comprehensive_async_example.py\r\n```\r\n\r\n### \ud83d\ude80 Advanced Async Usage\r\n\r\nThe enhanced async support provides comprehensive tracing for complex async patterns:\r\n\r\n#### Concurrent Flow Execution\r\n```python\r\nimport asyncio\r\nfrom pocketflow_tracing import trace_flow\r\n\r\n@trace_flow(flow_name=\"ConcurrentFlow\")\r\nclass ConcurrentFlow(AsyncFlow):\r\n # ... your async flow definition ...\r\n\r\nasync def run_concurrent_flows():\r\n flows = [ConcurrentFlow() for _ in range(5)]\r\n shared_data = [{\"input\": f\"data_{i}\"} for i in range(5)]\r\n\r\n # Execute flows concurrently with proper tracing\r\n results = await asyncio.gather(*[\r\n flow.run_async(shared)\r\n for flow, shared in zip(flows, shared_data)\r\n ])\r\n\r\n return results\r\n```\r\n\r\n#### Error Handling and Recovery\r\n```python\r\nclass RobustAsyncNode(AsyncNode):\r\n def __init__(self, max_retries=3):\r\n super().__init__(max_retries=max_retries, wait=1.0)\r\n\r\n async def exec_async(self, prep_res):\r\n # This will automatically retry on failure\r\n return await risky_async_operation(prep_res)\r\n\r\n async def exec_fallback_async(self, prep_res, exc):\r\n # Fallback when all retries are exhausted\r\n return await safe_fallback_operation(prep_res)\r\n```\r\n\r\n#### Nested Flow Composition\r\n```python\r\n@trace_flow(flow_name=\"MainFlow\")\r\nclass MainFlow(AsyncFlow):\r\n async def run_async(self, shared):\r\n # Run main processing\r\n result = await super().run_async(shared)\r\n\r\n # Run nested analysis flow with proper context\r\n if result == \"success\":\r\n analysis_flow = AnalysisFlow()\r\n analysis_result = await analysis_flow.run_async(shared)\r\n shared[\"analysis\"] = analysis_result\r\n\r\n return result\r\n```\r\n\r\nFor complete migration guidance, see [docs/async_migration_guide.md](docs/async_migration_guide.md).\r\n\r\n## \ud83d\udd0d Viewing Traces\r\n\r\nAfter running your traced flows, visit your Langfuse dashboard to view the traces:\r\n\r\n**Dashboard URL**: Use the URL you configured in `LANGFUSE_HOST` environment variable\r\n\r\nIn the dashboard you'll see:\r\n- **Traces**: One trace per flow execution\r\n- **Spans**: Individual node phases (prep, exec, post)\r\n- **Input/Output Data**: All data flowing through your workflow\r\n- **Performance Metrics**: Execution times for each phase\r\n- **Error Details**: Stack traces and error messages\r\n\r\nThe tracings in examples.\r\n\r\n\r\nDetailed tracing for a node.\r\n\r\n\r\n## \ud83d\udee0\ufe0f Advanced Usage\r\n\r\n### Custom Tracer Configuration\r\n\r\n```python\r\nfrom tracing import TracingConfig, LangfuseTracer\r\n\r\n# Create custom configuration\r\nconfig = TracingConfig.from_env()\r\nconfig.debug = True\r\n\r\n# Use tracer directly (for advanced use cases)\r\ntracer = LangfuseTracer(config)\r\n```\r\n\r\n### Environment Variables\r\n\r\nYou can customize tracing behavior with these environment variables:\r\n\r\n```env\r\n# Required Langfuse configuration\r\nLANGFUSE_SECRET_KEY=your-secret-key\r\nLANGFUSE_PUBLIC_KEY=your-public-key\r\nLANGFUSE_HOST=your-langfuse-host\r\n\r\n# Optional tracing configuration\r\nPOCKETFLOW_TRACING_DEBUG=true\r\nPOCKETFLOW_TRACE_INPUTS=true\r\nPOCKETFLOW_TRACE_OUTPUTS=true\r\nPOCKETFLOW_TRACE_PREP=true\r\nPOCKETFLOW_TRACE_EXEC=true\r\nPOCKETFLOW_TRACE_POST=true\r\nPOCKETFLOW_TRACE_ERRORS=true\r\n\r\n# Optional session/user tracking\r\nPOCKETFLOW_SESSION_ID=your-session-id\r\nPOCKETFLOW_USER_ID=your-user-id\r\n```\r\n\r\n## \ud83d\udc1b Troubleshooting\r\n\r\n### Common Issues\r\n\r\n1. **\"langfuse package not installed\"**\r\n ```bash\r\n pip install langfuse\r\n ```\r\n\r\n2. **\"Langfuse client initialization failed\"**\r\n - Check your `.env` file configuration\r\n - Verify Langfuse server is running at the specified host\r\n - Check network connectivity\r\n\r\n3. **\"No traces appearing in dashboard\"**\r\n - Ensure `POCKETFLOW_TRACING_DEBUG=true` to see debug output\r\n - Check that your flow is actually being executed\r\n - Verify Langfuse credentials are correct\r\n\r\n### Debug Mode\r\n\r\nEnable debug mode to see detailed tracing information:\r\n\r\n```env\r\nPOCKETFLOW_TRACING_DEBUG=true\r\n```\r\n\r\nThis will print detailed information about:\r\n- Langfuse client initialization\r\n- Trace and span creation\r\n- Data serialization\r\n- Error messages\r\n\r\n## \ud83d\udcda API Reference\r\n\r\n### `@trace_flow()`\r\n\r\nDecorator to add Langfuse tracing to PocketFlow flows.\r\n\r\n**Parameters:**\r\n- `config` (TracingConfig, optional): Custom configuration. If None, loads from environment.\r\n- `flow_name` (str, optional): Custom name for the flow. If None, uses class name.\r\n- `session_id` (str, optional): Session ID for grouping related traces.\r\n- `user_id` (str, optional): User ID for the trace.\r\n\r\n### `TracingConfig`\r\n\r\nConfiguration class for tracing settings.\r\n\r\n**Methods:**\r\n- `TracingConfig.from_env()`: Create config from environment variables\r\n- `validate()`: Check if configuration is valid\r\n- `to_langfuse_kwargs()`: Convert to Langfuse client kwargs\r\n\r\n### `LangfuseTracer`\r\n\r\nCore tracer class for Langfuse integration.\r\n\r\n**Methods:**\r\n- `start_trace()`: Start a new trace\r\n- `end_trace()`: End the current trace\r\n- `start_node_span()`: Start a span for node execution\r\n- `end_node_span()`: End a node execution span\r\n- `flush()`: Flush pending traces to Langfuse\r\n\r\n## \ud83e\udd1d Contributing\r\n\r\nThis cookbook is designed to be a starting point for PocketFlow observability. Feel free to extend and customize it for your specific needs!\r\n\r\n## \ud83d\udcc4 License\r\n\r\nThis cookbook follows the same license as PocketFlow.\r\n",
"bugtrack_url": null,
"license": null,
"summary": "Observability and tracing for PocketFlow workflows using Langfuse",
"version": "0.1.3",
"project_urls": {
"Bug Tracker": "https://github.com/redreamality/PocketFlow/issues",
"Documentation": "https://redreamality.com/blog/pocketflow-tracing",
"Homepage": "https://redreamality.com/blog/pocketflow-tracing",
"Repository": "https://github.com/redreamality/PocketFlow/tree/main/cookbook/pocketflow-tracing"
},
"split_keywords": [
"pocketflow",
" tracing",
" observability",
" langfuse",
" workflow",
" monitoring",
" llm",
" ai"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "95c2c9b21cf5fc918bfc8e53889bb03dafb755b4224d97d3d577b5a4bfa90a04",
"md5": "73ebe59c017c4c61089cd81bb50d2aee",
"sha256": "f99a855b243a2f07fca812081700a11603b5f8a218e7f8f7987afeac2d5c900e"
},
"downloads": -1,
"filename": "pocketflow_tracing-0.1.3-py3-none-any.whl",
"has_sig": false,
"md5_digest": "73ebe59c017c4c61089cd81bb50d2aee",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.11",
"size": 30152,
"upload_time": "2025-08-01T02:03:16",
"upload_time_iso_8601": "2025-08-01T02:03:16.240109Z",
"url": "https://files.pythonhosted.org/packages/95/c2/c9b21cf5fc918bfc8e53889bb03dafb755b4224d97d3d577b5a4bfa90a04/pocketflow_tracing-0.1.3-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "ff965b5f4089fb47552e35a36475ba61236b3f9d62dfe91ac551951d61a06d13",
"md5": "682745d15d08e4c94ed326ae0d571e40",
"sha256": "ae2893a196550b55aa96a6a42b14e316b7d3a6e30d6dbeb8e47a9c7c3dc79460"
},
"downloads": -1,
"filename": "pocketflow_tracing-0.1.3.tar.gz",
"has_sig": false,
"md5_digest": "682745d15d08e4c94ed326ae0d571e40",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.11",
"size": 55166,
"upload_time": "2025-08-01T02:03:18",
"upload_time_iso_8601": "2025-08-01T02:03:18.065089Z",
"url": "https://files.pythonhosted.org/packages/ff/96/5b5f4089fb47552e35a36475ba61236b3f9d62dfe91ac551951d61a06d13/pocketflow_tracing-0.1.3.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-01 02:03:18",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "redreamality",
"github_project": "PocketFlow",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "pocketflow-tracing"
}
JSON
