@totaland/create-starter-kit 2.0.3 → 2.0.5

package/templates/python-backend/src/lib/llm.py

@@ -0,0 +1,155 @@
+"""
+LLM Provider abstraction layer.
+
+Provides a unified interface for OpenAI and Anthropic models with:
+- Streaming support
+- Token counting
+- Retry logic with exponential backoff
+- LangSmith tracing integration
+"""
+
+from typing import Literal, AsyncIterator
+from functools import lru_cache
+
+from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import BaseMessage, AIMessageChunk
+from langchain_core.callbacks import AsyncCallbackHandler
+import tiktoken
+
+from src.config import get_settings
+from src.lib.logging import get_logger
+
+logger = get_logger(__name__)
+
+LLMProvider = Literal["openai", "anthropic"]
+
+
+@lru_cache
+def get_openai_model(
+    model: str | None = None,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+    streaming: bool | None = None,
+) -> ChatOpenAI:
+    """Get a cached OpenAI chat model instance."""
+    settings = get_settings()
+    return ChatOpenAI(
+        model=model or settings.openai_model,
+        api_key=settings.openai_api_key,
+        temperature=temperature if temperature is not None else settings.llm_temperature,
+        max_tokens=max_tokens or settings.llm_max_tokens,
+        streaming=streaming if streaming is not None else settings.llm_streaming,
+    )
+
+
+@lru_cache
+def get_anthropic_model(
+    model: str | None = None,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+    streaming: bool | None = None,
+) -> ChatAnthropic:
+    """Get a cached Anthropic chat model instance."""
+    settings = get_settings()
+    return ChatAnthropic(
+        model=model or settings.anthropic_model,
+        api_key=settings.anthropic_api_key,
+        temperature=temperature if temperature is not None else settings.llm_temperature,
+        max_tokens=max_tokens or settings.llm_max_tokens,
+        streaming=streaming if streaming is not None else settings.llm_streaming,
+    )
+
+
+def get_llm(
+    provider: LLMProvider | None = None,
+    model: str | None = None,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+    streaming: bool | None = None,
+) -> BaseChatModel:
+    """
+    Get an LLM instance based on the provider.
+    
+    Args:
+        provider: "openai" or "anthropic". Defaults to settings.default_llm_provider
+        model: Model name override
+        temperature: Temperature override
+        max_tokens: Max tokens override
+        streaming: Streaming override
+    
+    Returns:
+        A configured chat model instance
+    """
+    settings = get_settings()
+    provider = provider or settings.default_llm_provider
+    
+    if provider == "openai":
+        return get_openai_model(model, temperature, max_tokens, streaming)
+    elif provider == "anthropic":
+        return get_anthropic_model(model, temperature, max_tokens, streaming)
+    else:
+        raise ValueError(f"Unknown provider: {provider}")
+
+
+async def stream_llm_response(
+    messages: list[BaseMessage],
+    provider: LLMProvider | None = None,
+    model: str | None = None,
+    callbacks: list[AsyncCallbackHandler] | None = None,
+) -> AsyncIterator[str]:
+    """
+    Stream LLM response as text chunks.
+    
+    Args:
+        messages: List of chat messages
+        provider: LLM provider
+        model: Model name override
+        callbacks: Optional async callbacks
+    
+    Yields:
+        Text chunks from the LLM response
+    """
+    llm = get_llm(provider=provider, model=model, streaming=True)
+    
+    async for chunk in llm.astream(messages, config={"callbacks": callbacks or []}):
+        if isinstance(chunk, AIMessageChunk) and chunk.content:
+            yield str(chunk.content)
+
+
+def count_tokens(text: str, model: str = "gpt-4o") -> int:
+    """
+    Count tokens in text using tiktoken.
+    
+    Args:
+        text: Text to count tokens for
+        model: Model name for encoding selection
+    
+    Returns:
+        Token count
+    """
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        encoding = tiktoken.get_encoding("cl100k_base")
+    return len(encoding.encode(text))
+
+
+def count_message_tokens(messages: list[BaseMessage], model: str = "gpt-4o") -> int:
+    """
+    Count tokens in a list of messages.
+    
+    Args:
+        messages: List of messages to count
+        model: Model name for encoding
+    
+    Returns:
+        Total token count
+    """
+    total = 0
+    for message in messages:
+        total += count_tokens(str(message.content), model)
+        total += 4  # Overhead per message
+    total += 2  # Conversation overhead
+    return total

