lambda-erp 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

api/auth.py

@@ -35,12 +35,19 @@ def _resolve_jwt_secret() -> str:
       3. Newly-generated random secret (only used if the filesystem is
          read-only or inaccessible — cookies will be invalidated on
          restart in that degenerate case).
+
+    A Postgres deployment must set JWT_SECRET_KEY: there is no DB file to
+    sit next to, so the file would land on the container's own disk and
+    every replica and restart would sign with a different key, logging
+    users out at random.
     """
     env_secret = os.environ.get("JWT_SECRET_KEY")
     if env_secret:
         return env_secret
 
     db_path = os.environ.get("LAMBDA_ERP_DB", "lambda_erp.db")
+    if db_path.startswith(("postgresql://", "postgres://")):
+        raise RuntimeError("JWT_SECRET_KEY must be set when LAMBDA_ERP_DB is a Postgres URL")
     data_dir = os.path.dirname(os.path.abspath(db_path)) or "."
     secret_file = os.path.join(data_dir, ".jwt_secret")
 
@@ -338,6 +345,19 @@ def validate_assignable_role(role: str) -> str:
     return role
 
 
+def claim_invite(db, token: str) -> None:
+    """Mark an invite used, exactly once. The conditional UPDATE is the check:
+    two sign-ups racing on one invite both pass the earlier read, but only one
+    row update succeeds."""
+    with db._lock:
+        cursor = db.conn.execute(
+            'UPDATE "Invite" SET used = 1 WHERE token = ? AND COALESCE(used, 0) = 0', [token])
+        claimed = cursor.rowcount == 1
+        db.conn.commit()
+    if not claimed:
+        raise HTTPException(status_code=410, detail="Invite already used")
+
+
 def require_role(minimum_role: str):
     """Returns a dependency that checks the user has at least the specified role."""
     min_level = ROLE_HIERARCHY[minimum_role]
@@ -450,8 +470,7 @@ def register(data: RegisterRequest, request: Request, response: Response):
             raise HTTPException(status_code=403, detail="This invite was issued for a different email")
 
         role = validate_assignable_role(invite["role"])
-        db.sql('UPDATE "Invite" SET used = 1 WHERE token = ?', [data.invite_token])
-        db.conn.commit()
+        claim_invite(db, data.invite_token)
     elif _setting_enabled(db, "allow_public_signup"):
         # Open signup is enabled: anyone may self-register, but only as a viewer.
         role = "viewer"

api/chat.py

@@ -146,6 +146,74 @@ def can_access_session(session: dict | None, user: dict | None) -> bool:
     return session.get("user_id") == user.get("name")
 
 
+# A session runs one agent turn at a time. The claim lives on the session row,
+# so it holds across browser tabs, the REST chat API and app processes; a
+# per-connection check let two turns build on the same history and both write.
+# The deadline frees the session if the process running the turn died.
+TURN_LEASE_SECONDS = 30 * 60
+
+
+def _utc_iso(offset_seconds: int = 0) -> str:
+    from datetime import datetime, timedelta, timezone
+    return (datetime.now(timezone.utc) + timedelta(seconds=offset_seconds)).isoformat(timespec="seconds")
+
+
+def claim_session_turn(session_id: str) -> str | None:
+    """Claim the session for one turn; return the claim token, or None while
+    another turn is still running on it."""
+    db = get_db()
+    token = uuid.uuid4().hex
+    with db._lock:
+        cursor = db.conn.execute(
+            'UPDATE "Chat Session" SET active_turn = ?, active_turn_until = ? '
+            "WHERE id = ? AND (active_turn IS NULL OR active_turn_until IS NULL "
+            "OR active_turn_until < ?)",
+            [token, _utc_iso(TURN_LEASE_SECONDS), session_id, _utc_iso()],
+        )
+        claimed = cursor.rowcount == 1
+        db.conn.commit()
+    return token if claimed else None
+
+
+def release_session_turn(session_id: str, token: str | None) -> None:
+    if not token:
+        return
+    db = get_db()
+    with db._lock:
+        db.conn.execute(
+            'UPDATE "Chat Session" SET active_turn = NULL, active_turn_until = NULL '
+            "WHERE id = ? AND active_turn = ?",
+            [session_id, token],
+        )
+        db.conn.commit()
+
+
+def session_turn_running(session_id: str) -> bool:
+    rows = get_db().sql(
+        'SELECT active_turn_until FROM "Chat Session" WHERE id = ? AND active_turn IS NOT NULL',
+        [session_id],
+    )
+    return bool(rows and rows[0]["active_turn_until"] and rows[0]["active_turn_until"] >= _utc_iso())
+
+
+# Turns whose socket closed keep running to completion (see chat_websocket);
+# hold references so they aren't garbage-collected, and so shutdown can wait.
+_DETACHED_TURNS: set[asyncio.Task] = set()
+
+
+def detach_turn(task: asyncio.Task) -> None:
+    _DETACHED_TURNS.add(task)
+    task.add_done_callback(_DETACHED_TURNS.discard)
+
+
+async def drain_turns(timeout: float) -> None:
+    """On shutdown, give turns that are still running time to finish and
+    persist their results instead of dying between a tool call and its reply."""
+    pending = [task for task in _DETACHED_TURNS if not task.done()]
+    if pending:
+        await asyncio.wait(pending, timeout=timeout)
+
+
 def delete_session(session_id: str):
     """Delete a chat session, its messages, and its attachments."""
     try:
@@ -440,6 +508,8 @@ def api_delete_session(session_id: str, user: dict = _Depends(get_current_user))
     session = get_session(session_id)
     if not can_access_session(session, user):
         return {"detail": "Session not found"}
+    if session_turn_running(session_id):
+        raise HTTPException(status_code=409, detail="Wait for the current response to finish before deleting this chat.")
     delete_session(session_id)
     return {"ok": True}
 
@@ -4142,7 +4212,9 @@ async def chat_websocket(
         finally:
             session_tasks.pop(target_session_id, None)
 
-    async def process_session_message(target_session_id: str, user_content: str, attachment_ids: list | None = None):
+    async def process_session_message(target_session_id: str, user_content: str,
+                                      attachment_ids: list | None = None,
+                                      turn_token: str | None = None):
         try:
             async def on_event(event: dict):
                 await send_event(event["type"], session_id=target_session_id, **{
@@ -4169,7 +4241,9 @@ async def chat_websocket(
         except Exception as e:
             await send_error(str(e), session_id=target_session_id)
         finally:
-            session_tasks.pop(target_session_id, None)
+            release_session_turn(target_session_id, turn_token)
+            if session_tasks.get(target_session_id) is asyncio.current_task():
+                session_tasks.pop(target_session_id, None)
 
     try:
         await send_event("sessions_list", sessions=list_sessions(user_id=ws_user_id, role=ws_user_role))
@@ -4240,7 +4314,7 @@ async def chat_websocket(
                     continue
 
                 active_task = session_tasks.get(session_id)
-                if active_task and not active_task.done():
+                if (active_task and not active_task.done()) or session_turn_running(session_id):
                     await send_error(
                         "Wait for the current response to finish before deleting this chat.",
                         request_id=request_id,
@@ -4263,7 +4337,7 @@ async def chat_websocket(
                     continue
 
                 active_task = session_tasks.get(session_id)
-                if active_task and not active_task.done():
+                if (active_task and not active_task.done()) or session_turn_running(session_id):
                     await send_error(
                         "Wait for the current response to finish before clearing this chat.",
                         request_id=request_id,
@@ -4347,7 +4421,8 @@ async def chat_websocket(
 
                 session = get_session(session_id)
                 await send_event("demo_started", request_id=request_id, session_id=session_id, title=session["title"] if session else "New Chat")
-                session_tasks[session_id] = asyncio.create_task(replay_demo_session(session_id))
+                session_tasks[session_id] = asyncio.create_task(
+                    replay_demo_session(session_id), name=f"demo:{session_id}")
                 continue
 
             if msg_type == "transcribe":
@@ -4503,10 +4578,24 @@ async def chat_websocket(
                 if aid in session_attachments
             ]
 
-            save_chat_message(
-                session_id, "user", user_content or "",
-                metadata={"attachments": attached_meta} if attached_meta else None,
-            )
+            # Claimed before the user message is stored, so a second tab (or
+            # another app process) can't add a message to a running turn.
+            turn_token = claim_session_turn(session_id)
+            if not turn_token:
+                await send_error(
+                    "Wait for the current response to finish before sending another message.",
+                    request_id=request_id,
+                    session_id=session_id,
+                )
+                continue
+            try:
+                save_chat_message(
+                    session_id, "user", user_content or "",
+                    metadata={"attachments": attached_meta} if attached_meta else None,
+                )
+            except BaseException:
+                release_session_turn(session_id, turn_token)
+                raise
             await send_message_added(
                 session_id, "user", user_content or "",
                 attachments=attached_meta if attached_meta else None,
@@ -4520,11 +4609,21 @@ async def chat_websocket(
             await send_event("thinking", session_id=session_id, iteration=1)
 
             session_tasks[session_id] = asyncio.create_task(
-                process_session_message(session_id, user_content, attachment_ids)
+                process_session_message(session_id, user_content, attachment_ids, turn_token),
+                name=f"turn:{session_id}",
             )
 
     except WebSocketDisconnect:
-        for task in session_tasks.values():
-            task.cancel()
+        pass
     except Exception as e:
         await send_error(str(e))
+    finally:
+        # A demo replay is only presentation: stop it. An agent turn may be
+        # between a tool's write and its result: cancelling it would commit the
+        # write but lose the result and the reply, so the user retries and the
+        # write happens twice. Let it finish; history shows it on reconnect.
+        for task in list(session_tasks.values()):
+            if task.get_name().startswith("demo:"):
+                task.cancel()
+            elif not task.done():
+                detach_turn(task)

api/main.py

@@ -51,41 +51,48 @@ def load_plugins() -> None:
 async def lifespan(app: FastAPI):
     # Startup: initialize database
     db_path = os.environ.get("LAMBDA_ERP_DB", "lambda_erp.db")
-    setup(db_path)
+    db = setup(db_path)
 
-    from api.mentions import initialize_mentions
-    initialize_mentions()
+    # Plugin schema, migrations and seeding run one process at a time, like
+    # the core migrations inside setup(): replicas booting together must not
+    # race each other through them.
+    with db.startup_lock():
+        from api.mentions import initialize_mentions
+        initialize_mentions()
 
-    # Load customer extension plugins before anything creates documents.
-    load_plugins()
+        # Load customer extension plugins before anything creates documents.
+        load_plugins()
 
-    # Create plugin-registered tables and run their pending migrations. Must be
-    # after load_plugins() (registrations happen in register()) and before any
-    # document is created.
-    from api.services import apply_plugin_schema
-    apply_plugin_schema()
+        # Create plugin-registered tables and run their pending migrations. Must be
+        # after load_plugins() (registrations happen in register()) and before any
+        # document is created.
+        from api.services import apply_plugin_schema
+        apply_plugin_schema()
 
-    from api.pdf_profiles import validate_pdf_registry
-    validate_pdf_registry()
+        from api.pdf_profiles import validate_pdf_registry
+        validate_pdf_registry()
 
-    # Ensure the demo spend log table exists before any LLM call happens.
-    from api.demo_limits import init_schema as init_demo_spend_schema
-    init_demo_spend_schema()
+        # Ensure the demo spend log table exists before any LLM call happens.
+        from api.demo_limits import init_schema as init_demo_spend_schema
+        init_demo_spend_schema()
 
-    # Seed a deterministic admin from the environment (if configured) before
-    # anyone can register. On deployments whose DB is recreated each rollout
-    # this stops the first visitor after a redeploy from grabbing admin.
-    from api.auth import ensure_seed_admin
-    ensure_seed_admin()
+        # Seed a deterministic admin from the environment (if configured) before
+        # anyone can register. On deployments whose DB is recreated each rollout
+        # this stops the first visitor after a redeploy from grabbing admin.
+        from api.auth import ensure_seed_admin
+        ensure_seed_admin()
 
-    # When packaged as a demo container, land visitors straight in demo mode.
-    if os.environ.get("LAMBDA_ERP_AUTO_DEMO") == "1":
-        from api.bootstrap import bootstrap_demo
+        # When packaged as a demo container, land visitors straight in demo mode.
+        if os.environ.get("LAMBDA_ERP_AUTO_DEMO") == "1":
+            from api.bootstrap import bootstrap_demo
 
-        bootstrap_demo()
+            bootstrap_demo()
 
     yield
-    # Shutdown: nothing to clean up (SQLite handles it)
+    # Shutdown: let chat turns whose sockets already closed finish and save
+    # their results. Stay inside the container's termination grace period.
+    from api.chat import drain_turns
+    await drain_turns(timeout=float(os.environ.get("LAMBDA_ERP_SHUTDOWN_DRAIN_SECONDS", "20")))
 
 
 app = FastAPI(

api/oauth.py

@@ -47,6 +47,7 @@ from api.auth import (
     require_interactive_user,
     _is_https_request,
     validate_assignable_role,
+    claim_invite,
     _setting_enabled,
 )
 
@@ -362,8 +363,7 @@ def _consume_invite(db, invite_token: str, email: str) -> str:
     if invite["email"].lower() != email.lower():
         raise HTTPException(status_code=403, detail="This invite was issued for a different email")
     role = validate_assignable_role(invite["role"])
-    db.sql('UPDATE "Invite" SET used = 1 WHERE token = ?', [invite_token])
-    db.conn.commit()
+    claim_invite(db, invite_token)
     return role
 
 

api/routers/bank_statements.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 from urllib.parse import quote
 
@@ -44,7 +45,8 @@ async def preview_bank_statements(
     _user: dict = Depends(require_non_public_manager),
 ):
     """Parse uploads without writing any statement or transaction data."""
-    return preview_documents(await _parse_uploads(files))
+    # Parsing and matching are synchronous DB work: keep them off the event loop.
+    return await asyncio.to_thread(preview_documents, await _parse_uploads(files))
 
 
 @router.post("/import")
@@ -64,8 +66,9 @@ async def import_bank_statements(
     ):
         raise HTTPException(status_code=422, detail="mappings must map statement keys to Bank Accounts")
     try:
-        return import_documents(
-            await _parse_uploads(files), parsed_mappings, imported_by=user.get("name")
+        return await asyncio.to_thread(
+            import_documents, await _parse_uploads(files), parsed_mappings,
+            imported_by=user.get("name"),
         )
     except ValidationError as exc:
         raise HTTPException(status_code=422, detail=str(exc)) from exc

api/routers/chat_api.py

@@ -23,12 +23,15 @@ from pydantic import BaseModel
 
 from api.auth import get_api_caller
 from api.chat import (
+    claim_session_turn,
     create_session,
     delete_session,
     get_session,
     list_sessions,
+    release_session_turn,
     run_session_turn,
     save_chat_message,
+    session_turn_running,
 )
 from api.pdf import generate_pdf
 from api.pdf_exports import create_pdf_export, get_pdf_export, pdf_content_disposition
@@ -81,8 +84,23 @@ async def chat(payload: ChatApiRequest, request: Request, caller: dict = Depends
         target_session_id = existing[0]["id"] if existing else create_session(user_id=owner)["id"]
         replay_history = False
 
-    save_chat_message(target_session_id, "user", message)
-
+    # A continued session replays its history, so a second message must wait
+    # for the running turn (same rule as the web chat). The rolling audit
+    # session is stateless; parallel calls on it stay allowed.
+    turn_token = None
+    if replay_history:
+        turn_token = claim_session_turn(target_session_id)
+        if not turn_token:
+            raise HTTPException(status_code=409, detail="A reply is still running in this session; retry when it finishes")
+    try:
+        save_chat_message(target_session_id, "user", message)
+        return await _run_chat_turn(
+            target_session_id, message, caller, request, replay_history)
+    finally:
+        release_session_turn(target_session_id, turn_token)
+
+
+async def _run_chat_turn(target_session_id, message, caller, request, replay_history):
     tool_results = []
     generated = []
     pdf_attempts = {}
@@ -168,5 +186,7 @@ def delete(session_id: str, caller: dict = Depends(get_api_caller)):
     session = get_session(session_id)
     if not session or session.get("user_id") != caller["name"]:
         raise HTTPException(status_code=404, detail="Session not found")
+    if session_turn_running(session_id):
+        raise HTTPException(status_code=409, detail="A reply is still running in this session")
     delete_session(session_id)
     return {"id": session_id, "deleted": True}

api/routers/masters.py

@@ -1,6 +1,5 @@
 """Master data CRUD: Customer, Supplier, Item, Warehouse, Account, Company."""
 
-import re
 import secrets
 
 from fastapi import APIRouter, Depends, HTTPException, Query, Request
@@ -171,26 +170,15 @@ def _find_reference(master_type: str, name: str) -> str | None:
 
 
 def _generate_master_name(db, doctype: str, prefix: str, digits: int = 3) -> str:
-    # Take the highest numeric suffix among strict "PREFIX-<digits>" names.
-    # Names with a non-numeric tail (e.g. a custom "ITEM-COST-TEST") are ignored
-    # rather than parsed — string-sorting them to the top used to reset the
-    # counter to 001 and collide with an existing record.
-    rows = db.sql(
-        f'SELECT name FROM "{doctype}" WHERE name LIKE ?',
-        [f"{prefix}-%"],
-    )
-    pattern = re.compile(rf"^{re.escape(prefix)}-(\d+)$")
-    max_number = 0
-    for row in rows:
-        match = pattern.match(row["name"] or "")
-        if match:
-            max_number = max(max_number, int(match.group(1)))
-
-    # Skip any number already taken by a non-standard name so we never collide.
-    number = max_number + 1
-    while db.exists(doctype, f"{prefix}-{number:0{digits}d}"):
-        number += 1
-    return f"{prefix}-{number:0{digits}d}"
+    # The shared naming series (the same one documents use), so concurrent
+    # creates, other processes and a doctype that is both a master and a
+    # document (Lead) never pick the same number. Seeding counts only strict
+    # "PREFIX-<digits>" names, so a custom "ITEM-COST-TEST" doesn't move it.
+    # Skip any number already taken by a record created with an explicit name.
+    while True:
+        name = f"{prefix}-{db.next_in_series(prefix):0{digits}d}"
+        if not db.exists(doctype, name):
+            return name
 
 
 def _generate_random_master_name(db, doctype: str, prefix: str) -> str:

api/routers/mcp.py

@@ -15,6 +15,7 @@ automatically — the MCP surface is modular by construction.
 Transport: a single POST /api/mcp speaking JSON-RPC 2.0 (request → JSON result;
 notifications → 202, no body). That's the minimum a tool-only server needs.
 """
