lambda-erp 0.6.25__tar.gz → 0.7.0__tar.gz

{lambda_erp-0.6.25 → lambda_erp-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: lambda-erp
-Version: 0.6.25
+Version: 0.7.0
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0
@@ -158,6 +158,7 @@ The result is booked in one step — chart of accounts, sensible default account
 - Moving-average stock ledger with negative-stock protection
 - Double-entry General Ledger with cancellation reversal
 - Preset reports: Trial Balance, Profit & Loss, Balance Sheet, General Ledger, AR/AP Aging, Stock Balance
+- **Assets & reservations** — for equipment you own and hire out rather than sell: an `Asset` is one physical unit of an Item (the Item stays the *type* and carries the pricing), and a `Reservation` books a half-open date window against either a specific unit or `qty` units of an item+warehouse pool, refusing double-bookings and answering "what's free between the 14th and the 19th". Tracking is opt-in per Item (`is_asset_tracked`, off by default), and neither posts to the GL or the stock ledger — an owned machine going out on hire is not a sale of inventory. See [`docs/adr-0002-asset-and-reservation.md`](docs/adr-0002-asset-and-reservation.md).
 - Custom analytics drafts via chat (persisted, shareable, editable)
 - Server-side aggregation tool for in-chat factual answers across large datasets
 - PDF / image attachment → add invoices, create quotations, etc. all directly by adding them in the chat
@@ -170,7 +171,8 @@ The result is booked in one step — chart of accounts, sensible default account
 
 - Multi-currency beyond the simplified current handling
 - Workflows / approval chains
-- Serial & batch tracking
+- Serial & batch tracking for *sellable stock* (unit identity for owned equipment
+  is covered by Assets — see below)
 - Manufacturing (BOM, work orders)
 - HR / Payroll beyond the journal-entry workaround
 - Regional compliance packs (GST, VAT returns, etc.) - see below

{lambda_erp-0.6.25 → lambda_erp-0.7.0}/README.md

@@ -130,6 +130,7 @@ The result is booked in one step — chart of accounts, sensible default account
 - Moving-average stock ledger with negative-stock protection
 - Double-entry General Ledger with cancellation reversal
 - Preset reports: Trial Balance, Profit & Loss, Balance Sheet, General Ledger, AR/AP Aging, Stock Balance
+- **Assets & reservations** — for equipment you own and hire out rather than sell: an `Asset` is one physical unit of an Item (the Item stays the *type* and carries the pricing), and a `Reservation` books a half-open date window against either a specific unit or `qty` units of an item+warehouse pool, refusing double-bookings and answering "what's free between the 14th and the 19th". Tracking is opt-in per Item (`is_asset_tracked`, off by default), and neither posts to the GL or the stock ledger — an owned machine going out on hire is not a sale of inventory. See [`docs/adr-0002-asset-and-reservation.md`](docs/adr-0002-asset-and-reservation.md).
 - Custom analytics drafts via chat (persisted, shareable, editable)
 - Server-side aggregation tool for in-chat factual answers across large datasets
 - PDF / image attachment → add invoices, create quotations, etc. all directly by adding them in the chat
@@ -142,7 +143,8 @@ The result is booked in one step — chart of accounts, sensible default account
 
 - Multi-currency beyond the simplified current handling
 - Workflows / approval chains
-- Serial & batch tracking
+- Serial & batch tracking for *sellable stock* (unit identity for owned equipment
+  is covered by Assets — see below)
 - Manufacturing (BOM, work orders)
 - HR / Payroll beyond the journal-entry workaround
 - Regional compliance packs (GST, VAT returns, etc.) - see below

{lambda_erp-0.6.25 → lambda_erp-0.7.0}/api/chat.py

@@ -449,6 +449,10 @@ DOCUMENT_SLUGS = [
     "payment-entry", "journal-entry", "stock-entry",
     "delivery-note", "purchase-receipt", "pos-invoice",
     "pricing-rule", "budget", "subscription", "bank-transaction",
+    # Owned equipment and its hire calendar. Core doctypes, so they belong in
+    # this list rather than surfacing as "deployment-specific extensions"
+    # (_extra_document_slugs is defined as everything NOT named here).
+    "asset", "reservation",
 ]
 
 MASTER_TYPES = ["customer", "supplier", "item", "warehouse", "account", "company", "cost-center"]
@@ -2135,6 +2139,7 @@ When a user asks you to do something they don't have permission for, explain wha
 - **Buying:** purchase-order, purchase-invoice
 - **Accounting:** payment-entry, journal-entry, budget, subscription, bank-transaction
 - **Stock:** stock-entry, delivery-note, purchase-receipt
+- **Assets & hire:** asset, reservation
 - **Settings:** pricing-rule{extension_doctypes_line}{chat_doctype_section}
 
 ## Document Workflow & What Each Document Does
@@ -2239,6 +2244,18 @@ For a complete sales return (financial + stock): create and submit both a Credit
 - **Material Issue:** Removes stock for write-offs or internal consumption. Posts Dr Stock Adjustment / Cr Stock In Hand.
 - **Material Transfer:** Moves stock between warehouses. No GL impact.
 
+### Assets & Reservations (equipment you OWN and hire out — not stock you sell)
+Use these only for items flagged `is_asset_tracked` on the Item master. Neither posts GL or stock entries: an owned machine going out on hire is not a sale of inventory, so the books are untouched until you invoice the hire through the normal selling cycle.
+
+- **Item vs Asset:** the Item is the *type* ("17t Excavator") and carries the rate and pricing rules. An **Asset** (slug `asset`) is ONE physical unit of it. Three identical machines = one Item + three Assets. Create with `item_code` (required) plus `asset_tag` (plate / serial — optional but must be unique), `warehouse` (its home yard), and optionally `purchase_date`, `purchase_value`, `meter_reading`. `status` is Available / On Hire / Maintenance / Retired — the unit's state *today*, not a date range. Retired units leave the pool.
+- **Opting in:** creating an Asset for an Item that isn't asset-tracked is refused. Fix it by setting `is_asset_tracked` = 1 on the Item via update_master, then retry. Never suggest the user edit the database.
+- **Reservation** (slug `reservation`) books a time window. Required: `from_datetime` and `to_datetime` (`YYYY-MM-DD` or `YYYY-MM-DD HH:MM:SS`; a bare date means midnight). Windows are **half-open** — a hire ending on the 19th and the next starting on the 19th do NOT clash. Two ways to book:
+  - **pooled** — set `item_code`, `warehouse` and `qty`: "*a* machine of this type from that yard". Use this at quotation/order time when the specific unit doesn't matter yet.
+  - **unit** — set `asset`: "*that* machine". `item_code`, `warehouse` and `qty` are filled in from the Asset automatically.
+- `status` is Reserved / Out / Returned / Cancelled. **Reserved and Out block the calendar; Returned and Cancelled do not** — so a hire that comes back early frees its slot the moment you set it to Returned. Link a booking to the order that caused it with `voucher_type` + `voucher_no`.
+- **Double-booking is refused at save time.** If you get "already committed" (that unit is taken) or "free at" (the yard's pool is exhausted for that window), do NOT retry blindly — report the conflict, then offer the alternatives: different dates, a different yard, or a different model.
+- To answer "what's free between X and Y", list reservations for the item over the window and compare against the Assets that exist; a unit with no overlapping Reserved/Out row is available.
+
 ### Salary / Payroll (manual flow)
 There is no dedicated payroll module. Handle salary payments with two steps:
 1. **Accrue salary:** Create a Journal Entry — Debit "Salary Expense" (the expense), Credit "Salary Payable" (the liability). Add a remark like "April 2026 salaries".

{lambda_erp-0.6.25 → lambda_erp-0.7.0}/api/routers/masters.py

@@ -78,6 +78,8 @@ DELETE_REFERENCE_CHECKS = {
         ('SELECT 1 FROM "Bin" WHERE item_code = ? LIMIT 1', "bin"),
         ('SELECT 1 FROM "Pricing Rule" WHERE item_code = ? LIMIT 1', "pricing rule"),
         ('SELECT 1 FROM "Subscription Plan" WHERE item_code = ? LIMIT 1', "subscription plan"),
+        ('SELECT 1 FROM "Asset" WHERE item_code = ? LIMIT 1', "asset"),
+        ('SELECT 1 FROM "Reservation" WHERE item_code = ? LIMIT 1', "reservation"),
     ],
     "warehouse": [
         ('SELECT 1 FROM "Item" WHERE default_warehouse = ? LIMIT 1', "item"),
@@ -94,6 +96,8 @@ DELETE_REFERENCE_CHECKS = {
         ('SELECT 1 FROM "Stock Entry Detail" WHERE s_warehouse = ? OR t_warehouse = ? LIMIT 1', "stock entry item"),
         ('SELECT 1 FROM "Stock Ledger Entry" WHERE warehouse = ? LIMIT 1', "stock ledger entry"),
         ('SELECT 1 FROM "Bin" WHERE warehouse = ? LIMIT 1', "bin"),
+        ('SELECT 1 FROM "Asset" WHERE warehouse = ? LIMIT 1', "asset"),
+        ('SELECT 1 FROM "Reservation" WHERE warehouse = ? LIMIT 1', "reservation"),
     ],
     "account": [
         ('SELECT 1 FROM "Account" WHERE parent_account = ? LIMIT 1', "child account"),

{lambda_erp-0.6.25 → lambda_erp-0.7.0}/api/services.py

@@ -22,6 +22,8 @@ from lambda_erp.controllers.pricing_rule import PricingRule
 from lambda_erp.accounting.budget import Budget
 from lambda_erp.accounting.subscription import Subscription
 from lambda_erp.accounting.bank_transaction import BankTransaction
+from lambda_erp.assets.asset import Asset
+from lambda_erp.assets.reservation import Reservation
 
 
 # --- Doctype registries ---
@@ -43,6 +45,11 @@ DOCUMENT_CLASSES = {
     "Budget": Budget,
     "Subscription": Subscription,
     "Bank Transaction": BankTransaction,
+    # Neither posts to the GL or the Stock Ledger; both stay at docstatus 0 and
+    # carry their meaning in `status`. Registered here so the generic document
+    # CRUD, the chat tools and MCP drive them like every other doctype.
+    "Asset": Asset,
+    "Reservation": Reservation,
 }
 
 CONVERTERS = {

lambda_erp-0.7.0/lambda_erp/assets/__init__.py

@@ -0,0 +1,33 @@
+"""Unit-level asset identity and date-ranged reservations.
+
+Deliberately NOT part of `lambda_erp/stock/`. Stock models quantities that are
+consumed — you buy 10, sell 3, and the ledger moves the value out as COGS. An
+Asset is an owned unit that goes out and comes back: it is never consumed, so
+nothing here touches the Stock Ledger or the General Ledger.
+
+Two pieces:
+
+- `asset.py` — the Asset master: one row per physical unit, pointing at the
+  Item that describes its *type* (and carries its pricing).
+- `reservation.py` — the Reservation primitive: a half-open time window that
+  commits either a specific Asset or `qty` units from an item+warehouse pool,
+  plus the availability engine that answers "what's free between X and Y".
+
+See docs/adr-0002-asset-and-reservation.md for why it's shaped this way.
+"""
+
+from lambda_erp.assets.asset import (
+    Asset, ASSET_STATUSES, ASSET_RETIRED, usable_assets,
+)
+from lambda_erp.assets.reservation import (
+    Reservation, RESERVATION_STATUSES, BLOCKING_STATUSES,
+    available_assets, available_qty, committed_qty, overlapping_reservations,
+    pool_capacity, release_reservations,
+)
+
+__all__ = [
+    "Asset", "ASSET_STATUSES", "ASSET_RETIRED", "usable_assets",
+    "Reservation", "RESERVATION_STATUSES", "BLOCKING_STATUSES",
+    "available_assets", "available_qty", "committed_qty",
+    "overlapping_reservations", "pool_capacity", "release_reservations",
+]

lambda_erp-0.7.0/lambda_erp/assets/asset.py

@@ -0,0 +1,134 @@
+"""Asset — one row per physical unit of an asset-tracked Item.
+
+The Item stays the *type* ("Kubota U 17 E", with its rate and pricing rules);
+the Asset is the *unit* (the three machines you actually own, each with its own
+plate number, home yard, and hour meter). Pricing, quoting and invoicing keep
+keying off the Item, so nothing about the selling flow changes — only the
+question "which one, and is it free?" becomes answerable.
+
+Opt-in: an Item is only asset-tracked when `is_asset_tracked = 1`. The flag
+defaults to 0, so every existing deployment behaves exactly as before after the
+version bump — no receipt suddenly demands unit identities. Creating an Asset
+against an Item that hasn't opted in is refused with a message that says how.
+
+Nothing here posts to the GL or the Stock Ledger. An Asset is a record of a
+thing you own, not a valuation entry; see docs/adr-0002-asset-and-reservation.md.
+"""
+
+from lambda_erp.database import get_db
+from lambda_erp.exceptions import ValidationError
+from lambda_erp.model import Document
+
+# Current state of the unit. This is the *now* status, deliberately NOT a
+# window: "is it free on the 14th" is answered by the Reservation calendar, not
+# by this field (see reservation.py). Retired units drop out of the pool.
+ASSET_AVAILABLE = "Available"
+ASSET_ON_HIRE = "On Hire"
+ASSET_MAINTENANCE = "Maintenance"
+ASSET_RETIRED = "Retired"
+
+ASSET_STATUSES = [ASSET_AVAILABLE, ASSET_ON_HIRE, ASSET_MAINTENANCE, ASSET_RETIRED]
+
+
+# The "Asset" table itself is declared with every other core table in
+# lambda_erp/database.py — one source of truth for the schema.
+
+
+def is_asset_tracked(db, item_code: str) -> bool:
+    """True when the Item has opted in to unit-level tracking.
+
+    Reads through get_value (never a hand-written SELECT of a maybe-missing
+    column) so it stays correct on both backends — on SQLite an unknown column
+    silently returns its own name as a string rather than raising (see
+    docs/agents/gotchas.md)."""
+    row = db.get_value("Item", item_code, ["is_asset_tracked"])
+    if not row:
+        return False
+    return bool(row.get("is_asset_tracked"))
+
+
+class Asset(Document):
+    DOCTYPE = "Asset"
+    CHILD_TABLES = {}
+    PREFIX = "ASSET"
+    LINK_FIELDS = {
+        "item_code": "Item",
+        "warehouse": "Warehouse",
+        "company": "Company",
+    }
+
+    def validate(self):
+        if not self.item_code:
+            raise ValidationError("Item Code is required")
+
+        db = get_db()
+        # _validate_links proves the Item exists (it runs after validate), but
+        # the opt-in check needs the row now and must give the better message.
+        if not db.exists("Item", self.item_code):
+            raise ValidationError(
+                f"Asset: Item Code '{self.item_code}' does not exist in Item"
+            )
+        if not is_asset_tracked(db, self.item_code):
+            raise ValidationError(
+                f"Item '{self.item_code}' is not asset-tracked. Set "
+                f"is_asset_tracked = 1 on the Item before creating Assets for it."
+            )
+
+        status = self._data.get("status") or ASSET_AVAILABLE
+        if status not in ASSET_STATUSES:
+            raise ValidationError(
+                f"Invalid asset status '{status}' — must be one of "
+                f"{', '.join(ASSET_STATUSES)}"
+            )
+        self._data["status"] = status
+
+        # An asset tag is the plate / manufacturer serial. Optional, but when
+        # given it identifies exactly one unit — a duplicate means someone
+        # entered the same machine twice, which would double the pool capacity.
+        tag = (self._data.get("asset_tag") or "").strip()
+        if tag:
+            self._data["asset_tag"] = tag
+            clash = db.sql(
+                'SELECT name FROM "Asset" WHERE asset_tag = ? AND name != ? '
+                "AND COALESCE(discarded, 0) = 0 LIMIT 1",
+                [tag, self.name],
+            )
+            if clash:
+                raise ValidationError(
+                    f"Asset tag '{tag}' is already used by {clash[0]['name']}"
+                )
+
+        # Default the display name so lists and link fields read sensibly
+        # without forcing the caller to invent one.
+        if not self._data.get("asset_name"):
+            self._data["asset_name"] = f"{self.item_code} {tag}".strip()
+
+        # Fall back to the item's default warehouse so a single-yard deployment
+        # never has to think about locations.
+        if not self._data.get("warehouse"):
+            item = db.get_value("Item", self.item_code, ["default_warehouse"])
+            if item and item.get("default_warehouse"):
+                self._data["warehouse"] = item["default_warehouse"]
+
+
+def usable_assets(db, item_code: str, warehouse: str | None = None) -> list:
+    """Assets of an item that can still be hired out — i.e. the pool.
+
+    Retired, disabled and discarded units are excluded. `Maintenance` is NOT
+    excluded: it describes the unit *today*, and this function answers a
+    question about a future window. Blocking a machine for a service slot is a
+    Reservation with no party, so that one calendar governs every window.
+    """
+    # COALESCE rather than a `{"disabled": 0}` filter: `disabled = 0` does not
+    # match NULL, and a row written by a plugin or a raw INSERT may leave the
+    # flag unset. Portable across SQLite and Postgres.
+    sql = (
+        'SELECT name, asset_name, asset_tag, warehouse, status FROM "Asset" '
+        "WHERE item_code = ? AND COALESCE(disabled, 0) = 0 "
+        "AND COALESCE(discarded, 0) = 0 AND COALESCE(status, '') != ?"
+    )
+    params = [item_code, ASSET_RETIRED]
+    if warehouse:
+        sql += " AND warehouse = ?"
+        params.append(warehouse)
+    return db.sql(sql + " ORDER BY name", params)

lambda_erp-0.7.0/lambda_erp/assets/reservation.py

@@ -0,0 +1,328 @@
+"""Reservation — a date-ranged commitment against an Asset or an item pool.
+
+This is the primitive the rest of the system was missing. `Bin.reserved_qty`
+already tracks *how many* units a Sales Order has spoken for, but it carries no
+dates, so it can never answer "is a machine free from the 14th to the 19th".
+Reservation is that answer, and it deliberately sits beside Bin rather than
+replacing it: Bin stays the Sales Order's stock semantic, this is the calendar.
+
+Two levels, because that's how hire actually works:
+
+- **pooled** — `item_code` + `warehouse` + `qty`: "*a* 1.7 t excavator out of
+  St. Gallen, 14.–19.". What you commit at quote and order time, when nobody
+  cares which unit.
+- **unit** — `asset` set: "*that* machine". Assigned at dispatch, or earlier
+  when the customer insists on a specific one.
+
+A unit reservation also consumes one slot of its pool, so the two levels stay
+consistent: booking three machines pooled and pinning a fourth is four of your
+capacity, not one plus three.
+
+Windows are **half-open**: `[from, to)`. A hire ending 09:00 and the next
+starting 09:00 do not collide, which is the behaviour a dispatcher expects.
+
+Nothing here posts to the GL or the Stock Ledger. A commitment is not a
+transaction — the invoice that eventually bills the hire is, and that flows
+through the ordinary selling cycle untouched.
+"""
+
+import datetime
+
+from lambda_erp.assets.asset import ASSET_RETIRED, is_asset_tracked, usable_assets
+from lambda_erp.database import get_db
+from lambda_erp.exceptions import ValidationError
+from lambda_erp.model import Document
+from lambda_erp.utils import flt
+
+RESERVED = "Reserved"
+OUT = "Out"
+RETURNED = "Returned"
+CANCELLED = "Cancelled"
+
+RESERVATION_STATUSES = [RESERVED, OUT, RETURNED, CANCELLED]
+
+# Only these hold the calendar. Returned/Cancelled rows stay for the audit
+# trail but stop blocking, so a released window is immediately re-bookable.
+BLOCKING_STATUSES = (RESERVED, OUT)
+
+_DT_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+# The "Reservation" table is declared with every other core table in
+# lambda_erp/database.py — one source of truth for the schema.
+
+
+def normalize_datetime(value, field="datetime") -> str:
+    """Normalise to a fixed-width `YYYY-MM-DD HH:MM:SS` string.
+
+    Every stored bound goes through this, which is what lets the overlap test
+    be a plain string comparison — fixed-width ISO sorts lexicographically, and
+    TEXT comparison behaves identically on SQLite and Postgres. A bare date
+    means midnight, so `2026-08-14` and `2026-08-14 00:00:00` are one instant
+    rather than two incomparable strings.
+
+    Any timezone suffix is dropped: a hire window is wall-clock time at the
+    yard, not an instant on a global timeline.
+    """
+    if value is None or value == "":
+        raise ValidationError(f"{field} is required")
+    if isinstance(value, datetime.datetime):
+        return value.strftime(_DT_FORMAT)
+    if isinstance(value, datetime.date):
+        return datetime.datetime(value.year, value.month, value.day).strftime(_DT_FORMAT)
+
+    text = str(value).strip().replace("T", " ")
+    if text.endswith("Z"):
+        text = text[:-1].strip()
+    # Strip a trailing +02:00 / -05:00 offset without touching the date's own
+    # hyphens (offsets only ever appear after the time part).
+    for sep in ("+", "-"):
+        idx = text.find(sep, 11)
+        if idx > 0:
+            text = text[:idx].strip()
+            break
+    try:
+        parsed = datetime.datetime.fromisoformat(text)
+    except ValueError:
+        raise ValidationError(
+            f"Invalid {field} '{value}' — expected YYYY-MM-DD or "
+            f"YYYY-MM-DD HH:MM:SS"
+        )
+    return parsed.strftime(_DT_FORMAT)
+
+
+class Reservation(Document):
+    DOCTYPE = "Reservation"
+    CHILD_TABLES = {}
+    PREFIX = "RES"
+    LINK_FIELDS = {
+        "item_code": "Item",
+        "warehouse": "Warehouse",
+        "asset": "Asset",
+        "company": "Company",
+    }
+    DYNAMIC_LINK_FIELDS = {
+        "party": ("party_type", {"Customer": "Customer", "Supplier": "Supplier"}),
+    }
+
+    def validate(self):
+        db = get_db()
+
+        status = self._data.get("status") or RESERVED
+        if status not in RESERVATION_STATUSES:
+            raise ValidationError(
+                f"Invalid reservation status '{status}' — must be one of "
+                f"{', '.join(RESERVATION_STATUSES)}"
+            )
+        self._data["status"] = status
+
+        from_dt = normalize_datetime(self._data.get("from_datetime"), "From Datetime")
+        to_dt = normalize_datetime(self._data.get("to_datetime"), "To Datetime")
+        if from_dt >= to_dt:
+            raise ValidationError(
+                f"To Datetime ({to_dt}) must be after From Datetime ({from_dt})"
+            )
+        self._data["from_datetime"] = from_dt
+        self._data["to_datetime"] = to_dt
+
+        asset = self._data.get("asset")
+        if asset:
+            self._resolve_from_asset(db, asset)
+        elif not self._data.get("item_code"):
+            raise ValidationError("Item Code is required (or set an Asset)")
+
+        item_code = self._data["item_code"]
+        if not db.exists("Item", item_code):
+            raise ValidationError(
+                f"Reservation: Item Code '{item_code}' does not exist in Item"
+            )
+        # Capacity is counted from Asset rows, so an item with no units has no
+        # pool to reserve against. Pooled reservation of ordinary (untracked)
+        # stock is a different feature — see the ADR's scope note.
+        if not is_asset_tracked(db, item_code):
+            raise ValidationError(
+                f"Item '{item_code}' is not asset-tracked. Set is_asset_tracked = 1 "
+                f"on the Item before reserving it."
+            )
+
+        if not self._data.get("warehouse"):
+            item = db.get_value("Item", item_code, ["default_warehouse"])
+            if item and item.get("default_warehouse"):
+                self._data["warehouse"] = item["default_warehouse"]
+        if not self._data.get("warehouse"):
+            raise ValidationError(
+                "Warehouse is required — set it on the Reservation, on the Asset, "
+                "or as the Item's default warehouse"
+            )
+
+        qty = flt(self._data.get("qty") or (1 if asset else 0))
+        if asset:
+            # A pinned unit is exactly one machine; anything else would
+            # double-count it against the pool.
+            qty = 1
+        elif qty <= 0:
+            raise ValidationError("Qty must be greater than zero")
+        self._data["qty"] = qty
+
+        if status in BLOCKING_STATUSES:
+            self._check_availability(db, from_dt, to_dt)
+
+    def _resolve_from_asset(self, db, asset: str) -> None:
+        """Pin the reservation to one unit, inheriting its item and location."""
+        row = db.get_value(
+            "Asset", asset, ["item_code", "warehouse", "status", "disabled"]
+        )
+        if not row:
+            raise ValidationError(
+                f"Reservation: Asset '{asset}' does not exist in Asset"
+            )
+        if row.get("status") == ASSET_RETIRED or row.get("disabled"):
+            raise ValidationError(
+                f"Asset {asset} is retired or disabled and cannot be reserved"
+            )
+        declared = self._data.get("item_code")
+        if declared and declared != row.get("item_code"):
+            raise ValidationError(
+                f"Asset {asset} is a '{row.get('item_code')}', not a '{declared}'"
+            )
+        self._data["item_code"] = row.get("item_code")
+        if not self._data.get("warehouse") and row.get("warehouse"):
+            self._data["warehouse"] = row["warehouse"]
+
+    def _check_availability(self, db, from_dt: str, to_dt: str) -> None:
+        """Refuse a double-booking, at whichever level this reservation binds."""
+        asset = self._data.get("asset")
+        item_code = self._data["item_code"]
+        warehouse = self._data["warehouse"]
+
+        if asset:
+            clash = overlapping_reservations(
+                db, asset=asset, from_dt=from_dt, to_dt=to_dt, exclude=self.name
+            )
+            if clash:
+                first = clash[0]
+                raise ValidationError(
+                    f"Asset {asset} is already committed from "
+                    f"{first['from_datetime']} to {first['to_datetime']} "
+                    f"by {first['name']}"
+                )
+
+        capacity = pool_capacity(db, item_code, warehouse)
+        if capacity <= 0:
+            raise ValidationError(
+                f"No assets available for '{item_code}' at {warehouse} — "
+                f"create Asset records for its units first"
+            )
+        committed = committed_qty(
+            db, item_code, warehouse, from_dt, to_dt, exclude=self.name
+        )
+        wanted = flt(self._data.get("qty") or 1)
+        if committed + wanted > capacity:
+            raise ValidationError(
+                f"Only {max(0.0, capacity - committed):g} of {capacity:g} "
+                f"'{item_code}' free at {warehouse} between {from_dt} and "
+                f"{to_dt} — {wanted:g} requested"
+            )
+
+
+# --- Availability engine -------------------------------------------------
+# The whole overlap rule, in one place: two half-open windows collide when
+# `existing.from < new.to AND existing.to > new.from`. Touching ends don't.
+
+
+def overlapping_reservations(db, *, from_dt, to_dt, item_code=None,
+                             warehouse=None, asset=None, exclude=None,
+                             statuses=BLOCKING_STATUSES) -> list:
+    """Blocking reservations that overlap the window, narrowed by whichever of
+    asset / item+warehouse was given. `exclude` skips a row by name so editing
+    a reservation never collides with itself."""
+    from_dt = normalize_datetime(from_dt, "From Datetime")
+    to_dt = normalize_datetime(to_dt, "To Datetime")
+
+    placeholders = ", ".join(["?"] * len(statuses))
+    sql = (
+        'SELECT name, item_code, warehouse, asset, qty, from_datetime, '
+        'to_datetime, status, voucher_type, voucher_no FROM "Reservation" '
+        f"WHERE status IN ({placeholders}) AND COALESCE(discarded, 0) = 0 "
+        "AND from_datetime < ? AND to_datetime > ?"
+    )
+    params = list(statuses) + [to_dt, from_dt]
+
+    if asset:
+        sql += " AND asset = ?"
+        params.append(asset)
+    if item_code:
+        sql += " AND item_code = ?"
+        params.append(item_code)
+    if warehouse:
+        sql += " AND warehouse = ?"
+        params.append(warehouse)
+    if exclude:
+        sql += " AND name != ?"
+        params.append(exclude)
+
+    return db.sql(sql + " ORDER BY from_datetime", params)
+
+
+def pool_capacity(db, item_code: str, warehouse: str | None = None) -> float:
+    """How many units of an item could be hired out of a location at all."""
+    return float(len(usable_assets(db, item_code, warehouse)))
+
+
+def committed_qty(db, item_code: str, warehouse: str | None, from_dt, to_dt,
+                  exclude=None) -> float:
+    """Units already spoken for in the window — pooled and pinned together."""
+    rows = overlapping_reservations(
+        db, item_code=item_code, warehouse=warehouse,
+        from_dt=from_dt, to_dt=to_dt, exclude=exclude,
+    )
+    return sum(flt(r.get("qty") or 1) for r in rows)
+
+
+def available_qty(db, item_code: str, warehouse: str | None, from_dt, to_dt,
+                  exclude=None) -> float:
+    """Free units of an item at a location across the whole window."""
+    capacity = pool_capacity(db, item_code, warehouse)
+    committed = committed_qty(db, item_code, warehouse, from_dt, to_dt, exclude)
+    return max(0.0, capacity - committed)
+
+
+def available_assets(db, item_code: str, warehouse: str | None, from_dt, to_dt,
+                     exclude=None) -> list:
+    """The specific units free for the whole window — what dispatch picks from.
+
+    Pooled reservations reduce the *count* available without naming a unit, so
+    this deliberately reports units with no overlapping commitment of their
+    own; callers assigning a machine should also respect `available_qty`.
+    """
+    pinned = {
+        r["asset"]
+        for r in overlapping_reservations(
+            db, item_code=item_code, warehouse=warehouse,
+            from_dt=from_dt, to_dt=to_dt, exclude=exclude,
+        )
+        if r.get("asset")
+    }
+    return [a for a in usable_assets(db, item_code, warehouse) if a["name"] not in pinned]
+
+
+def release_reservations(db, voucher_type: str, voucher_no: str,
+                         status: str = CANCELLED) -> int:
+    """Release every blocking reservation held by a document, freeing the window.
+
+    The hook a cancelled order or a completed return calls. Writes the status
+    directly rather than round-tripping save(): re-validating would re-run the
+    availability check against the row's own window, and releasing a booking
+    should never be refusable.
+    """
+    if status not in RESERVATION_STATUSES:
+        raise ValidationError(f"Invalid reservation status '{status}'")
+    placeholders = ", ".join(["?"] * len(BLOCKING_STATUSES))
+    rows = db.sql(
+        f'SELECT name FROM "Reservation" WHERE voucher_type = ? AND voucher_no = ? '
+        f"AND status IN ({placeholders})",
+        [voucher_type, voucher_no] + list(BLOCKING_STATUSES),
+    )
+    for row in rows:
+        db.set_value("Reservation", row["name"], {"status": status})
+    return len(rows)

{lambda_erp-0.6.25 → lambda_erp-0.7.0}/lambda_erp/database.py

@@ -397,6 +397,7 @@ class Database:
                 stock_uom TEXT DEFAULT 'Nos',
                 is_stock_item INTEGER DEFAULT 1,
                 is_fixed_asset INTEGER DEFAULT 0,
+                is_asset_tracked INTEGER DEFAULT 0,
                 valuation_method TEXT DEFAULT 'FIFO',
                 default_warehouse TEXT,
                 standard_rate REAL DEFAULT 0,
@@ -1396,6 +1397,60 @@ class Database:
                 creation TEXT,
                 modified TEXT
             )""",
+
+            # --- Unit-level asset identity + reservations ---
+            # An Asset is one physical unit of an asset-tracked Item (the Item
+            # stays the *type* and carries the pricing). Owned, not consumed:
+            # nothing in lambda_erp/assets/ touches the Stock Ledger or the GL,
+            # so these tables cannot affect an existing deployment's books.
+            # Tracking is opt-in per Item via `is_asset_tracked` (migration 21),
+            # which defaults to 0. See docs/adr-0002-asset-and-reservation.md.
+            """CREATE TABLE IF NOT EXISTS "Asset" (
+                name TEXT PRIMARY KEY,
+                asset_name TEXT,
+                item_code TEXT,
+                asset_tag TEXT,
+                warehouse TEXT,
+                company TEXT,
+                status TEXT DEFAULT 'Available',
+                purchase_date TEXT,
+                purchase_value REAL DEFAULT 0,
+                meter_reading REAL DEFAULT 0,
+                meter_uom TEXT,
+                notes TEXT,
+                disabled INTEGER DEFAULT 0,
+                discarded INTEGER DEFAULT 0,
+                docstatus INTEGER DEFAULT 0,
+                creation TEXT,
+                modified TEXT
+            )""",
+
+            # A half-open [from, to) commitment against either one Asset
+            # (`asset` set) or `qty` units of an item+warehouse pool. Bounds are
+            # normalised to fixed-width 'YYYY-MM-DD HH:MM:SS', which is what
+            # lets the overlap test be a plain TEXT comparison on both backends.
+            """CREATE TABLE IF NOT EXISTS "Reservation" (
+                name TEXT PRIMARY KEY,
+                item_code TEXT,
+                warehouse TEXT,
+                asset TEXT,
+                qty REAL DEFAULT 1,
+                from_datetime TEXT,
+                to_datetime TEXT,
+                status TEXT DEFAULT 'Reserved',
+                party_type TEXT,
+                party TEXT,
+                voucher_type TEXT,
+                voucher_no TEXT,
+                voucher_detail_no TEXT,
+                purpose TEXT,
+                notes TEXT,
+                company TEXT,
+                discarded INTEGER DEFAULT 0,
+                docstatus INTEGER DEFAULT 0,
+                creation TEXT,
+                modified TEXT
+            )""",
         ]
 
         for stmt in stmts:
@@ -2062,6 +2117,14 @@ def _m020_chat_attachment_openai_file(db: "Database") -> None:
     db._add_column_if_missing("Chat Attachment", "openai_file_expires_at", "INTEGER")
 
 
+def _m021_item_is_asset_tracked(db: "Database") -> None:
+    """Opt an Item in to unit-level Asset tracking. Defaults to 0, so every
+    existing item in every existing deployment keeps behaving exactly as
+    before — no stock movement starts demanding unit identities. Only items a
+    user explicitly flags get Assets and reservations."""
+    db._add_column_if_missing("Item", "is_asset_tracked", "INTEGER DEFAULT 0")
+
+
 Database.MIGRATIONS = [
     (1, "chat_message_session_id", _m001_chat_message_session_id),
     (2, "chat_session_user_id", _m002_chat_session_user_id),
@@ -2083,6 +2146,7 @@ Database.MIGRATIONS = [
     (18, "quotation_item_frequency", _m018_quotation_item_frequency),
     (19, "api_keys_per_user", _m019_api_keys_per_user),
     (20, "chat_attachment_openai_file", _m020_chat_attachment_openai_file),
+    (21, "item_is_asset_tracked", _m021_item_is_asset_tracked),
 ]
 
 

{lambda_erp-0.6.25 → lambda_erp-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "0.6.25"
+version = "0.7.0"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "Apache-2.0"