package/templates/python-backend/src/lib/logging.py

@@ -0,0 +1,25 @@
+import structlog
+from src.config import get_settings
+
+settings = get_settings()
+
+
+def configure_logging() -> None:
+    structlog.configure(
+        processors=[
+            structlog.contextvars.merge_contextvars,
+            structlog.processors.add_log_level,
+            structlog.processors.StackInfoRenderer(),
+            structlog.dev.set_exc_info,
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.dev.ConsoleRenderer() if settings.debug else structlog.processors.JSONRenderer(),
+        ],
+        wrapper_class=structlog.make_filtering_bound_logger(10 if settings.debug else 20),
+        context_class=dict,
+        logger_factory=structlog.PrintLoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+
+def get_logger(name: str = __name__) -> structlog.stdlib.BoundLogger:
+    return structlog.get_logger(name)

package/templates/python-backend/src/main.py

@@ -0,0 +1,41 @@
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+from fastapi import FastAPI
+from fastapi.responses import ORJSONResponse
+
+from src.config import get_settings
+from src.lib.logging import configure_logging, get_logger
+from src.features import health, orders, chat, agents
+
+
+settings = get_settings()
+configure_logging()
+logger = get_logger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    logger.info("Starting application", app_name=settings.app_name)
+    yield
+    logger.info("Shutting down application")
+
+
+app = FastAPI(
+    title=settings.app_name,
+    description="Fast Python backend starter kit with high-performance packages",
+    version="1.0.0",
+    default_response_class=ORJSONResponse,
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+app.include_router(health.router)
+app.include_router(orders.router)
+app.include_router(chat.router)
+app.include_router(agents.router)
+
+
+@app.get("/")
+async def root() -> dict[str, str]:
+    return {"message": "Welcome to Python Starter Kit"}

package/templates/python-backend/tests/__init__.py

@@ -0,0 +1 @@
+

package/templates/python-backend/tests/test_health.py

@@ -0,0 +1,26 @@
+import pytest
+from httpx import AsyncClient, ASGITransport
+from src.main import app
+
+
+@pytest.fixture
+async def client() -> AsyncClient:
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as ac:
+        yield ac
+
+
+@pytest.mark.asyncio
+async def test_health_check(client: AsyncClient) -> None:
+    response = await client.get("/health")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "healthy"
+    assert "timestamp" in data
+
+
+@pytest.mark.asyncio
+async def test_root(client: AsyncClient) -> None:
+    response = await client.get("/")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Welcome to Python Starter Kit"}

package/templates/python-backend/tests/test_orders.py

@@ -0,0 +1,38 @@
+import pytest
+from httpx import AsyncClient, ASGITransport
+from src.main import app
+
+
+@pytest.fixture
+async def client() -> AsyncClient:
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as ac:
+        yield ac
+
+
+@pytest.mark.asyncio
+async def test_create_order(client: AsyncClient) -> None:
+    response = await client.post(
+        "/orders",
+        json={"product": "Widget", "quantity": 5, "price": 19.99},
+    )
+    assert response.status_code == 201
+    data = response.json()
+    assert data["product"] == "Widget"
+    assert data["quantity"] == 5
+    assert data["price"] == 19.99
+    assert "id" in data
+
+
+@pytest.mark.asyncio
+async def test_list_orders(client: AsyncClient) -> None:
+    response = await client.get("/orders")
+    assert response.status_code == 200
+    data = response.json()
+    assert "orders" in data
+
+
+@pytest.mark.asyncio
+async def test_get_order_not_found(client: AsyncClient) -> None:
+    response = await client.get("/orders/nonexistent")
+    assert response.status_code == 404