lambda-erp 0.6.13__tar.gz → 0.6.14__tar.gz

{lambda_erp-0.6.13 → lambda_erp-0.6.14}/PKG-INFO

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

{lambda_erp-0.6.13 → lambda_erp-0.6.14}/api/attachments.py

@@ -16,10 +16,55 @@ router = APIRouter(prefix="/chat", tags=["chat-attachments"])
 
 MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024  # 10 MB
 MAX_ATTACHMENTS_PER_SESSION = 100  # sanity cap
+
+# Binary Office / OpenDocument formats. The chat model reads these directly via
+# the OpenAI `file` content part (the same mechanism PDFs use) — the endpoint
+# accepts the raw bytes and reasons about them, so there is NO server-side
+# conversion/parsing here. Keep this set authoritative: the upload gate, the
+# extension map, and build_multimodal_content all read from it.
+OFFICE_MIME_TYPES = {
+    # Spreadsheets
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",          # xlsx
+    "application/vnd.ms-excel",                                                   # xls
+    "application/vnd.oasis.opendocument.spreadsheet",                             # ods
+    # Word-processing documents
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",    # docx
+    "application/msword",                                                         # doc
+    "application/vnd.oasis.opendocument.text",                                    # odt
+    # Presentations
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",  # pptx
+    "application/vnd.ms-powerpoint",                                              # ppt
+    "application/vnd.oasis.opendocument.presentation",                           # odp
+}
+
+# Plain-text formats — inlined into the prompt as text (no file part needed).
+TEXT_MIME_TYPES = {"text/csv", "text/plain"}
+
 ALLOWED_MIME_TYPES = {
     "image/png", "image/jpeg", "image/gif", "image/webp",
     "application/pdf",
+} | OFFICE_MIME_TYPES | TEXT_MIME_TYPES
+
+# Extension -> canonical mime, so a correctly-named file still uploads when the
+# browser/OS mislabels its type (Office files are frequently sent as
+# application/octet-stream, and CSV as application/vnd.ms-excel).
+_EXT_TO_MIME = {
+    "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "xls": "application/vnd.ms-excel",
+    "ods": "application/vnd.oasis.opendocument.spreadsheet",
+    "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "doc": "application/msword",
+    "odt": "application/vnd.oasis.opendocument.text",
+    "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "ppt": "application/vnd.ms-powerpoint",
+    "odp": "application/vnd.oasis.opendocument.presentation",
+    "csv": "text/csv",
+    "txt": "text/plain",
+    "pdf": "application/pdf",
+    "png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg",
+    "gif": "image/gif", "webp": "image/webp",
 }
+_MIME_TO_EXT = {m: e for e, m in _EXT_TO_MIME.items()}
 
 UPLOAD_ROOT = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "uploads")
 
@@ -46,14 +91,7 @@ def _safe_ext(filename: str, mime: str) -> str:
         ext = filename.rsplit(".", 1)[1].lower()
         if len(ext) <= 5 and ext.isalnum():
             return ext
-    mime_ext = {
-        "image/png": "png",
-        "image/jpeg": "jpg",
-        "image/gif": "gif",
-        "image/webp": "webp",
-        "application/pdf": "pdf",
-    }
-    return mime_ext.get(mime, "bin")
+    return _MIME_TO_EXT.get(mime, "bin")
 
 
 @router.post("/attachments")
@@ -65,7 +103,17 @@ async def upload_attachment(
     """Upload a chat attachment. Returns metadata the client uses to attach it to a message."""
     mime = (file.content_type or "application/octet-stream").lower()
     if mime not in ALLOWED_MIME_TYPES:
-        raise HTTPException(status_code=400, detail=f"Unsupported file type: {mime}. Allowed: images, PDF.")
+        # Browsers/OSes often mislabel Office files (e.g. octet-stream) — fall
+        # back to the filename extension so a correctly-named file still uploads.
+        ext = file.filename.rsplit(".", 1)[-1].lower() if file.filename and "." in file.filename else ""
+        if ext in _EXT_TO_MIME:
+            mime = _EXT_TO_MIME[ext]
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail=(f"Unsupported file type: {mime or ext or 'unknown'}. Allowed: images, PDF, "
+                        "spreadsheets (Excel/CSV/ODS), and documents (Word/OpenDocument)."),
+            )
 
     data = await file.read()
     if len(data) > MAX_ATTACHMENT_SIZE:
