celerp 2.2.0__tar.gz → 2.3.0__tar.gz

{celerp-2.2.0 → celerp-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celerp
-Version: 2.2.0
+Version: 2.3.0
 Summary: Free, self-hosted ERP for small businesses
 License: Business Source License 1.1
         

{celerp-2.2.0 → celerp-2.3.0}/celerp/events/schemas.py

@@ -117,6 +117,18 @@ class ItemExpired(BaseModel):
     reason: str | None = None
 
 
+class ItemWrittenOff(BaseModel):
+    # A unit of stock leaving the company for a non-sale reason (spoilage, samples,
+    # drawings). reason/account live single-sourced on the write-off list; the item row
+    # only records that it is off the books and points back to that list via source_list_id.
+    account: str
+    qty: float
+    unit_cost: float
+    cost_total: float
+    reason: str | None = None
+    source_list_id: str | None = None
+
+
 class ItemSplit(BaseModel):
     # Aggregate marker on the MOTHER. The projection consumes child_ids/child_skus;
     # children_detail drives the per-child history rows (one row per child).
@@ -193,6 +205,14 @@ class ItemProduced(BaseModel):
     quantity_produced: float
 
 
+class ItemCostAdjusted(BaseModel):
+    # Restate a lot's goods cost after the fact. Manufacturing re-costs a produced lot to the run's
+    # actual input cost once completion knows the true received quantity. cost_total is the new
+    # absolute cost_base; landed contributions rescale from it.
+    cost_total: float
+    manufacturing_order_id: str | None = None   # the run that re-costed the lot (audit trail)
+
+
 # --- Manufacturing recipe (materials + labor + overhead) attached to an item ---
 # The recipe is the single source of truth for how a manufactured item is built.
 # Interpretation (cost roll-up, expansion) lives in celerp-manufacturing; the schema
@@ -710,8 +730,8 @@ class MfgOrderIssued(BaseModel):
 
 
 class MfgOrderReceived(BaseModel):
-    # Finished goods received from a run. quantity restocks the output (per allow_splitting);
-    # lot_item_id is set when a non-splittable output created a new lot under the product.
+    # Finished goods received from a run. quantity is received as a discrete lot under the product;
+    # lot_item_id is that lot's id.
     quantity: float
     lot_item_id: str | None = None
     received_by: str | None = None
@@ -1045,6 +1065,7 @@ EVENT_SCHEMA_MAP: dict[str, type[BaseModel]] = {
     "item.fulfilled": ItemFulfilled,
     "item.fulfillment_reversed": ItemFulfillmentReversed,
     "item.expired": ItemExpired,
+    "item.written_off": ItemWrittenOff,
     "item.split": ItemSplit,
     "item.split_from": ItemSplitFrom,
     "item.transform": ItemTransform,
@@ -1054,6 +1075,7 @@ EVENT_SCHEMA_MAP: dict[str, type[BaseModel]] = {
     "item.patched": ItemPatched,
     "item.consumed": ItemConsumed,
     "item.produced": ItemProduced,
+    "item.cost_adjusted": ItemCostAdjusted,
     "item.recipe.set": ItemRecipeSet,
     "item.workflow.set": ItemWorkflowSet,
     "item.reserved": ItemReserved,

{celerp-2.2.0 → celerp-2.3.0}/celerp/events/types.py

@@ -15,6 +15,7 @@ class EventType(StrEnum):
     ITEM_TRANSFERRED = "item.transferred"
     ITEM_QUANTITY_ADJUSTED = "item.quantity.adjusted"
     ITEM_EXPIRED = "item.expired"
+    ITEM_WRITTEN_OFF = "item.written_off"
     ITEM_SPLIT = "item.split"
     ITEM_SPLIT_FROM = "item.split_from"
     ITEM_TRANSFORM = "item.transform"
@@ -22,6 +23,7 @@ class EventType(StrEnum):
     ITEM_MERGED = "item.merged"
     ITEM_CONSUMED = "item.consumed"
     ITEM_PRODUCED = "item.produced"
+    ITEM_COST_ADJUSTED = "item.cost_adjusted"
     ITEM_RECIPE_SET = "item.recipe.set"
     ITEM_WORKFLOW_SET = "item.workflow.set"
     ITEM_RESERVED = "item.reserved"

{celerp-2.2.0 → celerp-2.3.0}/celerp/main.py

@@ -281,6 +281,22 @@ async def lifespan(_app: FastAPI):
             "may show their status without a document link until a later boot"
         )
 
+    # One-time backfill: post the missing COGS JE for invoices finalized before
+    # COGS moved into the finalize JE and never fulfilled since. Marker-gated
+    # (runs once; retries stragglers while any doc is locked or errored);
+    # non-fatal like the backfill above.
+    try:
+        from celerp.db import SessionLocal as _CogsSession
+        from celerp.services.cogs_backfill import run_cogs_backfill
+        async with _CogsSession() as _cogs_sess:
+            await run_cogs_backfill(_cogs_sess)
+            await _cogs_sess.commit()
+    except Exception:
+        logging.getLogger(__name__).exception(
+            "COGS backfill failed (non-fatal); affected invoices keep their "
+            "missing COGS until a later boot retries"
+        )
+
     # Bring up the relay tunnel per the lazy free-tier lifecycle (3.1). A token-holder
     # is past first activation and never re-enters it. Paid instances (public_url set)
     # keep the tunnel always-on; a free instance opens it at boot only when it already

{celerp-2.2.0 → celerp-2.3.0}/celerp/modules/loader.py

@@ -549,6 +549,12 @@ def load_all(module_dir: str | Path, enabled: set[str]) -> list[dict]:
     """
     _loaded.clear()
     _load_errors.clear()
+    # Module-contributed i18n catalogs are rebuilt from scratch on every pass,
+    # exactly like _loaded above, so a re-scan (a module toggled off, or a
+    # catalog changed) never leaves a stale or orphaned catalog behind. Lazy
+    # import keeps ui.i18n the lowest leaf (it must not import this module).
+    from ui.i18n import clear_registry
+    clear_registry()
 
     # Support comma-separated module directories
     raw = str(module_dir)
@@ -581,8 +587,12 @@ def load_all(module_dir: str | Path, enabled: set[str]) -> list[dict]:
                 sys.path.insert(0, p_str)
             candidate_paths.append(p)
 
-    # Sort by dependency order (skip reasons land in _load_errors)
-    ordered = _topo_sort(candidate_paths, enabled, errors=_load_errors)
+    # Sort by dependency order (skip reasons land in _load_errors). Discovery is
+    # name-sorted first so load order - and therefore every first-registered-wins
+    # tie-break (slots and module i18n catalogs alike) - is deterministic, not
+    # dependent on the filesystem's iterdir() order.
+    ordered = _topo_sort(
+        sorted(candidate_paths, key=lambda p: p.name), enabled, errors=_load_errors)
 
     # Relay credentials for the premium-license gate, resolved lazily and ONCE
     # per load pass: the JWT is the same for every module, and there must be no
@@ -827,6 +837,52 @@ def _load_one(pkg_path: Path, pkg_name: str, *, trusted: bool = False) -> dict |
             for item in contribution:
                 register_slot(slot_name, {**item, "_module": pkg_name})
 
+    # Register module-contributed UI translation catalogs (the `locales`
+    # manifest key, mirroring `slots` above). Each entry maps a language code to
+    # {"file": <path>, "rtl": <bool>}. Pushed into ui.i18n through a lazy import
+    # so the i18n leaf never imports the module subsystem. A malformed or
+    # unreadable entry is logged and skipped; the module and its other locales
+    # still load.
+    locales = manifest.get("locales") or {}
+    if not isinstance(locales, dict):
+        log.error(
+            "Module %r 'locales' skipped: must be a dict, got %s",
+            pkg_name, type(locales).__name__,
+        )
+        locales = {}
+    for lang, entry in locales.items():
+        if not isinstance(lang, str) or not lang.strip():
+            log.error(
+                "Module %r locale skipped: language code must be a non-empty string (got %r)",
+                pkg_name, lang,
+            )
+            continue
+        if (not isinstance(entry, dict)
+                or not isinstance(entry.get("file"), str) or not entry["file"].strip()):
+            log.error(
+                "Module %r locale %r skipped: entry must be a dict with a non-empty string 'file'",
+                pkg_name, lang,
+            )
+            continue
+        rtl = entry.get("rtl", False)
+        if not isinstance(rtl, bool):
+            log.error(
+                "Module %r locale %r: 'rtl' must be a bool, got %s - treating as false",
+                pkg_name, lang, type(rtl).__name__,
+            )
+            rtl = False
+        cat_path = pkg_path / entry["file"]
+        try:
+            catalog = json.loads(cat_path.read_text(encoding="utf-8"))
+        except (OSError, ValueError) as exc:
+            log.error(
+                "Module %r locale %r skipped: cannot read %s (%s: %s)",
+                pkg_name, lang, entry["file"], type(exc).__name__, exc,
+            )
+            continue
+        from ui.i18n import register_catalog
+        register_catalog(lang, catalog, rtl=rtl)
+
     log.info(
         "Module %r loaded (v%s, slots: %s)",
         manifest["name"],

{celerp-2.2.0 → celerp-2.3.0}/celerp/output/pdf.py

@@ -349,7 +349,7 @@ def generate_document_pdf(doc: dict[str, Any], company: dict[str, Any] | None =
         if li_taxes:
             tax_str = " + ".join(
                 f"{t.get('label') or t.get('code') or 'Tax'} {float(t.get('rate', 0)):.1f}%"
-                for item in li_taxes
+                for t in li_taxes
             )
         else:
             tax_str = f"{float(li.get('tax_rate') or 0):.1f}%"

{celerp-2.2.0 → celerp-2.3.0}/celerp/routers/doctor.py

@@ -426,33 +426,19 @@ async def _check_legacy_item_prices(
 async def _emit_finalize_je(
     session: AsyncSession, company_id, user_id, doc_id: str, state: dict,
 ) -> None:
-    total = float(state.get("total", 0) or 0)
-    subtotal = float(state.get("subtotal", total) or total)
-    tax = float(state.get("tax", 0) or 0)
-    ts = state.get("issue_date") or state.get("created_at") or state.get("finalized_at")
-
-    je_id = f"je:auto:{doc_id}:fin"
-    entries = [
-        {"account": "1120", "debit": total, "credit": 0.0},
-        {"account": "4100", "debit": 0.0, "credit": subtotal},
-    ]
-    if tax > 0:
-        entries.append({"account": "2120", "debit": 0.0, "credit": tax})
+    """Delegate to auto_je.create_for_doc_finalized for DRY compliance.
 
-    await emit_event(
-        session, company_id=company_id, entity_id=je_id,
-        entity_type="journal_entry", event_type="acc.journal_entry.created",
-        data={"memo": f"Auto JE for {doc_id} finalized", "entries": entries, "ts": ts},
-        actor_id=user_id, location_id=None, source="auto_je",
-        idempotency_key=je_idempotency_key(doc_id, "invoice.finalized", "c"),
-        metadata_={"trigger": "doc.finalized", "doc_id": doc_id},
-    )
-    await emit_event(
-        session, company_id=company_id, entity_id=je_id,
-        entity_type="journal_entry", event_type="acc.journal_entry.posted",
-        data={}, actor_id=user_id, location_id=None, source="auto_je",
-        idempotency_key=je_idempotency_key(doc_id, "invoice.finalized", "p"),
-        metadata_={"trigger": "doc.finalized", "doc_id": doc_id},
+    A repaired invoice gets the same JE a live finalize posts - revenue, tax,
+    and the COGS pair - in the company's base currency.
+    """
+    from celerp.models.company import Company
+    from celerp.services import auto_je as _auto_je
+
+    company = await session.get(Company, company_id)
+    base_currency = (company.settings.get("currency", "USD") if company else "USD")
+    await _auto_je.create_for_doc_finalized(
+        session, company_id=company_id, user_id=user_id, doc_id=doc_id,
+        doc=state, base_currency=base_currency,
     )