tomevault-io DAPR Code Generator
This skill generates production-ready Python code for DAPR applications following best practices.
When to Use
Claude automatically uses this skill when:
- User creates a new DAPR service
- Adding DAPR features to existing code
- Scaffolding microservice projects
- Creating workflows or actors
Code Templates
FastAPI Microservice
"""
{service_name} - DAPR-enabled FastAPI microservice
"""
import json
import logging
from contextlib import asynccontextmanager
from typing import Any
from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel
from dapr.clients import DaprClient
from dapr.ext.fastapi import DaprApp
# Configure logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
# Constants
DAPR_STORE_NAME = "statestore"
DAPR_PUBSUB_NAME = "pubsub"
@asynccontextmanager
async def lifespan(app: FastAPI):
"""Application lifespan handler."""
logger.info("Starting {service_name}")
yield
logger.info("Shutting down {service_name}")
app = FastAPI(
title="{service_name}",
lifespan=lifespan
)
dapr_app = DaprApp(app)
# Health endpoints
@app.get("/health")
async def health():
"""Health check endpoint."""
return {"status": "healthy"}
@app.get("/ready")
async def ready():
"""Readiness check endpoint."""
return {"status": "ready"}
# DAPR State Management
async def save_state(key: str, value: Any) -> None:
"""Save state to DAPR state store."""
async with DaprClient() as client:
await client.save_state(
store_name=DAPR_STORE_NAME,
key=key,
value=json.dumps(value)
)
logger.info(f"State saved: {key}")
async def get_state(key: str) -> Any:
"""Get state from DAPR state store."""
async with DaprClient() as client:
state = await client.get_state(
store_name=DAPR_STORE_NAME,
key=key
)
if state.data:
return json.loads(state.data)
return None
# DAPR Pub/Sub
async def publish_event(topic: str, data: Any) -> None:
"""Publish event to DAPR pub/sub."""
async with DaprClient() as client:
await client.publish_event(
pubsub_name=DAPR_PUBSUB_NAME,
topic_name=topic,
data=json.dumps(data),
data_content_type="application/json"
)
logger.info(f"Event published to {topic}")
# DAPR Service Invocation
async def invoke_service(app_id: str, method: str, data: Any = None) -> Any:
"""Invoke another DAPR service."""
async with DaprClient() as client:
response = await client.invoke_method(
app_id=app_id,
method_name=method,
data=json.dumps(data) if data else None,
content_type="application/json"
)
return response.json() if response.data else None
# Example API endpoints - customize as needed
class ItemModel(BaseModel):
id: str
name: str
data: dict = {}
@app.post("/items")
async def create_item(item: ItemModel):
"""Create a new item."""
await save_state(f"item-{item.id}", item.model_dump())
await publish_event("items", {"action": "created", "item": item.model_dump()})
return {"status": "created", "id": item.id}
@app.get("/items/{item_id}")
async def get_item(item_id: str):
"""Get an item by ID."""
item = await get_state(f"item-{item_id}")
if not item:
raise HTTPException(status_code=404, detail="Item not found")
return item
# DAPR Pub/Sub subscription
@dapr_app.subscribe(pubsub=DAPR_PUBSUB_NAME, topic="items")
async def handle_item_event(event: dict):
"""Handle item events from pub/sub."""
logger.info(f"Received event: {event}")
return {"status": "SUCCESS"}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)
Workflow Service
"""
{workflow_name} - DAPR Workflow Service
"""
import logging
from datetime import timedelta
from dapr.ext.workflow import (
WorkflowRuntime,
DaprWorkflowClient,
DaprWorkflowContext,
WorkflowActivityContext,
RetryPolicy
)
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# Initialize workflow runtime
wf_runtime = WorkflowRuntime()
# Retry policy for activities
default_retry = RetryPolicy(
max_number_of_attempts=3,
first_retry_interval=timedelta(seconds=1),
backoff_coefficient=2.0,
max_retry_interval=timedelta(seconds=30)
)
# Workflow definition
@wf_runtime.workflow(name="{workflow_name}")
def {workflow_name}_workflow(ctx: DaprWorkflowContext, input_data: dict):
"""
Main workflow definition.
Args:
ctx: Workflow context
input_data: Input data for the workflow
Returns:
Workflow result
"""
logger.info(f"Starting workflow with input: {input_data}")
# Step 1: First activity
step1_result = yield ctx.call_activity(
activity=step1_activity,
input=input_data
)
logger.info(f"Step 1 completed: {step1_result}")
# Step 2: Second activity
step2_result = yield ctx.call_activity(
activity=step2_activity,
input=step1_result
)
logger.info(f"Step 2 completed: {step2_result}")
# Step 3: Final activity
final_result = yield ctx.call_activity(
activity=step3_activity,
input=step2_result
)
return {"status": "completed", "result": final_result}
# Activity definitions
@wf_runtime.activity(name="step1_activity")
def step1_activity(ctx: WorkflowActivityContext, data: dict) -> dict:
"""First step of the workflow."""
logger.info(f"Executing step 1 with: {data}")
# Your logic here
return {"step": 1, "data": data}
@wf_runtime.activity(name="step2_activity")
def step2_activity(ctx: WorkflowActivityContext, data: dict) -> dict:
"""Second step of the workflow."""
logger.info(f"Executing step 2 with: {data}")
# Your logic here
return {"step": 2, "data": data}
@wf_runtime.activity(name="step3_activity")
def step3_activity(ctx: WorkflowActivityContext, data: dict) -> dict:
"""Third step of the workflow."""
logger.info(f"Executing step 3 with: {data}")
# Your logic here
return {"step": 3, "data": data}
# Start workflow runtime
if __name__ == "__main__":
logger.info("Starting workflow runtime...")
wf_runtime.start()
# Keep the runtime running
import time
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
logger.info("Shutting down workflow runtime...")
wf_runtime.shutdown()
Actor Service
"""
{actor_name} - DAPR Virtual Actor
"""
import logging
from abc import abstractmethod
from dapr.actor import Actor, ActorInterface, ActorProxy, Remindable, actormethod
from dapr.actor.runtime.config import ActorRuntimeConfig, ActorTypeConfig
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# Actor interface
class {actor_name}Interface(ActorInterface):
"""Interface for {actor_name} actor."""
@abstractmethod
async def get_state(self) -> dict:
"""Get the current state of the actor."""
...
@abstractmethod
async def set_state(self, data: dict) -> None:
"""Set the state of the actor."""
...
@abstractmethod
async def process(self, input_data: dict) -> dict:
"""Process input data and return result."""
...
# Actor implementation
class {actor_name}(Actor, {actor_name}Interface, Remindable):
"""
{actor_name} virtual actor implementation.
This actor maintains state and can process requests.
"""
def __init__(self, ctx, actor_id):
super().__init__(ctx, actor_id)
self._state = {}
async def _on_activate(self) -> None:
"""Called when actor is activated."""
logger.info(f"Actor {self.id} activated")
# Load state if exists
has_state, state = await self._state_manager.try_get_state("actor_state")
if has_state:
self._state = state
async def _on_deactivate(self) -> None:
"""Called when actor is deactivated."""
logger.info(f"Actor {self.id} deactivated")
@actormethod(name="GetState")
async def get_state(self) -> dict:
"""Get the current state of the actor."""
return self._state
@actormethod(name="SetState")
async def set_state(self, data: dict) -> None:
"""Set the state of the actor."""
self._state = data
await self._state_manager.set_state("actor_state", self._state)
await self._state_manager.save_state()
@actormethod(name="Process")
async def process(self, input_data: dict) -> dict:
"""Process input data and return result."""
logger.info(f"Processing: {input_data}")
# Your processing logic here
result = {"processed": True, "input": input_data}
return result
async def receive_reminder(self, name: str, state: bytes, due_time, period) -> None:
"""Handle reminder callback."""
logger.info(f"Reminder received: {name}")
# Handle the reminder
# Actor runtime configuration
actor_runtime_config = ActorRuntimeConfig()
actor_runtime_config.register_actor({actor_name})
# FastAPI integration
from fastapi import FastAPI
from dapr.ext.fastapi import DaprActor
app = FastAPI(title="{actor_name} Service")
actor = DaprActor(app)
@app.on_event("startup")
async def startup():
await actor.register_actor({actor_name})
@app.get("/health")
async def health():
return {"status": "healthy"}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)
Generated File Structure
When generating a new service, create:
{service_name}/
├── src/
│ ├── __init__.py
│ ├── main.py # Main application
│ ├── models.py # Pydantic models
│ ├── services.py # Business logic
│ └── config.py # Configuration
├── components/
│ ├── statestore.yaml # State store component
│ ├── pubsub.yaml # Pub/sub component
│ └── secrets.yaml # Secrets component
├── tests/
│ ├── __init__.py
│ └── test_main.py # Unit tests
├── dapr.yaml # DAPR configuration
├── requirements.txt # Python dependencies
├── Dockerfile # Container image
└── README.md # Documentation
Requirements Template
# DAPR SDK
dapr>=1.12.0
dapr-ext-fastapi>=1.12.0
dapr-ext-workflow>=0.4.0
# Web framework
fastapi>=0.104.0
uvicorn>=0.24.0
# Utilities
pydantic>=2.0.0
python-dotenv>=1.0.0
# Observability
opentelemetry-api>=1.20.0
opentelemetry-sdk>=1.20.0
opentelemetry-instrumentation-fastapi>=0.41b0
Dockerfile Template
FROM python:3.11-slim
WORKDIR /app
# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copy application
COPY src/ ./src/
# Run application
EXPOSE 8000
CMD ["python", "src/main.py"]
Converted and distributed by TomeVault — claim your Tome and manage your conversions.