@@ -186,23 +234,33 @@ def get_attachments_by_ids(attachment_ids: list[str], user_id: str) -> list[dict
 
 
 def build_multimodal_content(attachment: dict) -> dict:
-    """Convert an attachment dict (with raw data) into an OpenAI multimodal content part."""
+    """Convert an attachment dict (with raw data) into an OpenAI multimodal content part.
+
+    Images go as `image_url`; plain-text files (CSV/TXT) are inlined as text;
+    PDFs and binary Office/OpenDocument files go as a `file` part carrying the
+    raw bytes — the model reads them directly, no server-side conversion.
+    """
     mime = attachment["mime_type"]
-    data_b64 = base64.b64encode(attachment["data"]).decode("ascii")
+    filename = attachment["filename"]
     if mime.startswith("image/"):
+        data_b64 = base64.b64encode(attachment["data"]).decode("ascii")
         return {
             "type": "image_url",
             "image_url": {"url": f"data:{mime};base64,{data_b64}"},
         }
-    if mime == "application/pdf":
+    if mime in TEXT_MIME_TYPES or mime.startswith("text/"):
+        text = attachment["data"].decode("utf-8", errors="replace")
+        return {"type": "text", "text": f"[File: {filename}]\n{text}"}
+    if mime == "application/pdf" or mime in OFFICE_MIME_TYPES:
+        data_b64 = base64.b64encode(attachment["data"]).decode("ascii")
         return {
             "type": "file",
             "file": {
-                "filename": attachment["filename"],
+                "filename": filename,
                 "file_data": f"data:{mime};base64,{data_b64}",
             },
         }
-    return {"type": "text", "text": f"[Unsupported attachment: {attachment['filename']}]"}
+    return {"type": "text", "text": f"[Unsupported attachment: {filename}]"}
 
 
 def list_session_attachments(session_id: str, user_id: str) -> list[dict]:

{lambda_erp-0.6.13 → lambda_erp-0.6.14}/api/chat.py

@@ -458,15 +458,17 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "list_documents",
-            "description": "List or search documents of a given type. Returns an array of document summaries (header fields only — child tables like 'items' and 'taxes' are NOT included to keep results compact). Use get_document to drill into a single document's line items. Results are ordered by creation DESC (newest first).",
+            "description": "List or search documents of a given type. Returns an array of document summaries (header fields only — child tables like 'items' and 'taxes' are NOT included to keep results compact). Use get_document to drill into a single document's line items. Results are ordered by creation DESC (newest first). Page past `limit` with `offset`; trim the payload to only the columns you need with `fields`.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "doctype": {"type": "string", "enum": DOCUMENT_SLUGS, "description": "Document type slug"},
-                    "filters": {"type": "object", "description": "Optional equality filters on any column, e.g. {\"status\": \"Draft\", \"customer\": \"CUST-001\", \"lead_id\": \"LEAD-3316\"}", "default": {}},
+                    "filters": {"type": "object", "description": "Optional filters on any column. Equality: {\"status\": \"Draft\", \"customer\": \"CUST-001\"}. Comparison (value = a 2-item array [op, value]): {\"grand_total\": [\">\", 100]}, {\"fit\": [\"!=\", \"A\"]}. NULL checks (1-item array): {\"fit\": [\"is null\"]}, {\"main_email\": [\"is not null\"]}. Allowed ops: =, !=, >, <, >=, <=, like, not like, is null, is not null.", "default": {}},
                     "order_by": {"type": "string", "description": "Optional column to sort by (e.g. \"occurred_at\" for a timeline). Defaults to creation."},
                     "order": {"type": "string", "enum": ["asc", "desc"], "description": "Sort direction (default desc)", "default": "desc"},
                     "limit": {"type": "integer", "description": "Max results (default 20, max 500)", "default": 20},
+                    "offset": {"type": "integer", "description": "Skip this many rows before returning — for paging past `limit`. Default 0.", "default": 0},
+                    "fields": {"type": "array", "items": {"type": "string"}, "description": "Optional: return ONLY these columns (plus name) instead of every field — keeps results lean when you need just a few. Unknown fields are ignored."},
                 },
                 "required": ["doctype"],
             },