+import asyncio
 import json
 import os
 
@@ -225,10 +226,12 @@ async def mcp_endpoint(request: Request):
     version = request.headers.get('mcp-protocol-version')
     if not initializing and version and version not in SUPPORTED_PROTOCOL_VERSIONS:
         raise HTTPException(400, 'Unsupported MCP protocol version')
+    # Tool calls do synchronous database and PDF work; running them on the
+    # event loop would stall every other request and websocket on this process.
     if isinstance(body, list):
-        responses = [r for r in (_handle(m, user) for m in body) if r is not None]
+        responses = [r for r in [await asyncio.to_thread(_handle, m, user) for m in body] if r is not None]
         return JSONResponse(responses) if responses else Response(status_code=202)
-    resp = _handle(body, user)
+    resp = await asyncio.to_thread(_handle, body, user)
     if resp is None:
         return Response(status_code=202)
     return JSONResponse(resp)

api/services.py

@@ -572,6 +572,12 @@ def update_document(doctype_slug: str, name: str, data: dict) -> dict:
         raise ValueError(f"Unknown document type: {doctype_slug}")
     data = _validate_document_input(doctype, cls, data)
     doc = cls.load(name)
+    # A client that sends back the `modified` it loaded (the document form
+    # does) edits that version: if someone saved in between, the write-state
+    # check refuses instead of the stale copy silently replacing their changes
+    # (including whole child tables). Callers that omit it keep last-write-wins.
+    if data.get("modified"):
+        doc._loaded_modified = data["modified"]
     # Update parent fields
     for key, value in data.items():
         if key not in ("name", "docstatus", "creation") and key not in doc.CHILD_TABLES:

