planar 0.5.0__py3-none-any.whl

planar/scaffold_templates/app/db/entities.py.j2

@@ -0,0 +1,11 @@
+from planar.modeling.mixins import TimestampMixin
+from planar.modeling.orm import Field, PlanarBaseEntity
+
+
+class Invoice(PlanarBaseEntity, TimestampMixin, table=True):
+    """Invoice entity"""
+
+    __tablename__ = "invoice"
+
+    vendor: str = Field()
+    amount: float = Field()

planar/scaffold_templates/app/flows/process_invoice.py.j2

@@ -0,0 +1,67 @@
+from planar.ai import Agent
+from planar.ai.providers import OpenAI
+from planar.files import PlanarFile
+from planar.human import Human
+from planar.rules.decorator import rule
+from planar.workflows import step, workflow
+from pydantic import BaseModel
+
+
+class InvoiceData(BaseModel):
+    vendor: str
+    amount: float
+
+
+class RuleInput(BaseModel):
+    amount: float
+
+
+class RuleOutput(BaseModel):
+    approved: bool
+    reason: str
+
+
+invoice_agent = Agent(
+    name="Invoice Agent",
+    model=OpenAI.gpt_4_1,
+    tools=[],
+    max_turns=1,
+    system_prompt="Extract vendor and amount from invoice text.",
+    user_prompt="{{ '{{input}}' }}",
+    input_type=PlanarFile,
+    output_type=InvoiceData,
+)
+
+
+human_review = Human(
+    name="Review Invoice",
+    title="Review Invoice",
+    input_type=InvoiceData,
+    output_type=InvoiceData,
+)
+
+
+@rule(description="Auto approve invoices under $1000")
+def auto_approve(input: RuleInput) -> RuleOutput:
+    return RuleOutput(approved=input.amount < 1000, reason="Amount is under $1000")
+
+
+@step(display_name="Extract invoice")
+async def extract_invoice(invoice_file: PlanarFile) -> InvoiceData:
+    result = await invoice_agent(invoice_file)
+    return result.output
+
+
+@step(display_name="Maybe approve")
+async def maybe_approve(invoice: InvoiceData) -> InvoiceData:
+    auto_approve_result = await auto_approve(RuleInput(amount=invoice.amount))
+    if auto_approve_result.approved:
+        return invoice
+    reviewed_invoice = await human_review(invoice, suggested_data=invoice)
+    return reviewed_invoice.output
+
+
+@workflow()
+async def process_invoice(invoice_file: PlanarFile) -> InvoiceData:
+    invoice = await extract_invoice(invoice_file)
+    return await maybe_approve(invoice)

planar/scaffold_templates/main.py.j2

@@ -0,0 +1,13 @@
+from planar import PlanarApp
+
+from app.db.entities import Invoice
+from app.flows.process_invoice import process_invoice
+from app.flows.process_invoice import invoice_agent
+
+
+app = (
+    PlanarApp(title="{{ name }}")
+    .register_entity(Invoice)
+    .register_workflow(process_invoice)
+    .register_agent(invoice_agent)
+)

planar/scaffold_templates/planar.dev.yaml.j2

@@ -0,0 +1,34 @@
+db_connections:
+  app:
+    driver: sqlite+aiosqlite
+    path: demo.db
+
+app:
+  db_connection: app
+
+storage:
+  backend: localdir
+  directory: .files
+
+sse_hub: true
+
+cors:
+  allow_origins: "^(?:https://(?:[a-zA-Z0-9-]+\\.)+coplane\\.(dev|com)|http://127.0.0.1:3000)$"
+  allow_credentials: true
+  allow_methods: ["*"]
+  allow_headers: ["*"]
+
+ai_providers:
+  openai:
+    api_key: ${OPENAI_API_KEY}
+
+logging:
+  planar:
+    level: INFO # enable INFO level logging for all modules in the "planar" package.
+  # Uncomment the following two lines to see SQL statements
+  # sqlalchemy.engine:  
+  #   level: INFO
+  # The root logger is represented by an empty string, so you can uncomment
+  # the following lines to enable INFO level for the whole application (except sqlalchemy.engine, which must be enabled above)
+  # "":
+  #  level: INFO

planar/scaffold_templates/planar.prod.yaml.j2