@@ -521,6 +523,41 @@ TOOLS = [
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "batch_update_documents",
+            "description": (
+                "Update MANY existing documents of the SAME doctype in ONE call — far cheaper than a "
+                "separate update_document per record when applying changes across a set (e.g. tagging or "
+                "qualifying a batch of leads). Pass `doctype` and `updates`: an array of {\"name\", \"data\"} "
+                "objects where `data` holds the fields to change on that record (identical shape to "
+                "update_document's `data`, including child-table arrays). Best-effort and per-item: each "
+                "record is updated independently, so one failure doesn't undo the others. Max 200 per call. "
+                "Only drafts (docstatus=0) can be updated. Returns {\"updated\", \"failed\", "
+                "\"results\": [{\"name\", \"ok\", \"error\"?}]}."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "doctype": {"type": "string", "enum": DOCUMENT_SLUGS},
+                    "updates": {
+                        "type": "array",
+                        "description": "Up to 200 {name, data} objects — one per record to update.",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {"type": "string", "description": "Document name/ID to update"},
+                                "data": {"type": "object", "description": "Fields to change on this record (same as update_document's data)."},
+                            },
+                            "required": ["name", "data"],
+                        },
+                    },
+                },
+                "required": ["doctype", "updates"],
+            },
+        },
+    },
     {
         "type": "function",
         "function": {
@@ -746,7 +783,7 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "list_chat_attachments",
-            "description": "List all files (PDFs, images) the user has uploaded in this chat session. Returns metadata including id, filename, mime type, size, and upload date. Use this when the user references a previously uploaded file or you need to find an attachment to retrieve.",
+            "description": "List all files the user has uploaded in this chat session — PDFs, images, spreadsheets (Excel/CSV/ODS), and documents (Word/OpenDocument). Returns metadata including id, filename, mime type, size, and upload date. Use this when the user references a previously uploaded file or you need to find an attachment to retrieve.",
             "parameters": {"type": "object", "properties": {}},
         },
     },
@@ -754,7 +791,7 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "retrieve_chat_attachment",
-            "description": "Retrieve a previously uploaded file (PDF or image) by its id and inject it back into the conversation so you can read/analyze it. Use this when the user asks a follow-up about a file they uploaded earlier in the chat but it's no longer in the immediate context. Call list_chat_attachments first if you don't know the id.",
+            "description": "Retrieve a previously uploaded file (PDF, image, spreadsheet, or document) by its id and inject it back into the conversation so you can read/analyze it — e.g. to cross-check a spreadsheet of companies against the CRM. Use this when the user asks a follow-up about a file they uploaded earlier in the chat but it's no longer in the immediate context. Call list_chat_attachments first if you don't know the id.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -1251,22 +1288,59 @@ def build_tools():
 # ---------------------------------------------------------------------------
 
 
