lambda-erp 0.1.0__py3-none-any.whl

api/pdf.py

@@ -0,0 +1,151 @@
+"""PDF generation for ERP documents."""
+
+import os
+from jinja2 import Environment, FileSystemLoader
+from weasyprint import HTML
+from lambda_erp.database import get_db
+from api.services import load_document
+
+TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates")
+_jinja_env = Environment(loader=FileSystemLoader(TEMPLATE_DIR), autoescape=True)
+
+# Document type → (title, party_field, party_name_field, party_doctype, party_label)
+DOC_CONFIG = {
+    "Quotation":        ("Quotation",        "customer", "customer_name", "Customer", "Customer"),
+    "Sales Order":      ("Sales Order",      "customer", "customer_name", "Customer", "Customer"),
+    "Sales Invoice":    ("Sales Invoice",    "customer", "customer_name", "Customer", "Customer"),
+    "Purchase Order":   ("Purchase Order",   "supplier", "supplier_name", "Supplier", "Supplier"),
+    "Purchase Invoice": ("Purchase Invoice", "supplier", "supplier_name", "Supplier", "Supplier"),
+    "Delivery Note":    ("Delivery Note",    "customer", "customer_name", "Customer", "Customer"),
+    "Purchase Receipt": ("Purchase Receipt", "supplier", "supplier_name", "Supplier", "Supplier"),
+}
+
+SHOW_WAREHOUSE = {"Delivery Note", "Purchase Receipt"}
+
+
+def _get_dict(row):
+    """Convert a database row to a plain dict."""
+    if row is None:
+        return {}
+    if isinstance(row, dict):
+        return row
+    return dict(row) if row else {}
+
+
+def generate_pdf(doctype_slug: str, name: str) -> bytes:
+    """Generate a PDF for a document and return raw bytes."""
+    doc = load_document(doctype_slug, name)
+    db = get_db()
+
+    # Resolve doctype display name
+    doctype = doctype_slug.replace("-", " ").title()
+    # Fix multi-word: "Sales Invoice" not "Sales-Invoice"
+    for dt in DOC_CONFIG:
+        if dt.lower().replace(" ", "-") == doctype_slug:
+            doctype = dt
+            break
+
+    config = DOC_CONFIG.get(doctype)
+    if not config:
+        # Fallback for unknown types
+        config = (doctype, None, None, None, "Party")
+
+    title, party_field, party_name_field, party_doctype, party_label = config
+
+    # Credit note / debit note titles
+    if doc.get("is_return"):
+        if doctype == "Sales Invoice":
+            title = "Credit Note"
+        elif doctype == "Purchase Invoice":
+            title = "Debit Note"
+        else:
+            title = f"{title} (Return)"
+
+    # Party info
+    party_name = doc.get(party_name_field or "", "") or doc.get(party_field or "", "")
+    party_info = {}
+    if party_field and party_doctype and doc.get(party_field):
+        fields = ["email", "phone", "address", "city", "zip_code", "country", "tax_id"]
+        if party_name_field:
+            fields = [party_name_field, *fields]
+        row = db.get_value(party_doctype, doc[party_field], fields)
+        if row:
+            party_info = _get_dict(row)
+            # Show the party's CURRENT name from the master, so a later
+            # correction (e.g. fixing a typo) appears on the PDF — consistent
+            # with the address fields, which are already looked up live. The
+            # name stored on the document is only a fallback for when the
+            # master record no longer exists.
+            live_name = party_info.get(party_name_field) if party_name_field else None
+            if live_name:
+                party_name = live_name
+
+    # Company info
+    company_id = doc.get("company", "")
+    company_name = company_id  # fallback to the id if the master is gone
+    company_info = {}
+    if company_id:
+        row = db.get_value("Company", company_id,
+                           ["company_name", "email", "phone", "address", "city", "zip_code", "country", "tax_id"])
+        if row:
+            company_info = _get_dict(row)
+            # Show the company's CURRENT display name from the master.
+            company_name = company_info.get("company_name") or company_id
+
+    # Currency
+    currency = doc.get("currency", "USD") or "USD"
+
+    # Meta fields (varies by doc type)
+    meta_fields = []
+    if doc.get("posting_date"):
+        meta_fields.append({"label": "Date", "value": doc["posting_date"]})
+    elif doc.get("transaction_date"):
+        meta_fields.append({"label": "Date", "value": doc["transaction_date"]})
+    if doc.get("due_date"):
+        meta_fields.append({"label": "Due Date", "value": doc["due_date"]})
+    if doc.get("valid_till"):
+        meta_fields.append({"label": "Valid Till", "value": doc["valid_till"]})
+    if doc.get("delivery_date"):
+        meta_fields.append({"label": "Delivery Date", "value": doc["delivery_date"]})
+    if doc.get("return_against"):
+        meta_fields.append({"label": "Return Against", "value": doc["return_against"]})
+    if doc.get("status"):
+        meta_fields.append({"label": "Status", "value": doc["status"]})
+
+    # Items — refresh each line's item_name from the Item master so a later
+    # correction to an item's name appears on the PDF, consistent with the
+    # party/company names. Quantities, rates, and amounts stay as transacted.
+    # Falls back to the name stored on the line if the master is gone.
+    items = doc.get("items", [])
+    for item in items:
+        code = item.get("item_code")
+        if code:
+            live_item_name = db.get_value("Item", code, "item_name")
+            if live_item_name:
+                item["item_name"] = live_item_name
+
+    taxes = doc.get("taxes", [])
+
+    # Page size setting
+    page_size_row = db.sql('SELECT value FROM "Settings" WHERE key = "pdf_page_size"')
+    page_size = page_size_row[0]["value"] if page_size_row else "A4"
+
+    # Render
+    template = _jinja_env.get_template("document.html")
+    html_str = template.render(
+        doc=doc,
+        title=title,
+        company_name=company_name,
+        company_info=company_info,
+        party_label=party_label,
+        party_name=party_name,
+        party_info=party_info,
+        currency=currency,
+        meta_fields=meta_fields,
+        items=items,
+        taxes=taxes,
+        show_warehouse=doctype in SHOW_WAREHOUSE,
+        page_size=page_size,
+    )
+
+    return HTML(string=html_str).write_pdf()