lambda_erp/accounting/bank_reconciliation.py

@@ -611,20 +611,13 @@ def reconcile_with_payment(bank_transaction: str, allocations: list[dict], *,
         "references": references,
     })
     db = get_db()
-    db._in_transaction = True
-    try:
+    with db.atomic():
         reconciliation = _new_audit(
             tx, mode="Created Payment Entry", voucher_type="Payment Entry",
             voucher_no=payment.name, user=user,
         )
         payment._data["bank_reconciliation"] = reconciliation
         payment.submit()
-        db.commit()
-        db._in_transaction = False
-    except Exception:
-        db.conn.rollback()
-        db._in_transaction = False
-        raise
     return {
         "bank_transaction": bank_transaction,
         "reconciliation": reconciliation,
@@ -693,20 +686,13 @@ def reconcile_with_journal(bank_transaction: str, counterparty_account: str, *,
         "remark": remarks or tx.get("remittance_information") or tx.get("description") or f"Bank reconciliation {tx['name']}",
         "accounts": accounts,
     })
-    db._in_transaction = True
-    try:
+    with db.atomic():
         reconciliation = _new_audit(
             tx, mode="Created Journal Entry", voucher_type="Journal Entry",
             voucher_no=journal.name, user=user,
         )
         journal._data["bank_reconciliation"] = reconciliation
         journal.submit()