+# Filter/order keys that aren't real columns but are meaningful to list_documents.
+_LIST_META_FILTER_KEYS = {"from_date", "to_date", "date_field", "search", "search_fields"}
+
+
+def _validate_filter_columns(doctype_slug, filters) -> str | None:
+    """Reject a filter naming a column the doctype doesn't have. The key is
+    interpolated into SQL, so this both closes that injection seam and hands the
+    model a clean error instead of a 500. Returns an error string, or None."""
+    if not filters:
+        return None
+    cols = services.document_columns(doctype_slug)
+    if not cols:
+        return None  # unknown doctype -> handled downstream
+    bad = [k for k in filters if k not in cols and k not in _LIST_META_FILTER_KEYS]
+    if bad:
+        return (f"Unknown filter column(s) for {doctype_slug}: {', '.join(bad)}. "
+                f"Valid columns include: {', '.join(sorted(cols)[:40])}.")
+    return None
+
+
 def _handle_list_documents(args):
     # List views don't need child tables — strip them so the LLM can see more rows
     # within the tool-result budget. Use get_document to drill into one doc.
-    cls_entry = services.DOCUMENT_CLASSES.get(services.SLUG_TO_DOCTYPE.get(args["doctype"], ""))
+    doctype = args["doctype"]
+    filters = args.get("filters") or {}
+    err = _validate_filter_columns(doctype, filters)
+    if err:
+        return {"error": err}
+    order_by = args.get("order_by")
+    cols = services.document_columns(doctype)
+    if order_by and cols and order_by not in cols:
+        return {"error": f"Unknown order_by column for {doctype}: {order_by}"}
+
+    cls_entry = services.DOCUMENT_CLASSES.get(services.SLUG_TO_DOCTYPE.get(doctype, ""))
     child_keys = list(cls_entry.CHILD_TABLES.keys()) if cls_entry and cls_entry.CHILD_TABLES else []
 
-    rows = services.list_documents(
-        args["doctype"],
-        filters=args.get("filters"),
-        limit=args.get("limit", 20),
-        order_by=args.get("order_by"),
-        order=args.get("order", "desc"),
-    )
-    for row in rows:
-        for key in child_keys:
-            row.pop(key, None)
+    fields = args.get("fields")
+    try:
+        rows = services.list_documents(
+            doctype,
+            filters=filters,
+            limit=args.get("limit", 20),
+            offset=args.get("offset", 0) or 0,
+            order_by=order_by,
+            order=args.get("order", "desc"),
+            fields=fields,
+        )
+    except ValueError as e:  # bad filter operator / malformed operator list
+        return {"error": str(e)}
+    if not fields:  # projection already excludes child tables
+        for row in rows:
+            for key in child_keys:
+                row.pop(key, None)
     return rows
 
 
@@ -1285,6 +1359,13 @@ def _handle_update_document(args):
     return services.update_document(args["doctype"], args["name"], args.get("data", {}))
 
 
+def _handle_batch_update_documents(args):
+    try:
+        return services.batch_update_documents(args["doctype"], args.get("updates"))
+    except ValueError as e:  # bad doctype / empty or oversized batch
+        return {"error": str(e)}
+
+
 def _handle_submit_document(args):
     return services.submit_document(args["doctype"], args["name"])
 