api/providers.py

@@ -0,0 +1,116 @@
+"""Pricing data for external LLM APIs the chat orchestrator uses.
+
+Mirrors the shape of `lambda-web/backend/providers.py`. Only the models
+this app actually calls are listed — refresh this dict when model
+choices change. Prices are USD per 1M tokens.
+
+Consumers import `cost_of_openai_call` / `cost_of_anthropic_call` to
+turn an SDK `response.usage` object into a USD amount.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+# ---------------------------------------------------------------------------
+# Pricing dicts
+# ---------------------------------------------------------------------------
+
+OPENAI_PRICING: dict[str, dict[str, Any]] = {
+    "gpt-5.4": {
+        "tiered": True,
+        "tiers": [
+            {"max_input_tokens": 272_000, "input": 2.50, "cached_input": 0.25, "output": 15.00},
+            {"max_input_tokens": None,    "input": 5.00, "cached_input": 0.50, "output": 22.50},
+        ],
+    },
+    "gpt-4.1-nano": {"input": 0.10, "cached_input": 0.025, "output": 0.40},
+    "gpt-4.1-mini": {"input": 0.40, "cached_input": 0.10,  "output": 1.60},
+    "gpt-4.1":      {"input": 2.00, "cached_input": 0.50,  "output": 8.00},
+    "gpt-5":        {"input": 1.25, "cached_input": 0.125, "output": 10.00},
+    "gpt-5-mini":   {"input": 0.25, "cached_input": 0.025, "output": 2.00},
+    "gpt-5-nano":   {"input": 0.05, "cached_input": 0.005, "output": 0.40},
+    "gpt-4o":       {"input": 2.50, "cached_input": 1.25,  "output": 10.00},
+    "gpt-4o-mini":  {"input": 0.15, "cached_input": 0.075, "output": 0.60},
+}
+
+ANTHROPIC_PRICING: dict[str, dict[str, Any]] = {
+    "claude-opus-4-7":   {"input": 5.00, "output": 25.00, "cache_write": 6.25, "cache_read": 0.50},
+    "claude-opus-4-6":   {"input": 5.00, "output": 25.00, "cache_write": 6.25, "cache_read": 0.50},
+    "claude-sonnet-4-6": {"input": 3.00, "output": 15.00, "cache_write": 3.75, "cache_read": 0.30},
+    "claude-sonnet-4-5": {"input": 3.00, "output": 15.00, "cache_write": 3.75, "cache_read": 0.30},
+    "claude-haiku-4-5":  {"input": 1.00, "output": 5.00,  "cache_write": 1.25, "cache_read": 0.10},
+}
+
+
+# ---------------------------------------------------------------------------
+# Rate lookup — unknown models fall back to the most expensive model in each
+# family so we never under-count a call we forgot to register.
+# ---------------------------------------------------------------------------
+
+def get_openai_rates(model: str, input_tokens: int = 0) -> dict[str, float]:
+    entry = OPENAI_PRICING.get(model)
+    if entry is None:
+        entry = OPENAI_PRICING["gpt-5.4"]
+    if entry.get("tiered"):
+        for tier in entry["tiers"]:
+            cap = tier.get("max_input_tokens")
+            if cap is None or input_tokens <= cap:
+                return tier
+        return entry["tiers"][-1]
+    return entry
+
+
+def get_anthropic_rates(model: str) -> dict[str, float]:
+    return ANTHROPIC_PRICING.get(model) or ANTHROPIC_PRICING["claude-opus-4-7"]
+
+
+# ---------------------------------------------------------------------------
+# Cost calculators. `usage` is the SDK's raw usage object; we accept None
+# and degrade to 0 so callers don't need to pre-check.
+# ---------------------------------------------------------------------------
+
+def cost_of_openai_call(model: str, usage: Optional[Any]) -> float:
+    """USD cost of one OpenAI chat.completions call from `response.usage`.
+
+    Understands the `prompt_tokens_details.cached_tokens` breakdown so cache
+    hits are billed at the discounted rate."""
+    if usage is None:
+        return 0.0
+    prompt_tokens = int(getattr(usage, "prompt_tokens", 0) or 0)
+    completion_tokens = int(getattr(usage, "completion_tokens", 0) or 0)
+
+    cached = 0
+    details = getattr(usage, "prompt_tokens_details", None)
+    if details is not None:
+        cached = int(getattr(details, "cached_tokens", 0) or 0)
+
+    rates = get_openai_rates(model, input_tokens=prompt_tokens)
+    uncached = max(prompt_tokens - cached, 0)
+    cached_rate = rates.get("cached_input", rates["input"])
+    total = (
+        uncached * rates["input"]
+        + cached * cached_rate
+        + completion_tokens * rates["output"]
+    )
+    return total / 1_000_000
+
+
+def cost_of_anthropic_call(model: str, usage: Optional[Any]) -> float:
+    """USD cost of one Anthropic messages.create call from `response.usage`."""
+    if usage is None:
+        return 0.0
+    input_tokens = int(getattr(usage, "input_tokens", 0) or 0)
+    output_tokens = int(getattr(usage, "output_tokens", 0) or 0)
+    cache_create = int(getattr(usage, "cache_creation_input_tokens", 0) or 0)
+    cache_read = int(getattr(usage, "cache_read_input_tokens", 0) or 0)
+
+    rates = get_anthropic_rates(model)
+    total = (
+        input_tokens * rates["input"]
+        + cache_create * rates.get("cache_write", rates["input"])
+        + cache_read * rates.get("cache_read", rates["input"])
+        + output_tokens * rates["output"]
+    )
+    return total / 1_000_000

api/routers/accounting.py

@@ -0,0 +1,63 @@
+"""Accounting period-end actions (currently: foreign-currency revaluation)."""
+
+from fastapi import APIRouter, Depends
+from lambda_erp.database import get_db
+from lambda_erp.accounting.revaluation import run_period_revaluation
+from lambda_erp.utils import nowdate
+from api.auth import require_role
+
+router = APIRouter(prefix="/accounting", tags=["accounting"])
+
+
+def _resolve_company(db, company):
+    if company:
+        return company
+    companies = db.get_all("Company", fields=["name"], limit=1)
+    return companies[0]["name"] if companies else None
+
+
+@router.get("/currencies")
+def list_currencies(company: str | None = None, _user: dict = Depends(require_role("viewer"))):
+    """Currencies the books can transact in, for the document currency dropdown.
+
+    Returns the company base currency, every currency that has a Currency
+    Exchange rate on file, and any currency set as a default on a Company /
+    Customer / Supplier. Base currency first, then the rest alphabetically. We
+    only offer convertible currencies so a new document can't be denominated in
+    one the ledger has no rate path to base for.
+    """
+    db = get_db()
+    company = _resolve_company(db, company)
+    base = (db.get_value("Company", company, "default_currency") if company else None) or "USD"
+
+    found = {base}
+    for row in db.sql(
+        'SELECT from_currency AS c FROM "Currency Exchange" '
+        'UNION SELECT to_currency AS c FROM "Currency Exchange"'
+    ):
+        if row.get("c"):
+            found.add(row["c"])
+    for table in ("Company", "Customer", "Supplier"):
+        for row in db.sql(f'SELECT DISTINCT default_currency AS c FROM "{table}"'):
+            if row.get("c"):
+                found.add(row["c"])
+
+    others = sorted(found - {base})
+    return {"base_currency": base, "currencies": [base, *others]}
+
+
+@router.post("/revaluation")
+def period_revaluation(data: dict, _user: dict = Depends(require_role("manager"))):
+    """Preview or post period-end FX revaluation of open foreign balances.
+
+    Body: {company?, date?, post?}. With post=false (default) it's a dry run —
+    returns the per-balance breakdown without touching the ledger. With
+    post=true it posts the revaluation + a next-day auto-reversal.
+    """
+    db = get_db()
+    company = _resolve_company(db, data.get("company"))
+    if not company:
+        return {"detail": "No company found; create one first."}
+    return run_period_revaluation(
+        company, data.get("date") or nowdate(), post=bool(data.get("post", False))
+    )

api/routers/admin.py

@@ -0,0 +1,122 @@
+"""Admin-only observability endpoints.
+
+Currently exposes the demo spend overview. Add future admin-only
+reports here to keep `require_admin`-gated routes together.
+"""
+
+from __future__ import annotations
+
+import time
+
+from fastapi import APIRouter, Depends
+
+from api.auth import require_admin
+from api.demo_limits import init_schema, limiter
+from lambda_erp.database import get_db
+
+
+router = APIRouter(prefix="/admin", tags=["admin"])
+
+
+# Fixed windows the UI offers. Ordered for display.
+_WINDOWS = [
+    ("1h", 3600),
+    ("2h", 2 * 3600),
+    ("4h", 4 * 3600),
+    ("12h", 12 * 3600),
+    ("24h", 24 * 3600),
+    ("7d", 7 * 24 * 3600),
+]
+
+
+def _window_totals(now: float, seconds: int) -> dict:
+    db = get_db()
+    cutoff = now - seconds
+
+    totals = db.conn.execute(
+        'SELECT '
+        '  COALESCE(SUM(cost_usd), 0) AS total_usd, '
+        '  COALESCE(SUM(CASE WHEN role = "public_manager" THEN cost_usd ELSE 0 END), 0) AS demo_usd, '
+        '  COALESCE(SUM(prompt_tokens), 0) AS prompt_tokens, '
+        '  COALESCE(SUM(completion_tokens), 0) AS completion_tokens, '
+        '  COUNT(*) AS call_count, '
+        '  COUNT(DISTINCT ip) AS unique_ips '
+        'FROM "Demo Spend Log" WHERE ts > ?',
+        (cutoff,),
+    ).fetchone()
+
+    by_provider_rows = db.conn.execute(
+        'SELECT provider, '
+        '  COALESCE(SUM(cost_usd), 0) AS cost_usd, '
+        '  COUNT(*) AS call_count, '
+        '  COALESCE(SUM(prompt_tokens), 0) AS prompt_tokens, '
+        '  COALESCE(SUM(completion_tokens), 0) AS completion_tokens '
+        'FROM "Demo Spend Log" WHERE ts > ? GROUP BY provider',
+        (cutoff,),
+    ).fetchall()
+
+    by_provider = {
+        (row["provider"] or "unknown"): {
+            "cost_usd": round(row["cost_usd"], 6),
+            "call_count": int(row["call_count"]),
+            "prompt_tokens": int(row["prompt_tokens"]),
+            "completion_tokens": int(row["completion_tokens"]),
+        }
+        for row in by_provider_rows
+    }
+
+    return {
+        "total_usd": round(totals["total_usd"], 6),
+        "demo_usd": round(totals["demo_usd"], 6),
+        "prompt_tokens": int(totals["prompt_tokens"]),
+        "completion_tokens": int(totals["completion_tokens"]),
+        "call_count": int(totals["call_count"]),
+        "unique_ips": int(totals["unique_ips"] or 0),
+        "by_provider": by_provider,
+    }
+
+
+@router.get("/demo-spend")
+def demo_spend_overview(_user: dict = Depends(require_admin)):
+    """Per-window spend breakdown, caps, and top-10 IPs over 24h.
+
+    Only `public_manager` spend counts against the demo cap — `demo_usd`
+    in each window is the number the global cap compares against. Non-
+    demo calls (your own admin/manager sessions) are included in
+    `total_usd` so you can see the full OpenAI + Anthropic bill from this
+    deployment.
+    """
+    init_schema()
+    now = time.time()
+
+    windows = {name: _window_totals(now, seconds) for name, seconds in _WINDOWS}
+
+    db = get_db()
+    top_ip_rows = db.conn.execute(
+        'SELECT ip, role, '
+        '  COALESCE(SUM(cost_usd), 0) AS cost_usd, '
+        '  COUNT(*) AS call_count '
+        'FROM "Demo Spend Log" WHERE ts > ? '
+        'GROUP BY ip, role '
+        'ORDER BY cost_usd DESC '
+        'LIMIT 10',
+        (now - 24 * 3600,),
+    ).fetchall()
+    top_ips_24h = [
+        {
+            "ip": row["ip"] or "unknown",
+            "role": row["role"],
+            "cost_usd": round(row["cost_usd"], 6),
+            "call_count": int(row["call_count"]),
+        }
+        for row in top_ip_rows
+    ]
+
+    return {
+        "caps": {
+            "global_hourly_usd": limiter.global_hourly_usd,
+            "per_ip_hourly_usd": limiter.per_ip_hourly_usd,
+        },
+        "windows": windows,
+        "top_ips_24h": top_ips_24h,
+    }