-        db.commit()
-        db._in_transaction = False
-    except Exception:
-        db.conn.rollback()
-        db._in_transaction = False
-        raise
     return {
         "bank_transaction": bank_transaction,
         "reconciliation": reconciliation,
@@ -770,12 +756,10 @@ def _validate_existing_voucher_group(transactions: list[dict], voucher_type: str
         )
 
 
-def _begin_existing_voucher_transaction(db, voucher_type: str, voucher_no: str) -> None:
-    """Serialize consumers of one voucher while the group is validated."""
-    db._in_transaction = True
-    if db.dialect == "sqlite":
-        db.conn.execute("BEGIN IMMEDIATE")
-    else:
+def _lock_existing_voucher(db, voucher_type: str, voucher_no: str) -> None:
+    """Serialize consumers of one voucher while the group is validated. Runs
+    inside db.atomic(), which already holds SQLite's write reservation."""
+    if db.dialect == "postgres":
         # ``voucher_type`` is checked against the fixed allowlist before this
         # helper is called, so quoting the table name is safe.
         db.conn.execute(
@@ -804,8 +788,8 @@ def reconcile_with_existing_voucher_group(bank_transactions: list[str], voucher_
         names.append(name)
 
     db = get_db()
-    try:
-        _begin_existing_voucher_transaction(db, voucher_type, voucher_no)
+    with db.atomic():
+        _lock_existing_voucher(db, voucher_type, voucher_no)
         transactions = [_transaction(name) for name in names]
         for tx in transactions:
             _ensure_available(tx)
@@ -826,12 +810,6 @@ def reconcile_with_existing_voucher_group(bank_transactions: list[str], voucher_
             activate_generated_reconciliation(
                 reconciliation, voucher_type=voucher_type, voucher_no=voucher_no,
             )
-        db.commit()
-    except Exception:
-        db.conn.rollback()
-        raise
-    finally:
-        db._in_transaction = False
     return {
         "bank_transaction": names[0],
         "bank_transactions": names,
@@ -866,19 +844,11 @@ def undo_reconciliation(bank_transaction: str, *, user: str | None = None,
     if audit["mode"] in {"Created Payment Entry", "Created Journal Entry"}:
         document_cls = PaymentEntry if audit["voucher_type"] == "Payment Entry" else JournalEntry
         document = document_cls.load(audit["voucher_no"])
-        db._in_transaction = True
-        db.set_value("Bank Reconciliation", audit["name"], "reversed_by", user)
-        try:
+        with db.atomic():
+            db.set_value("Bank Reconciliation", audit["name"], "reversed_by", user)
             document.cancel()
-            db.commit()
-            db._in_transaction = False
-        except Exception:
-            db.conn.rollback()
-            db._in_transaction = False
-            raise
     else:
-        db._in_transaction = True
-        try:
+        with db.atomic():
             group = _group_rows(audit.get("group_id")) or [audit]
             for member in group:
                 member_tx = _transaction(member["bank_transaction"])
@@ -891,12 +861,6 @@ def undo_reconciliation(bank_transaction: str, *, user: str | None = None,
                     "status": "Unreconciled", "reconciled_by": None,
                     "reconciled_at": None, "modified": now(),
                 })
-            db.commit()
-        except Exception:
-            db.conn.rollback()
-            raise
-        finally:
-            db._in_transaction = False
     return {
         "bank_transaction": bank_transaction,
         "bank_transactions": [

lambda_erp/accounting/budget.py

@@ -87,6 +87,16 @@ def validate_expense_against_budget(gl_entry):
 
     budgets = db.get_all("Budget", filters=filters, fields=["*"])
 
+    # Two postings against one "Stop" budget must not both pass on the same
+    # old total. Lock the budget rows (in name order, so concurrent postings
+    # can't deadlock) before summing: the lock waits for the other posting to
+    # commit, and the SUM below then sees its GL entries.
+    stop_budgets = sorted(b["name"] for b in budgets if b.get("action_if_exceeded") == "Stop")
+    if stop_budgets and db.dialect == "postgres" and db._in_transaction:
+        placeholders = ", ".join("?" * len(stop_budgets))
+        db.sql(f'SELECT name FROM "Budget" WHERE name IN ({placeholders}) '
+               'ORDER BY name FOR UPDATE', stop_budgets)
+
     for budget in budgets:
         fiscal_year = budget.get("fiscal_year", "")
         if fiscal_year and str(year) not in fiscal_year:

lambda_erp/accounting/revaluation.py

@@ -161,11 +161,31 @@ def run_period_revaluation(company, date=None, *, post=True):
                 "No Unrealized Exchange Gain/Loss account is configured on the company; "
                 "cannot post the period revaluation."
             )
-        reval_no = new_name("REVAL")
-        reversal_no = new_name("REVAL")
         next_date = add_days(on_date, 1).isoformat()
-        make_gl_entries(_build_entries(postable, fx_account, company, on_date, reval_no, swap=False))
-        make_gl_entries(_build_entries(postable, fx_account, company, next_date, reversal_no, swap=True))
+        # One transaction: the voucher and its reversal post together or not
+        # at all. Serialized per company, and refused when this date is already
+        # revalued: party balances are measured from invoice rates, so a
+        # second run on the same date would book the same delta again.
+        with db.atomic():
+            if db.dialect == "postgres":
+                db.sql("SELECT pg_advisory_xact_lock(hashtext(?))",
+                       [f"period-revaluation:{company}"])
+            existing = db.sql(
+                'SELECT voucher_no FROM "GL Entry" WHERE voucher_type = ? '
+                'AND company = ? AND posting_date = ? AND COALESCE(is_cancelled, 0) = 0 '
+                "AND remarks NOT LIKE 'Reversal of %' LIMIT 1",
+                ["Period Revaluation", company, str(on_date)],
+            )
+            if existing:
+                raise ValidationError(
+                    f"{company} is already revalued on {on_date} "
+                    f"({existing[0]['voucher_no']}); posting again would double the "
+                    "unrealized FX."
+                )
+            reval_no = new_name("REVAL")
+            reversal_no = new_name("REVAL")
+            make_gl_entries(_build_entries(postable, fx_account, company, on_date, reval_no, swap=False))
+            make_gl_entries(_build_entries(postable, fx_account, company, next_date, reversal_no, swap=True))
         result.update(posted=True, voucher_no=reval_no,
                       reversal_voucher_no=reversal_no, reversal_date=next_date)
 

lambda_erp/database.py

@@ -258,6 +258,10 @@ class Database:
         self._local = threading.local()
         self._col_cache = {}  # doctype -> set(columns); invalidated on ALTER
         self._text_col_cache = {}  # doctype -> set(text columns); invalidated on ALTER
+        # Postgres naming series run on their own autocommit connection (see
+        # next_in_series); one per process, serialized by this lock.
+        self._series_conn = None
+        self._series_lock = threading.Lock()
         if self._is_memory:
             self._lock = threading.RLock()
             self._shared_conn = self._open_conn()
@@ -268,7 +272,35 @@ class Database:
             # Open the init-thread connection now so _setup_schema can use it
             # via the self.conn property.
             self._open_conn()
-        self._setup_schema()
+        with self.startup_lock():
+            self._setup_schema()
+
+    # Arbitrary constant naming the "schema setup / migrations" advisory lock.
+    _STARTUP_LOCK_KEY = 715624180032
+
+    @contextmanager
+    def startup_lock(self):
+        """Run schema setup and migrations in one process at a time.
+
+        Every process applies pending migrations when it boots. Two replicas,
+        or a new revision starting next to a restarting old one, would otherwise
+        run the same migration concurrently: the slower one fails on the
+        migration marker (a crash loop for required migrations) and a data
+        backfill can run twice. A Postgres session advisory lock, held on its
+        own connection, makes the others wait and then find the work done.
+        Not reentrant: don't nest two startup_lock() blocks in one process.
+        SQLite is single-process, so it needs no lock."""
+        if self.dialect != "postgres":
+            yield
+            return
+        import psycopg
+
+        with psycopg.connect(self.db_path, autocommit=True) as conn:
+            conn.execute("SELECT pg_advisory_lock(%s)", [self._STARTUP_LOCK_KEY])
+            try:
+                yield
+            finally:
+                conn.execute("SELECT pg_advisory_unlock(%s)", [self._STARTUP_LOCK_KEY])
 
     def _open_conn(self):
         """Open a new connection (per-backend) with the same per-conn settings.
@@ -316,6 +348,13 @@ class Database:
         conn = getattr(self._local, "conn", None)
         if conn is None:
             conn = self._open_conn()
+        elif (self.dialect == "postgres" and conn._raw.closed
+              and not getattr(self._local, "in_transaction", False)):
+            # A dropped connection (server restart, failover, idle kill) would
+            # otherwise fail every later request this pooled thread serves.
+            # Mid-transaction the error must surface; reconnecting there would
+            # silently continue in a new transaction.
+            conn = self._open_conn()
         return conn
 
     @property
@@ -1961,7 +2000,15 @@ class Database:
         evaluates the parser at query time: persisting an index that calls a
         connection-local UDF would break ordinary sqlite3 writers and imports.
         Apply after core/plugin schema setup; failures retry on subsequent boots.
+        Indexes that already exist are skipped up front: on PostgreSQL even
+        CREATE INDEX IF NOT EXISTS takes the table lock before checking, so
+        every boot would otherwise queue behind live writes.
         """
+        if self.dialect == "postgres":
+            existing = {r[0] for r in self.conn.execute(
+                "SELECT indexname FROM pg_indexes WHERE schemaname = 'public'").fetchall()}
+        else:
+            existing = set()
         for table in self._all_user_tables():
             try:
                 columns = self._get_table_columns(table)
@@ -1986,7 +2033,14 @@ class Database:
                             self.conn.execute(f'DROP INDEX IF EXISTS "{idx}"')
                             self.conn.commit()
             for idx, expression in indexes:
+                if idx in existing:
+                    continue
                 try:
+                    if self.dialect == "postgres":
+                        # CREATE INDEX waits for a SHARE lock, and every new
+                        # write to the table queues behind that wait. Give up
+                        # quickly instead; the next boot retries.
+                        self.conn.execute("SET LOCAL lock_timeout = '3s'")
                     self.conn.execute(f'CREATE INDEX IF NOT EXISTS "{idx}" ON "{table}" ({expression})')
                     self.conn.commit()
                 except Exception:
@@ -2272,6 +2326,115 @@ class Database:
             finally:
                 self._in_transaction = outer
 
+    # --- Naming series ---
+
+    def next_in_series(self, prefix: str) -> int:
+        """Allocate the next number of the naming series `prefix`.
+
+        The counter lives in "_NamingSeries", so every process, replica and
+        revision on this database draws from the same sequence. A process-local
+        counter handed out numbers another writer had already used.
+
+        On Postgres the increment runs on a separate autocommit connection:
+        the number is taken at once and never handed out again, even if the
+        caller's transaction rolls back (a gap, never a duplicate), and the
+        series row is not locked for the length of a document submit. SQLite has
+        a single writer anyway, so there the increment joins the caller's
+        transaction.
+
+        A prefix seen for the first time is seeded from the highest
+        "PREFIX-<digits>" already stored, so existing data keeps its numbers.
+        """
+        if self.dialect == "postgres":
+            return self._next_in_series_pg(prefix)
+        with self._lock:
+            conn = self.conn
+            update = 'UPDATE "_NamingSeries" SET current = current + 1 WHERE prefix = ?'
+            if conn.execute(update, [prefix]).rowcount == 0:
+                floor = self._series_floor(
+                    prefix, lambda sql, params: conn.execute(sql, params).fetchall())
+                conn.execute(
+                    'INSERT INTO "_NamingSeries" (prefix, current) VALUES (?, ?)',
+                    [prefix, floor + 1])
+            current = conn.execute(
+                'SELECT current FROM "_NamingSeries" WHERE prefix = ?', [prefix]
+            ).fetchone()[0]
+            if not self._in_transaction:
+                conn.commit()
+            return int(current)
+
+    def _next_in_series_pg(self, prefix: str) -> int:
+        import psycopg
+
+        update = ('UPDATE "_NamingSeries" SET current = current + 1 '
+                  'WHERE prefix = %s RETURNING current')
+        with self._series_lock:
+            for attempt in (1, 2):
+                try:
+                    conn = self._series_conn
+                    if conn is None or conn.closed:
+                        conn = self._series_conn = psycopg.connect(self.db_path, autocommit=True)
+                    row = conn.execute(update, [prefix]).fetchone()
+                    if row is None:
+                        floor = self._series_floor(
+                            prefix,
+                            lambda sql, params: conn.execute(sql.replace("?", "%s"), params).fetchall())
+                        # Two processes may seed the same new prefix at once;
+                        # both floors are valid, so keep the higher one.
+                        conn.execute(
+                            'INSERT INTO "_NamingSeries" (prefix, current) VALUES (%s, %s) '
+                            'ON CONFLICT (prefix) DO UPDATE SET current = '
+                            'GREATEST("_NamingSeries".current, EXCLUDED.current)',
+                            [prefix, floor])
+                        row = conn.execute(update, [prefix]).fetchone()
+                    return int(row[0])
+                except psycopg.OperationalError:
+                    # A dropped connection (failover, idle kill): reconnect once.
+                    if self._series_conn is not None:
+                        try:
+                            self._series_conn.close()
+                        except Exception:
+                            pass
+                    self._series_conn = None
+                    if attempt == 2:
+                        raise
+
+    def _series_floor(self, prefix: str, fetch) -> int:
+        """Highest number already used as "PREFIX-<digits>" in any table.
+
+        Only exact "PREFIX-<digits>" names count, so "ACT-IMP-LEAD-90951" or a
+        child row "LEAD-ITEM-0005" don't inflate ACT or LEAD. REVAL vouchers
+        have no row of their own and are found through GL Entry.voucher_no.
+        A failing probe raises: seeding a series too low would hand out
+        numbers that are already taken, one collision after another.
+        """
+        import re
+
+        if self.dialect == "postgres":
+            tables = [r[0] for r in fetch(
+                "SELECT c.table_name FROM information_schema.columns c "
+                "JOIN information_schema.tables t "
+                "ON t.table_schema = c.table_schema AND t.table_name = c.table_name "
+                "WHERE c.table_schema = 'public' AND c.column_name = 'name' "
+                "AND t.table_type = 'BASE TABLE'", [])]
+        else:
+            tables = [r[0] for r in fetch(
+                "SELECT name FROM sqlite_master WHERE type = 'table'", [])
+                if "name" in self._get_table_columns(r[0])]
+        probes = [(table, "name") for table in tables]
+        if "GL Entry" in tables:
+            probes.append(("GL Entry", "voucher_no"))
+
+        pattern = re.compile(rf"^{re.escape(prefix)}-(\d+)$")
+        floor = 0
+        for table, column in probes:
+            for row in fetch(f'SELECT "{column}" FROM "{table}" WHERE "{column}" LIKE ?',
+                             [f"{prefix}-%"]):
+                match = pattern.match(row[0] or "")
+                if match:
+                    floor = max(floor, int(match.group(1)))
+        return floor
+
     def commit(self):
         with self._lock:
             self.conn.commit()
@@ -2281,6 +2444,9 @@ class Database:
 
     def close(self):
         self.conn.close()
+        if self._series_conn is not None:
+            self._series_conn.close()
+            self._series_conn = None
 
 
 # Module-level singleton, initialized by setup()
@@ -2878,6 +3044,25 @@ def _m039_connection_app_type(db: "Database") -> None:
     db.ensure_column("Api Key", "app_type", "TEXT DEFAULT 'other'")
 
 
+def _m040_naming_series(db: "Database") -> None:
+    """Shared document numbering (see Database.next_in_series). Rows are
+    seeded lazily from existing names, so this only creates the table."""
+    db.conn.execute(
+        """CREATE TABLE IF NOT EXISTS "_NamingSeries" (
+            prefix TEXT PRIMARY KEY,
+            current INTEGER NOT NULL
+        )"""
+    )
+    db.conn.commit()
+
+
+def _m041_chat_turn_lease(db: "Database") -> None:
+    """One running agent turn per chat session, across connections and
+    processes (see api.chat.claim_session_turn)."""
+    db.ensure_column("Chat Session", "active_turn", "TEXT")
+    db.ensure_column("Chat Session", "active_turn_until", "TEXT")
+
+
 Database.MIGRATIONS = [
     (1, "chat_message_session_id", _m001_chat_message_session_id),
     (2, "chat_session_user_id", _m002_chat_session_user_id),
@@ -2918,6 +3103,8 @@ Database.MIGRATIONS = [
     (37, "pricing_record_lifecycle", _m037_pricing_record_lifecycle),
     (38, "customer_website", _m038_customer_website),
     (39, "connection_app_type", _m039_connection_app_type),
+    (40, "naming_series", _m040_naming_series),
+    (41, "chat_turn_lease", _m041_chat_turn_lease),
 ]
 
 

lambda_erp/model.py

@@ -73,7 +73,7 @@ class Document:
         self._loaded_modified = None
 
         if not self._data.get("name"):
-            self._data["name"] = new_name(self.PREFIX)
+            self._data["name"] = self._unused_name()
         if not self._data.get("docstatus"):
             self._data["docstatus"] = DRAFT
         if not self._data.get("creation"):
@@ -92,6 +92,16 @@ class Document:
                     child["name"] = new_name(f"{self.PREFIX}-ITEM")
                 self._children[field_name].append(child)
 
+    def _unused_name(self):
+        """Next series name not already taken. A record created with an
+        explicit name (import, API caller, migration) may sit ahead of the
+        series; skip past it rather than fail the save with "already exists"."""
+        db = get_db()
+        while True:
+            name = new_name(self.PREFIX)
+            if not db.exists(self.DOCTYPE, name):
+                return name
+
     # --- Attribute access (mirrors the framework's Document) ---
 
     def __getattr__(self, key):

lambda_erp/utils.py

@@ -134,51 +134,13 @@ class _dict(dict):
         super().update(*args, **kwargs)
         return self
 
-def new_name(prefix, sequence_store={}):
+def new_name(prefix):
     """Generate a sequential name like 'ACC-SINV-0001'.
 
-    Simple replacement for the framework's naming system.
-    On first use of a prefix, checks the database for the highest existing
-    sequence number so we don't collide after a server restart.
+    Simple replacement for the framework's naming system. The number comes
+    from the database's shared naming series (Database.next_in_series), so
+    every process on the same database draws from one sequence.
     """
-    if prefix not in sequence_store:
-        # Bootstrap from database
-        from lambda_erp.database import get_db
-        try:
-            db = get_db()
-            # Search all tables for names matching this prefix pattern
-            if getattr(db, "dialect", "sqlite") == "postgres":
-                # Only probe tables that HAVE a `name` column. On Postgres a
-                # failing statement (e.g. SELECT name FROM a table without one)
-                # aborts the whole transaction, unlike SQLite which shrugs it
-                # off — so we must not issue a query that can error here.
-                tables = db.sql(
-                    "SELECT table_name AS name FROM information_schema.columns "
-                    "WHERE column_name = 'name' AND table_schema = 'public'"
-                )
-            else:
-                tables = db.sql("SELECT name FROM sqlite_master WHERE type='table'")
-            max_num = 0
-            for t in tables:
-                table_name = t["name"] if isinstance(t, dict) else t[0]
-                try:
-                    rows = db.sql(
-                        f'SELECT name FROM "{table_name}" WHERE name LIKE ?',
-                        [f"{prefix}-%"],
-                    )
-                    for row in rows:
-                        n = row["name"] if isinstance(row, dict) else row[0]
-                        try:
-                            num = int(n.rsplit("-", 1)[-1])
-                            max_num = max(max_num, num)
-                        except (ValueError, IndexError):
-                            pass
-                except Exception:
-                    pass
-            sequence_store[prefix] = max_num
-        except Exception:
-            sequence_store[prefix] = 0
-
-    count = sequence_store[prefix] + 1
-    sequence_store[prefix] = count
-    return f"{prefix}-{count:04d}"
+    from lambda_erp.database import get_db
+
+    return f"{prefix}-{get_db().next_in_series(prefix):04d}"

{lambda_erp-1.2.2.dist-info → lambda_erp-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 1.2.2
+Version: 1.3.0
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0

{lambda_erp-1.2.2.dist-info → lambda_erp-1.3.0.dist-info}/RECORD

@@ -1,25 +1,25 @@
 api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 api/attachments.py,sha256=v5WAGUafYqA4tHWkPHHnP5pYxsJx9wDf6Mn1fTyUmYc,20496
-api/auth.py,sha256=xkyMjAFO1RpiwevPzjEw194x5M06F54LLLBx93RsV5Q,43203
+api/auth.py,sha256=IcZnUBMv_6u4CrEPENUtsV2DdLQ2rgZGzgpbGXX7s4o,44073
 api/bootstrap.py,sha256=9r6Bz93Puhz06d8C5LsbYk2NUt2Gr6Nz85FJxOWriCc,21308
-api/chat.py,sha256=-FLrT5znrDJs1YrUB6gsmEbg9dQEI3bvQ2Em7qHKNTI,241088
+api/chat.py,sha256=JaifG2AiT5OtBOGLC3nXuZ-hLhwKwpLJkLXnhj0eWKY,245353
 api/chat_links.py,sha256=eHuGxuMvWh42-UC3i97GVxV04NemXGMQDUhfoKiLO-A,2344
 api/demo_limits.py,sha256=b5PSNWgPIRuIVsAcJZyGLCivUv4RorEzJlZXf5LNwh0,14191
 api/deps.py,sha256=HaFNz0q0NlX49kNMs1xMe0rrO6Slqpt8-TlPOATirT4,140
 api/erp_context.py,sha256=FTVou9bGO_9X7xPBqaf2H9QG7qmKJvWPcw4Kduc4qBc,4483
 api/errors.py,sha256=kEC6BUU4koPlyGoCDobAA8sHRoMqw50Xtc2105ZFKF4,5376
 api/list_values.py,sha256=mGe74gJ4fHPa5X2djJNTsRE8txa0hG40GAxMfTumU_w,963
-api/main.py,sha256=1rwZsXJRxIooFECRTZd-UwRUAGMp6SPL_sxLOCDploo,10803
+api/main.py,sha256=t4fj7kpXURkpU39O3Tv9SFc30Un7jtB75wmZtraZk1k,11345
 api/mcp_oauth.py,sha256=MjmScAvihkvEXdmM3QJP0FLqqXq-pQ1zmWa67LiArDM,21392
 api/mentions.py,sha256=3A4hJ8mUD9IVisz21x6XtsHeR0tHqMyIbLPRn3mb9Ps,16712
-api/oauth.py,sha256=nRJGGweUGvD_yN7KBSuO7dhL7ynSnCjiPCQdvaWDgnY,22493
+api/oauth.py,sha256=w1XO__oQVQse0S3U03DYLN-_jUPOTliZ4Grr1Nhs4Fs,22450
 api/pdf.py,sha256=HnJzRYVx6D43ULvYCb2ehwqrGVvaqbzT1vsNg1Gxg7M,19228
 api/pdf_contract.py,sha256=cEUntXz951OaXTvGdhYnL58LbR_efowGGHhNEBP7y5Q,16118
 api/pdf_exports.py,sha256=bFdfJVInkCH3BV8e9PpBLF9sOX2OkcFnNO0emuVnrps,3199
 api/pdf_profiles.py,sha256=gqMRM-T6nzQnJ0DTxUf9MBFtpJws07MpNUQHHgI3Y7c,9206
 api/providers.py,sha256=ZwuDtukTpHh553wln-AEvRKQ5kE4296rj5_Kgh84O30,6525
 api/remarks_md.py,sha256=8MZ5oO3TNLDbjdMF2PjdFW13LdAffogOxT2nT0eYrVY,3754
-api/services.py,sha256=tXgkxV-U-KymK9xDo5Q6ILZg-roD9c8Uhmi6Uq4qPMI,61293
+api/services.py,sha256=F-7O9faPulVFV11RNLquxmPli1dEezUMztsip8h5-E4,61682
 api/time_filters.py,sha256=nAlyyZD7i3UOMq8kJdLGo2-jKYl84IZ8ad-oYBTjg1c,4882
 api/tool_permissions.py,sha256=CgVUUFLuJxEjQ44EWhzpIDNpzIY_tjSrgb5o5SBXU2Y,2216
 api/write_context.py,sha256=RsrpMTa7k78_wWPGGE2KwLmIOdt_hF54kji5HdjGNI0,649
@@ -30,11 +30,11 @@ api/routers/admin.py,sha256=0OrQ6Zg28pV56vwxnzYicaUriAP4mdrj81iIZK4aXcA,3835
 api/routers/analytics.py,sha256=XACviKwpvYn1i2LcjwfEd05wwzCFyQYopYW45krhz04,55293
 api/routers/availability.py,sha256=6iyVtIksPI3aC1tFFNAo4bwQ3iTiv3ebRmfhJzJrKPY,6141
 api/routers/bank_reconciliation.py,sha256=USv3-WEsgmXvpXALkwVvE9E536hYQ8Wdlr3c1znyBiQ,3717
-api/routers/bank_statements.py,sha256=8d6ur-ZS7BCFv8mgdUJ7Il7qKjOxCj4rWdQgS1K4qIA,4518
-api/routers/chat_api.py,sha256=4XAtp3wszIkVB5n9IrPLscK3vNT4QHx5FRYk8JyJK3s,7084
+api/routers/bank_statements.py,sha256=QCUW0Fu3nBnPuM9zky3ne_7FEkKoCEitibheBP0EJ1I,4678
+api/routers/chat_api.py,sha256=AdnKm5XtrdMnaMhhwYm_Ck8bvh8RnExtP9K0z2o47eo,8050
 api/routers/documents.py,sha256=Ww3bL-BN0uIYPRg6UO-Gq3YjtC-nX2DUYNKOqkZOn0Q,11736
-api/routers/masters.py,sha256=hg8eO_TsN57ULrM20xTbf_P7sGQpAyRhGnIi9ZgoKRQ,39043
-api/routers/mcp.py,sha256=6MP7TYw-Its0f7uNfsa4CbgFoQUqongB0vsxwPGj2iM,10948
+api/routers/masters.py,sha256=oAPwv_zaByl_R-krloUch5NkA0BT0tmvyPvUf0VUqiI,38697
+api/routers/mcp.py,sha256=X91Bigk3RDmshQ49tQeAFqp3HCKO6xZGheGzweHqF1E,11168
 api/routers/proposals.py,sha256=KtIITJ-GHa3GSMzSDE205nnFNvMwt0KUVAxU1M8-uyU,4520
 api/routers/reports.py,sha256=6GLlUJQfstS2p_7F5Il_XYwmZIifSHqaVjFdxTQM1OU,29738
 api/routers/setup.py,sha256=4qVLO0TExVCTGORDI4dNMUyxauvhLRbUS1VydnSubNw,16206
@@ -44,22 +44,22 @@ api/templates/document.html,sha256=6B1fhdrgq2WaEHmpcGR_LkbZ7hNU6wggLt-a9ojO5Pw,9
 api/templates/proposal.html,sha256=sx2qRsfl0kp8VeqgYrU_4MVs7rokWavfuDH0fU71ppU,5169
 api/templates/record.html,sha256=aPCWz4uB1ZBEf8KTFHeChMAbWgObEvx3VuhV1aC4x7A,34
 lambda_erp/__init__.py,sha256=ahOPqWyRzyy70oKnhA95TZnOWOCSaOZIjGSQ-qLojro,1088
-lambda_erp/database.py,sha256=5ML7kgKarrP57nVLFZPdEa0iNiLLwyfm_lId1EVNyZk,127227
+lambda_erp/database.py,sha256=v3JcOZrg8hhTLxze2mmNLoSOMHKtLalLrXSut64JMFs,136250
 lambda_erp/exceptions.py,sha256=ml-iuIefPDTNKqsOJCbdipstaAEKK5re9djIG-UFDxw,516
 lambda_erp/hooks.py,sha256=koA8a_kNGVIknIhDWjqaq_LI0OYS9Tjt3JT08O5XJcc,1369
 lambda_erp/master_integrity.py,sha256=xGonkRsJZn92CrBcj8oFBnNnzIncIR1C3fuTOM3UrOw,1191
-lambda_erp/model.py,sha256=RkFUryllJsiCUpQaKAmYy9tNlHoJ0dJyFI1OsUOiQdw,24730
+lambda_erp/model.py,sha256=S4XKCXcih8P31ESOhPW_nquaBZcEWz96Ml76NdNk4D8,25146
 lambda_erp/simulation.py,sha256=iwuTpNvZ35woeE-utveNgWSyDhlE2MK3Id_TTuNTNxg,27554
 lambda_erp/timestamps.py,sha256=iEOvJCOPoQ0YjbLv5CV2fEH7e002h2caWuYD2ko5Q9I,3067
-lambda_erp/utils.py,sha256=TMnufnsdKCsh8eg5kiz1AiJxQlkjponh_oBX6OzAMG4,6165
+lambda_erp/utils.py,sha256=VKXhpsiWIAKc_Kf1aCDnwmnrmMIsK5egHuB2zrddfVo,4404
 lambda_erp/validation.py,sha256=45SKxyhggbush7mR3l-CtvInyLmaMnISFmFavVry77I,9844
 lambda_erp/workflow.py,sha256=LMkjWXSrTywl9fo1knIUOsmrTmgkmTJsrfQqPYTqYxA,12732
 lambda_erp/accounting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lambda_erp/accounting/bank_account.py,sha256=3zwf2thIlB_JAFuaaK2EjhFtfZv-R2JJ3oklplM9Ab0,2862
-lambda_erp/accounting/bank_reconciliation.py,sha256=bc75k1grFI7LlwOVdpGDTxBcqEb_RkvKtcweSH76CK8,39662
+lambda_erp/accounting/bank_reconciliation.py,sha256=8YoVFV44AkEYEKix1NXhzO_r4RtfvS6CqfRedx6bpTA,38804
 lambda_erp/accounting/bank_statement_import.py,sha256=52JwE_s6laxOVX7GGtE4xWG6Y8p0i-iFySGfXrJVOZk,18978
 lambda_erp/accounting/bank_transaction.py,sha256=5BSR4jA_4pDJ7moxHss5WJEFaBE4d5QTc4xGn8x24Q0,4939
-lambda_erp/accounting/budget.py,sha256=3VyMYMbCZsa5TXIu9oV4ItARhDQ1rEpu6vtOMQLLnS0,4675
+lambda_erp/accounting/budget.py,sha256=uviD4vAunMneorfuNZ8MhFSQu8NoWjGjvopc1vHKNlc,5324
 lambda_erp/accounting/camt.py,sha256=zF2bppz4YXlifN1co5hNZR36xv4U3tUFB8bFxJ_f9Z8,17455
 lambda_erp/accounting/chart_of_accounts.py,sha256=pOS0FbwFQ-GPGl996UXb305ZLum15GYaLuqS2OiPHp0,10207
 lambda_erp/accounting/general_ledger.py,sha256=ySlaYYUS-hIqOVRZaBl_3t8VFp4E9Ua66aiNrdBYh-0,13459
@@ -67,7 +67,7 @@ lambda_erp/accounting/journal_entry.py,sha256=pA6gD5penIO__0L4PMM30J6i3O7Bj6WmEw
 lambda_erp/accounting/payment_entry.py,sha256=_-7q-aiq1Ky7PmtIAi6n8ou608zudHCJCGOSQDjaE4s,26504
 lambda_erp/accounting/pos_invoice.py,sha256=icxAaFfoe6A_zpg_ZTxcFgk9-BZ5MZvnOXsFzVhrTvA,13668
 lambda_erp/accounting/purchase_invoice.py,sha256=ZzpHuRaob1ZWWZblesy2-k7Jp5iXUzTPcjVW3jjIrBo,19360
-lambda_erp/accounting/revaluation.py,sha256=jIDb6ZwrclQfCiqh4Estc94qJdX2RrgWA7vVmy3Vpiw,7742
+lambda_erp/accounting/revaluation.py,sha256=40OF8ngnMp6eCYa3R0262B3WvAaxnyeEWTtrgzFOtfE,8862
 lambda_erp/accounting/sales_invoice.py,sha256=n66xi7VMaER-BlR1q6khBzEpKXeN5LIRccy6LS13lnE,18971
 lambda_erp/accounting/settlement.py,sha256=ej43n59qORcKJZTLOmnqg6QsiiMKxSqLPh7cVIZxeqw,3033
 lambda_erp/accounting/subscription.py,sha256=Xzk2465D-pp8-fKp73pF96L600KBP_qXjEJg54ncSIM,8585
@@ -104,7 +104,7 @@ lambda_erp/stock/delivery_note.py,sha256=Z3s57gVA7oSIpLauSd3DIWu-1y3tmvEE-zsopTv
 lambda_erp/stock/purchase_receipt.py,sha256=E42oHRO4MAowQniLumbOjYY38vVfHbHchkxCWyM3KDg,11463
 lambda_erp/stock/stock_entry.py,sha256=Itbt9a1u8b1s1OItKwVYMJDLjbNze2-UI2raIemCuts,12493
 lambda_erp/stock/stock_ledger.py,sha256=AFybuScWwfaTvsqOSAon3gwsjIza7skXvrvyQowL7b0,13265
-lambda_erp-1.2.2.dist-info/METADATA,sha256=P5e1cb8A_f9b5tY9YjS2mDJMV9Ph5Qft5LZCoyK35Aw,31852
-lambda_erp-1.2.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lambda_erp-1.2.2.dist-info/licenses/LICENSE,sha256=8H08P22jiM0mJ97SgnpYchU0NeaPunGxZc3IqEaLgtc,11394
-lambda_erp-1.2.2.dist-info/RECORD,,
+lambda_erp-1.3.0.dist-info/METADATA,sha256=ifoUfHeiHp1YhAATK6TabtikjcCPGS-r9QRLEwSglu0,31852
+lambda_erp-1.3.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+lambda_erp-1.3.0.dist-info/licenses/LICENSE,sha256=8H08P22jiM0mJ97SgnpYchU0NeaPunGxZc3IqEaLgtc,11394
+lambda_erp-1.3.0.dist-info/RECORD,,

{lambda_erp-1.2.2.dist-info → lambda_erp-1.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.4
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any