@@ -1813,6 +1894,7 @@ TOOL_HANDLERS = {
     "get_document": _handle_get_document,
     "create_document": _handle_create_document,
     "update_document": _handle_update_document,
+    "batch_update_documents": _handle_batch_update_documents,
     "submit_document": _handle_submit_document,
     "cancel_document": _handle_cancel_document,
     "discard_document": _handle_discard_document,

{lambda_erp-0.6.13 → lambda_erp-0.6.14}/api/routers/mcp.py

@@ -44,7 +44,8 @@ _EXCLUDE = {
 # Mirror the REST permission model: reads are viewer+, writes are manager+,
 # delete_master is admin-only (the handler also re-checks).
 _WRITE = {
-    "create_document", "update_document", "submit_document", "cancel_document",
+    "create_document", "update_document", "batch_update_documents",
+    "submit_document", "cancel_document",
     "discard_document", "convert_document", "create_master", "update_master",
 }
 _ADMIN = {"delete_master"}

{lambda_erp-0.6.13 → lambda_erp-0.6.14}/api/services.py

@@ -313,6 +313,45 @@ def update_document(doctype_slug: str, name: str, data: dict) -> dict:
     return doc.as_dict()
 
 
+def batch_update_documents(doctype_slug: str, updates: list) -> dict:
+    """Apply many ``{"name", "data"}`` updates to ONE doctype in a single call.
+
+    Best-effort and per-item: each update runs as its own update_document (its
+    own save + hooks), so a failing row doesn't roll back the others. Returns
+    ``{"updated", "failed", "results": [{"name", "ok", "error"?}]}``. Because it
+    reuses update_document, every plugin save-hook still fires — e.g. a lead
+    update carrying a transient ``_note`` records its timeline Activity here too.
+    """
+    doctype, cls = get_document_class(doctype_slug)
+    if not cls:
+        raise ValueError(f"Unknown document type: {doctype_slug}")
+    if not isinstance(updates, list) or not updates:
+        raise ValueError("updates must be a non-empty array of {name, data} objects")
+    if len(updates) > _BATCH_MAX:
+        raise ValueError(f"Too many updates ({len(updates)}); max {_BATCH_MAX} per call")
+
+    results, updated = [], 0
+    for i, item in enumerate(updates):
+        if not isinstance(item, dict):
+            results.append({"name": None, "ok": False, "error": f"item {i} is not an object"})
+            continue
+        name = item.get("name")
+        data = item.get("data")
+        if not name:
+            results.append({"name": None, "ok": False, "error": f"item {i} is missing 'name'"})
+            continue
+        if not isinstance(data, dict) or not data:
+            results.append({"name": name, "ok": False, "error": "missing 'data' object"})
+            continue
+        try:
+            update_document(doctype_slug, name, data)
+            results.append({"name": name, "ok": True})
+            updated += 1
+        except Exception as e:  # noqa: BLE001 — per-item best effort; report, don't abort
+            results.append({"name": name, "ok": False, "error": str(e)})
+    return {"updated": updated, "failed": len(results) - updated, "results": results}
+
+
 def submit_document(doctype_slug: str, name: str) -> dict:
     doctype, cls = get_document_class(doctype_slug)
     if not cls:
@@ -473,8 +512,87 @@ def _order_clause(order_by: str = None, order: str = "desc") -> str:
     return f'"{order_by}" {direction}'
 
 
+# --- Filter operators (safe, whitelisted) ---
+#
+# A list-style filter value is normally a scalar (equality), but it may also be
+# an operator form so callers can express inequality / range / NULL checks:
+#   {"amount": [">", 100]}   {"fit": ["!=", "A"]}
+#   {"fit": ["is null"]}     {"main_email": ["is not null"]}
+# The operator is looked up in this whitelist and NEVER interpolated from raw
+# caller input, so an operator filter can't inject SQL. (The column name is
+# validated separately against the doctype's real columns by the callers.)
+_FILTER_OPS = {
+    "=": "=", "==": "=", "!=": "!=", "<>": "!=",
+    ">": ">", "<": "<", ">=": ">=", "<=": "<=",
+    "like": "LIKE", "not like": "NOT LIKE",
+    "is null": "IS NULL", "is not null": "IS NOT NULL",
+}
+_NULLARY_OPS = {"IS NULL", "IS NOT NULL"}  # take no bound value
+
+# Max records a single batch write may touch (keeps one call bounded).
+_BATCH_MAX = 200
+
+
+def _resolve_op(raw) -> str:
+    op = _FILTER_OPS.get(str(raw).strip().lower())
+    if not op:
+        raise ValueError(
+            f"Unsupported filter operator: {raw!r} "
+            f"(allowed: {', '.join(sorted(set(_FILTER_OPS)))})"
+        )
+    return op
+
+
+def _filter_atom(col: str, value):
+    """Build (sql_clause, params) for one filter entry. `value` may be:
+      scalar      -> `"col" = ?`
+      [op, val]   -> `"col" <op> ?`            (op whitelisted)
+      [op]        -> `"col" IS [NOT] NULL`     (nullary op only)
+    Raises ValueError on an unknown operator or a malformed operator list — the
+    tool/REST layer surfaces that as a clean error rather than bad SQL."""
+    if isinstance(value, (list, tuple)):
+        if len(value) == 1:
+            op = _resolve_op(value[0])
+            if op not in _NULLARY_OPS:
+                raise ValueError(f"Filter operator {value[0]!r} requires a value")
+            return f'"{col}" {op}', []
+        if len(value) == 2:
+            op = _resolve_op(value[0])
+            if op in _NULLARY_OPS:
+                return f'"{col}" {op}', []  # value ignored for IS [NOT] NULL
+            return f'"{col}" {op} ?', [value[1]]
+        raise ValueError(
+            f"Malformed filter for {col!r}: expected a scalar, [op], or [op, value]"
+        )
+    return f'"{col}" = ?', [value]
+
+
+def _where_from_filters(db_filters: dict):
+    """(where_parts, params) for a dict of already-parsed equality/operator
+    filters, via the whitelisted _filter_atom builder."""
+    where_parts, params = [], []
+    for k, v in db_filters.items():
+        clause, ps = _filter_atom(k, v)
+        where_parts.append(clause)
+        params.extend(ps)
+    return where_parts, params
+
+
+def _projection_columns(doctype_slug: str, fields) -> set:
+    """The set of real columns to keep for a `fields` projection — always
+    includes 'name'. Unknown field names are dropped (validated against the
+    doctype's real columns), so a projection can never widen or inject."""
+    real = document_columns(doctype_slug)
+    keep = {"name"}
+    for f in (fields or []):
+        if f in real:
+            keep.add(f)
+    return keep
+
+
 def list_documents(doctype_slug: str, filters: dict = None, limit: int = 50, offset: int = 0,
-                   include_discarded: bool = False, order_by: str = None, order: str = "desc") -> list:
+                   include_discarded: bool = False, order_by: str = None, order: str = "desc",
+                   fields: list = None) -> list:
     doctype = SLUG_TO_DOCTYPE.get(doctype_slug)
     if not doctype:
         raise ValueError(f"Unknown document type: {doctype_slug}")
@@ -520,31 +638,39 @@ def list_documents(doctype_slug: str, filters: dict = None, limit: int = 50, off
 
     search_where, search_params = _search_clause(db, doctype, doctype_slug, search, search_fields)
 
-    # If both from and to are set, the dict can only hold one constraint per key
-    # Fall through to a raw SQL query for that case
+    order_clause = _order_clause(order_by, order)
+
+    # get_all handles only pure-equality filters (no OFFSET, no free-text OR-group,
+    # no whitelisted operator/NULL forms), so drop to raw SQL whenever any of those
+    # is in play. An operator filter shows up as a list/tuple value in db_filters.
+    has_op_filter = any(isinstance(v, (list, tuple)) for v in db_filters.values())
+
     if date_field and from_date and to_date:
-        return _list_with_date_range(
+        # Both bounds set: the dict can only hold one constraint per key, so this
+        # path adds both date conditions explicitly.
+        rows = _list_with_date_range(
             db, doctype, doctype_slug, db_filters, date_field, from_date, to_date, limit, offset,
             extra_where=search_where, extra_params=search_params,
         )
-
-    order_clause = _order_clause(order_by, order)
-
-    # get_all can't express OFFSET or a free-text OR-group, so drop to raw SQL
-    # whenever either is in play.
-    if offset or search_where:
-        return _list_with_offset(db, doctype, doctype_slug, db_filters, limit, offset, order_clause,
+    elif offset or search_where or has_op_filter:
+        rows = _list_with_offset(db, doctype, doctype_slug, db_filters, limit, offset, order_clause,
                                  extra_where=search_where, extra_params=search_params)
+    else:
+        rows = db.get_all(
+            doctype,
+            filters=db_filters if db_filters else None,
+            fields=["*"],
+            order_by=order_clause,
+            limit=limit,
+        )
+        rows = _attach_children(db, doctype_slug, rows)
 
-    rows = db.get_all(
-        doctype,
-        filters=db_filters if db_filters else None,
-        fields=["*"],
-        order_by=order_clause,
-        limit=limit,
-    )
-
-    return _attach_children(db, doctype_slug, rows)
+    # `fields` projection: keep only the requested real columns (+ name) to trim
+    # the payload — child tables (never selected here) drop out automatically.
+    if fields:
+        keep = _projection_columns(doctype_slug, fields)
+        rows = [{k: v for k, v in row.items() if k in keep} for row in rows]
+    return rows
 
 
 def count_documents(doctype_slug: str, filters: dict = None, include_discarded: bool = False) -> int:
@@ -588,14 +714,9 @@ def count_documents(doctype_slug: str, filters: dict = None, include_discarded:
     if date_field and to_date:
         where_parts.append(f'"{date_field}" <= ?')
         params.append(to_date)
-    for k, v in db_filters.items():
-        if isinstance(v, (list, tuple)) and len(v) == 2:
-            op, val = v
-            where_parts.append(f'"{k}" {op} ?')
-            params.append(val)
-        else:
-            where_parts.append(f'"{k}" = ?')
-            params.append(v)
+    fparts, fparams = _where_from_filters(db_filters)
+    where_parts.extend(fparts)
+    params.extend(fparams)
 
     search_where, search_params = _search_clause(db, doctype, doctype_slug, search, search_fields)
     if search_where:
@@ -639,12 +760,8 @@ def _filter_where(db, doctype: str, doctype_slug: str, filters: dict, include_di
         where_parts.append(f'"{date_field}" >= ?'); params.append(from_date)
     if date_field and to_date:
         where_parts.append(f'"{date_field}" <= ?'); params.append(to_date)
-    for k, v in db_filters.items():
-        if isinstance(v, (list, tuple)) and len(v) == 2:
-            op, val = v
-            where_parts.append(f'"{k}" {op} ?'); params.append(val)
-        else:
-            where_parts.append(f'"{k}" = ?'); params.append(v)
+    fparts, fparams = _where_from_filters(db_filters)
+    where_parts.extend(fparts); params.extend(fparams)
     search_where, search_params = _search_clause(db, doctype, doctype_slug, search, search_fields)
     if search_where:
         where_parts.append(search_where)
@@ -692,16 +809,7 @@ def adjacent_documents(doctype_slug: str, name: str, filters: dict = None,
 
 def _list_with_offset(db, doctype, doctype_slug, db_filters, limit, offset, order_clause="creation DESC",
                       extra_where=None, extra_params=None):
-    where_parts = []
-    params = []
-    for k, v in db_filters.items():
-        if isinstance(v, (list, tuple)) and len(v) == 2:
-            op, val = v
-            where_parts.append(f'"{k}" {op} ?')
-            params.append(val)
-        else:
-            where_parts.append(f'"{k}" = ?')
-            params.append(v)
+    where_parts, params = _where_from_filters(db_filters)
     if extra_where:
         where_parts.append(extra_where)
         params.extend(extra_params or [])
@@ -740,14 +848,9 @@ def _list_with_date_range(db, doctype, doctype_slug, extra_filters, date_field,
     """List documents when both from_date and to_date are set."""
     where_parts = [f'"{date_field}" >= ?', f'"{date_field}" <= ?']
     params = [from_date, to_date]
-    for k, v in extra_filters.items():
-        if isinstance(v, (list, tuple)) and len(v) == 2:
-            op, val = v
-            where_parts.append(f'"{k}" {op} ?')
-            params.append(val)
-        else:
-            where_parts.append(f'"{k}" = ?')
-            params.append(v)
+    fparts, fparams = _where_from_filters(extra_filters)
+    where_parts.extend(fparts)
+    params.extend(fparams)
     if extra_where:
         where_parts.append(extra_where)
         params.extend(extra_params or [])

{lambda_erp-0.6.13 → lambda_erp-0.6.14}/pyproject.toml

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