@@ -0,0 +1,28 @@
+db_connections:
+  app:
+    driver: postgresql+asyncpg
+    host: ${DB_HOST}
+    port: ${DB_PORT}
+    user: ${DB_USER}
+    password: ${DB_PASSWORD}
+    db: ${DB_NAME}
+
+app:
+  db_connection: app
+
+storage:
+  backend: s3
+  region: us-west-2
+  bucket_name: ${S3_BUCKET_NAME}
+
+sse_hub: true
+
+cors:
+  allow_origins: "^(?:https://(?:[a-zA-Z0-9-]+\\.)+coplane\\.(dev|com)|http://127.0.0.1:3000)$"
+  allow_credentials: true
+  allow_methods: ["*"]
+  allow_headers: ["*"]
+
+ai_providers:
+  openai:
+    api_key: ${OPENAI_API_KEY}

planar/scaffold_templates/pyproject.toml.j2

@@ -0,0 +1,10 @@
+[project]
+name = "{{ name }}"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = [
+    "planar>=0.1.0",
+]
+
+[[tool.uv.index]]
+url = "https://coplane.github.io/planar/simple/"

planar/security/auth_context.py

@@ -0,0 +1,148 @@
+"""
+Authentication context management for Planar.
+
+This module provides context variables and utilities for managing the current
+authenticated principal (user) throughout the request lifecycle.
+"""
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any, Iterator
+
+from pydantic import BaseModel, Field
+
+
+class Principal(BaseModel):
+    """Represents an authenticated principal (user) with JWT claims."""
+
+    # Standard JWT claims
+    sub: str = Field(..., description="Subject (user ID)")
+    iss: str | None = Field(None, description="Issuer")
+    exp: int | None = Field(None, description="Expiration timestamp")
+    iat: int | None = Field(None, description="Issued at timestamp")
+    sid: str | None = Field(None, description="Session ID")
+    jti: str | None = Field(None, description="JWT ID")
+
+    # WorkOS specific claims
+    org_id: str | None = Field(None, description="Organization ID")
+    org_name: str | None = Field(None, description="Organization name")
+    user_first_name: str | None = Field(None, description="User's first name")
+    user_last_name: str | None = Field(None, description="User's last name")
+    user_email: str | None = Field(None, description="User's email address")
+    role: str | None = Field(None, description="User's role")
+    permissions: list[str] | None = Field(None, description="User's permissions")
+
+    # Additional custom claims
+    extra_claims: dict[str, Any] = Field(
+        default_factory=dict, description="Additional custom claims"
+    )
+
+    @classmethod
+    def from_jwt_payload(cls, payload: dict[str, Any]) -> "Principal":
+        """Create a Principal from a JWT payload."""
+        if "sub" not in payload:
+            raise ValueError("JWT payload must contain 'sub' field")
+
+        standard_fields = {
+            "sub",
+            "iss",
+            "exp",
+            "iat",
+            "sid",
+            "jti",
+            "org_id",
+            "org_name",
+            "user_first_name",
+            "user_last_name",
+            "user_email",
+            "role",
+            "permissions",
+        }
+
+        # Extract standard fields
+        principal_data = {}
+        for field in standard_fields:
+            if field in payload:
+                principal_data[field] = payload[field]
+
+        # All other fields go into extra_claims
+        extra_claims = {k: v for k, v in payload.items() if k not in standard_fields}
+        principal_data["extra_claims"] = extra_claims
+
+        return cls(**principal_data)
+
+
+# Context variable for the current principal
+principal_var: ContextVar[Principal | None] = ContextVar("principal", default=None)
+
+
+def get_current_principal() -> Principal | None:
+    """
+    Get the current authenticated principal from context.
+
+    Returns:
+        The current Principal or None if not authenticated.
+    """
+    return principal_var.get()
+
+
+def require_principal() -> Principal:
+    """
+    Get the current authenticated principal from context.
+
+    Returns:
+        The current Principal.
+
+    Raises:
+        RuntimeError: If no principal is set in context.
+    """
+    principal = get_current_principal()
+    if principal is None:
+        raise RuntimeError("No authenticated principal in context")
+    return principal
+
+
+def has_role(role: str) -> bool:
+    """
+    Check if the current principal has the given role.
+    """
+    principal = get_current_principal()
+    return principal is not None and principal.role == role
+
+
+def set_principal(principal: Principal) -> Any:
+    """
+    Set the current principal in context.
+
+    Args:
+        principal: The principal to set.
+
+    Returns:
+        A token that can be used to reset the context.
+    """
+    return principal_var.set(principal)
+
+
+def clear_principal(token: Any) -> None:
+    """
+    Clear the current principal from context.
+
+    Args:
+        token: The token returned from set_principal.
+    """
+    principal_var.reset(token)
+
+
+@contextmanager
+def as_principal(principal: Principal) -> Iterator[None]:
+    """
+    Context manager that sets the current principal in context.
+
+    Args:
+        principal: The principal to set.
+    """
+    token = set_principal(principal)
+    try:
+        yield
+    finally:
+        clear_principal(token)