lambda-erp 0.1.4__tar.gz → 0.1.6__tar.gz

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-erp
-Version: 0.1.4
+Version: 0.1.6
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: MIT
@@ -20,6 +20,8 @@ Requires-Dist: python-jose[cryptography]>=3.3
 Requires-Dist: python-multipart>=0.0.9
 Requires-Dist: uvicorn[standard]>=0.30
 Requires-Dist: weasyprint>=62.0
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.1; extra == 'postgres'
 Description-Content-Type: text/markdown
 
 # Lambda ERP

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/api/auth.py

@@ -196,7 +196,7 @@ def get_current_user(request: Request) -> dict:
 
     # Fall back to public manager (demo mode)
     db = get_db()
-    pub = db.sql('SELECT name, email, full_name, role, enabled FROM "User" WHERE role = "public_manager" AND enabled = 1')
+    pub = db.sql('SELECT name, email, full_name, role, enabled FROM "User" WHERE role = \'public_manager\' AND enabled = 1')
     if pub:
         return dict(pub[0])
 
@@ -373,7 +373,7 @@ def change_role(user_name: str, data: ChangeRoleRequest, user: dict = Depends(re
         raise HTTPException(status_code=404, detail="User not found")
 
     if user_name == user["name"] and data.role != "admin":
-        admin_count = db.sql('SELECT COUNT(*) as cnt FROM "User" WHERE role = "admin" AND enabled = 1')[0]["cnt"]
+        admin_count = db.sql('SELECT COUNT(*) as cnt FROM "User" WHERE role = \'admin\' AND enabled = 1')[0]["cnt"]
         if admin_count <= 1:
             raise HTTPException(status_code=409, detail="Cannot demote the only admin")
 
@@ -414,7 +414,7 @@ def create_public_manager(user: dict = Depends(require_admin)):
     turned on.
     """
     db = get_db()
-    existing = db.sql('SELECT name, enabled FROM "User" WHERE role = "public_manager"')
+    existing = db.sql('SELECT name, enabled FROM "User" WHERE role = \'public_manager\'')
     if existing:
         if not existing[0]["enabled"]:
             db.set_value("User", existing[0]["name"], {"enabled": 1, "modified": now()})
@@ -453,7 +453,7 @@ def create_public_manager(user: dict = Depends(require_admin)):
 def remove_public_manager(user: dict = Depends(require_admin)):
     """Disable the public manager account."""
     db = get_db()
-    existing = db.sql('SELECT name FROM "User" WHERE role = "public_manager"')
+    existing = db.sql('SELECT name FROM "User" WHERE role = \'public_manager\'')
     if not existing:
         return {"ok": True, "status": "not_found"}
     db.set_value("User", existing[0]["name"], {"enabled": 0, "modified": now()})
@@ -464,7 +464,7 @@ def remove_public_manager(user: dict = Depends(require_admin)):
 def get_public_manager_status():
     """Public: check if a public manager exists and is enabled."""
     db = get_db()
-    existing = db.sql('SELECT name, full_name, role, enabled FROM "User" WHERE role = "public_manager" AND enabled = 1')
+    existing = db.sql('SELECT name, full_name, role, enabled FROM "User" WHERE role = \'public_manager\' AND enabled = 1')
     if existing:
         return {"active": True, "user": dict(existing[0])}
     return {"active": False}

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/api/bootstrap.py

@@ -293,7 +293,7 @@ def _ensure_top_customer_snapshots(db) -> None:
                SUM(net_total) AS revenue,
                COUNT(*) AS invoice_count
         FROM "Sales Invoice"
-        WHERE docstatus = 1 AND IFNULL(is_return, 0) = 0
+        WHERE docstatus = 1 AND COALESCE(is_return, 0) = 0
         GROUP BY customer, customer_name
         ORDER BY revenue DESC
         LIMIT 3
@@ -325,7 +325,7 @@ def _ensure_top_customer_snapshots(db) -> None:
             """
             SELECT name, posting_date
             FROM "Sales Invoice"
-            WHERE docstatus = 1 AND IFNULL(is_return, 0) = 0 AND customer = ?
+            WHERE docstatus = 1 AND COALESCE(is_return, 0) = 0 AND customer = ?
             ORDER BY posting_date DESC, name DESC
             LIMIT 1
             """,
@@ -477,7 +477,7 @@ def _format_qty(value) -> str:
 
 def _public_manager_user(db) -> dict | None:
     rows = db.sql(
-        'SELECT name, role FROM "User" WHERE role = "public_manager" LIMIT 1'
+        'SELECT name, role FROM "User" WHERE role = \'public_manager\' LIMIT 1'
     )
     if not rows:
         return None

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/api/chat.py

@@ -297,7 +297,7 @@ def count_assistant_messages(session_id: str) -> int:
     """Count assistant messages in a session (used to decide when to generate title)."""
     db = get_db()
     rows = db.sql(
-        'SELECT COUNT(*) as cnt FROM "Chat Message" WHERE session_id = ? AND role = "assistant" AND message_type = "chat"',
+        'SELECT COUNT(*) as cnt FROM "Chat Message" WHERE session_id = ? AND role = \'assistant\' AND message_type = \'chat\'',
         [session_id],
     )
     return rows[0]["cnt"] if rows else 0
@@ -385,7 +385,7 @@ def load_demo_history(session_id: str) -> list[dict]:
     db = get_db()
     rows = db.sql(
         'SELECT role, content, created_at FROM "Chat Message" '
-        'WHERE session_id = ? AND message_type = "demo" ORDER BY id',
+        'WHERE session_id = ? AND message_type = \'demo\' ORDER BY id',
         [session_id],
     )
     return [dict(r) for r in rows]
@@ -1172,7 +1172,7 @@ def _handle_retrieve_chat_history(args, session_id=None):
             params.append(date_to)
         rows = db.sql(
             f'SELECT role, content, created_at FROM "Chat Message" '
-            f'WHERE role IN ("user", "assistant") {session_clause} {date_clause} '
+            f'WHERE role IN (\'user\', \'assistant\') {session_clause} {date_clause} '
             f'ORDER BY id ASC LIMIT 50',
             params,
         )
@@ -1180,7 +1180,7 @@ def _handle_retrieve_chat_history(args, session_id=None):
         num = min(int(args.get("num_messages", 20)), 50)
         rows = db.sql(
             f'SELECT role, content, created_at FROM "Chat Message" '
-            f'WHERE role IN ("user", "assistant") {session_clause} '
+            f'WHERE role IN (\'user\', \'assistant\') {session_clause} '
             f'ORDER BY id DESC LIMIT ?',
             session_params + [num],
         )
@@ -2624,7 +2624,7 @@ async def chat_websocket(
                 # (non-demo) user/assistant messages.
                 non_demo_rows = get_db().sql(
                     'SELECT COUNT(*) as cnt FROM "Chat Message" '
-                    'WHERE session_id = ? AND message_type != "demo"',
+                    'WHERE session_id = ? AND message_type != \'demo\'',
                     [session_id],
                 )
                 if non_demo_rows and non_demo_rows[0]["cnt"] > 0:
@@ -2643,7 +2643,7 @@ async def chat_websocket(
                 db = get_db()
                 db.sql(
                     'DELETE FROM "Chat Message" '
-                    'WHERE session_id = ? AND message_type = "demo"',
+                    'WHERE session_id = ? AND message_type = \'demo\'',
                     [session_id],
                 )
                 db.conn.commit()

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/api/demo_limits.py

@@ -80,7 +80,8 @@ def init_schema() -> None:
         if _schema_ready:
             return
         db = get_db()
-        db.conn.execute(_SCHEMA_SQL)
+        # _ddl() maps the SQLite DDL (AUTOINCREMENT, REAL) to the active dialect.
+        db.conn.execute(db._ddl(_SCHEMA_SQL))
         db.conn.execute(_INDEX_TS_SQL)
         db.conn.execute(_INDEX_IP_TS_SQL)
         db.conn.commit()

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/api/main.py

@@ -121,7 +121,7 @@ async def ws_chat(websocket: WebSocket):
 
     # Fall back to public manager
     if not user:
-        pub = db.sql('SELECT name, full_name, role, enabled FROM "User" WHERE role = "public_manager" AND enabled = 1')
+        pub = db.sql('SELECT name, full_name, role, enabled FROM "User" WHERE role = \'public_manager\' AND enabled = 1')
         user = pub[0] if pub else None
 
     if not user:

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/api/pdf.py

@@ -127,7 +127,7 @@ def generate_pdf(doctype_slug: str, name: str) -> bytes:
     taxes = doc.get("taxes", [])
 
     # Page size setting
-    page_size_row = db.sql('SELECT value FROM "Settings" WHERE key = "pdf_page_size"')
+    page_size_row = db.sql('SELECT value FROM "Settings" WHERE key = \'pdf_page_size\'')
     page_size = page_size_row[0]["value"] if page_size_row else "A4"
 
     # Render

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/api/routers/analytics.py

@@ -28,10 +28,14 @@ _viewer = Depends(require_role("viewer"))
 # Legacy preset analytics
 # ---------------------------------------------------------------------------
 
+# Dates are stored as ISO text ('YYYY-MM-DD'), so substr-based bucketing is both
+# exact and portable across SQLite and Postgres — avoids SQLite-only strftime().
+# (Integer division (month+2)/3 -> quarter is integer in both dialects; the
+# parens guard SQLite's quirk where || binds tighter than /.)
 _TIME_BUCKETS = {
-    "month": "strftime('%Y-%m', {date_col})",
-    "quarter": "strftime('%Y-Q', {date_col}) || ((CAST(strftime('%m', {date_col}) AS INTEGER) + 2) / 3)",
-    "year": "strftime('%Y', {date_col})",
+    "month": "substr({date_col}, 1, 7)",
+    "quarter": "substr({date_col}, 1, 4) || '-Q' || ((CAST(substr({date_col}, 6, 2) AS INTEGER) + 2) / 3)",
+    "year": "substr({date_col}, 1, 4)",
 }
 
 

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/api/routers/masters.py

@@ -67,15 +67,15 @@ DELETE_REFERENCE_CHECKS = {
         ('SELECT 1 FROM "Sales Invoice" WHERE customer = ? LIMIT 1', "sales invoice"),
         ('SELECT 1 FROM "Delivery Note" WHERE customer = ? LIMIT 1', "delivery note"),
         ('SELECT 1 FROM "POS Invoice" WHERE customer = ? LIMIT 1', "POS invoice"),
-        ('SELECT 1 FROM "Payment Entry" WHERE party_type = "Customer" AND party = ? LIMIT 1', "payment entry"),
-        ('SELECT 1 FROM "Subscription" WHERE party_type = "Customer" AND party = ? LIMIT 1', "subscription"),
+        ('SELECT 1 FROM "Payment Entry" WHERE party_type = \'Customer\' AND party = ? LIMIT 1', "payment entry"),
+        ('SELECT 1 FROM "Subscription" WHERE party_type = \'Customer\' AND party = ? LIMIT 1', "subscription"),
     ],
     "supplier": [
         ('SELECT 1 FROM "Purchase Order" WHERE supplier = ? LIMIT 1', "purchase order"),
         ('SELECT 1 FROM "Purchase Invoice" WHERE supplier = ? LIMIT 1', "purchase invoice"),
         ('SELECT 1 FROM "Purchase Receipt" WHERE supplier = ? LIMIT 1', "purchase receipt"),
-        ('SELECT 1 FROM "Payment Entry" WHERE party_type = "Supplier" AND party = ? LIMIT 1', "payment entry"),
-        ('SELECT 1 FROM "Subscription" WHERE party_type = "Supplier" AND party = ? LIMIT 1', "subscription"),
+        ('SELECT 1 FROM "Payment Entry" WHERE party_type = \'Supplier\' AND party = ? LIMIT 1', "payment entry"),
+        ('SELECT 1 FROM "Subscription" WHERE party_type = \'Supplier\' AND party = ? LIMIT 1', "subscription"),
     ],
     "item": [
         ('SELECT 1 FROM "Quotation Item" WHERE item_code = ? LIMIT 1', "quotation item"),

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/lambda_erp/database.py

@@ -37,6 +37,121 @@ def _journal_mode() -> str:
     return mode if mode in _VALID_JOURNAL_MODES else "WAL"
 
 
+def _is_postgres_dsn(db_path) -> bool:
+    """A db_path that looks like a Postgres connection URL selects Postgres;
+    anything else (a file path or ':memory:') stays on SQLite. This is how
+    LAMBDA_ERP_DB doubles as the backend switch — no separate env var."""
+    return isinstance(db_path, str) and db_path.startswith(("postgresql://", "postgres://"))
+
+
+# ---------------------------------------------------------------------------
+# Postgres adapter
+#
+# The whole codebase was written against sqlite3: `?` placeholders,
+# `conn.execute(sql, params) -> cursor`, and `sqlite3.Row` rows that support
+# BOTH positional (row[0]) and mapping (row["x"], dict(row)) access. Rather
+# than rewrite every call site, we make a psycopg connection quack like that:
+#   * _PgConn translates `?`->`%s` and forwards execute/executemany/commit/...
+#   * _PgRow mirrors sqlite3.Row's dual access so get_value/sql/migrations and
+#     the external `db.conn.execute(...)` users keep working untouched.
+# ---------------------------------------------------------------------------
+
+class _PgRow:
+    """Row that mimics sqlite3.Row: positional and by-name access, dict(row),
+    and tuple(row) -> values."""
+
+    __slots__ = ("_cols", "_vals")
+
+    def __init__(self, cols, vals):
+        self._cols = cols
+        self._vals = vals
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return self._vals[key]
+        return self._vals[self._cols.index(key)]
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except (KeyError, ValueError, IndexError):
+            return default
+
+    def keys(self):
+        return list(self._cols)
+
+    def __iter__(self):
+        return iter(self._vals)  # tuple(row) -> values, like sqlite3.Row
+
+    def __len__(self):
+        return len(self._vals)
+
+
+def _pg_row_factory(cursor):
+    cols = [c.name for c in (cursor.description or [])]
+
+    def make(values):
+        return _PgRow(cols, values)
+
+    return make
+
+
+class _PgConn:
+    """Adapts a psycopg (v3) connection to the sqlite3 connection API the code
+    uses. autocommit is off so the existing `_in_transaction` + single commit()
+    / rollback() flow gives the same atomicity as SQLite's implicit transaction."""
+
+    def __init__(self, raw):
+        self._raw = raw
+
+    def execute(self, sql, params=None):
+        try:
+            cur = self._raw.cursor()
+            if params:
+                # psycopg does %-substitution when params are given, so a literal
+                # % must be doubled. No params -> psycopg leaves the SQL
+                # untouched, so literal % is already safe and needs no escaping.
+                cur.execute(sql.replace("%", "%%").replace("?", "%s"), list(params))
+            else:
+                cur.execute(sql.replace("?", "%s"))
+            return cur
+        except Exception:
+            # A failed statement leaves the connection in an aborted transaction
+            # (autocommit=False); every later query on this pooled/thread-local
+            # connection would then fail with InFailedSqlTransaction. Roll back
+            # so the connection stays usable, then re-raise the real error.
+            self._safe_rollback()
+            raise
+
+    def executemany(self, sql, seq_params):
+        try:
+            cur = self._raw.cursor()
+            cur.executemany(sql.replace("%", "%%").replace("?", "%s"),
+                            [list(p) for p in seq_params])
+            return cur
+        except Exception:
+            self._safe_rollback()
+            raise
+
+    def _safe_rollback(self):
+        try:
+            self._raw.rollback()
+        except Exception:
+            pass
+
+    def commit(self):
+        self._raw.commit()
+
+    def rollback(self):
+        self._raw.rollback()
+
+    def close(self):
+        self._raw.close()
+
+    def cursor(self, *args, **kwargs):
+        return self._raw.cursor(*args, **kwargs)
+
+
 class _NullLock:
     """No-op context manager used when SQLite-level locking is sufficient."""
 
@@ -59,8 +174,11 @@ class Database:
         #   is a separate empty database, so we keep one shared connection
         #   guarded by a Python lock.
         self.db_path = db_path
+        self.dialect = "postgres" if _is_postgres_dsn(db_path) else "sqlite"
+        # :memory: is a SQLite-only concept (Postgres is always a server).
         self._is_memory = (db_path == ":memory:")
         self._local = threading.local()
+        self._col_cache = {}  # doctype -> set(columns); invalidated on ALTER
         if self._is_memory:
             self._lock = threading.Lock()
             self._shared_conn = self._open_conn()
@@ -74,12 +192,20 @@ class Database:
         self._setup_schema()
 
     def _open_conn(self):
-        """Open a new sqlite connection with the same per-conn settings.
+        """Open a new connection (per-backend) with the same per-conn settings.
 
-        For file DBs the connection is stored on thread-local state so the
-        same thread reuses it; for :memory: it is returned and held as the
-        shared connection.
+        For file/Postgres DBs the connection is stored on thread-local state so
+        the same thread reuses it; for :memory: it is returned and held as the
+        shared connection. Returns the object the `conn` property hands out:
+        the raw sqlite3 connection, or a _PgConn wrapper for Postgres.
         """
+        conn = self._open_pg_conn() if self.dialect == "postgres" else self._open_sqlite_conn()
+        if not self._is_memory:
+            self._local.conn = conn
+            self._local.in_transaction = False
+        return conn
+
+    def _open_sqlite_conn(self):
         conn = sqlite3.connect(self.db_path, check_same_thread=False)
         conn.row_factory = sqlite3.Row
         conn.execute(f"PRAGMA journal_mode={_journal_mode()}")
@@ -88,11 +214,19 @@ class Database:
         # another thread is mid-write. Generous for our workload (LLM calls
         # dwarf any DB write).
         conn.execute("PRAGMA busy_timeout=5000")
-        if not self._is_memory:
-            self._local.conn = conn
-            self._local.in_transaction = False
         return conn
 
+    def _open_pg_conn(self):
+        # psycopg is only needed for the Postgres backend; import lazily so a
+        # SQLite-only install (tests, local dev) doesn't require the driver.
+        import psycopg
+
+        # autocommit off: matches SQLite's implicit transaction so the existing
+        # _in_transaction + commit()/rollback() atomicity (GL submit/cancel) is
+        # preserved exactly.
+        return _PgConn(psycopg.connect(self.db_path, autocommit=False,
+                                       row_factory=_pg_row_factory))
+
     @property
     def conn(self):
         if self._is_memory:
@@ -1106,10 +1240,27 @@ class Database:
         ]
 
         for stmt in stmts:
-            self.conn.execute(stmt)
+            self.conn.execute(self._ddl(stmt))
         self.conn.commit()
         self._migrate()
 
+    def _ddl(self, stmt: str) -> str:
+        """Translate SQLite DDL to the active dialect. No-op for SQLite.
+
+        For Postgres: SQLite's `REAL` is 8-byte (double); Postgres `REAL` is
+        only 4-byte, so map to DOUBLE PRECISION to keep float arithmetic
+        identical (the validation suite's balances depend on it). And
+        `INTEGER PRIMARY KEY AUTOINCREMENT` becomes BIGSERIAL.
+        """
+        if self.dialect != "postgres":
+            return stmt
+        import re
+        stmt = re.sub(r"\bINTEGER\s+PRIMARY\s+KEY\s+AUTOINCREMENT\b",
+                      "BIGSERIAL PRIMARY KEY", stmt, flags=re.IGNORECASE)
+        stmt = re.sub(r"\bAUTOINCREMENT\b", "", stmt, flags=re.IGNORECASE)
+        stmt = re.sub(r"\bREAL\b", "DOUBLE PRECISION", stmt, flags=re.IGNORECASE)
+        return stmt
+
     # -----------------------------------------------------------------
     # Migrations
     #
@@ -1125,9 +1276,9 @@ class Database:
     MIGRATIONS = None  # populated just below __init_subclass__ — see end of class
 
     def _add_column_if_missing(self, table: str, column: str, definition: str) -> None:
-        cols = {row[1] for row in self.conn.execute(f'PRAGMA table_info("{table}")').fetchall()}
-        if column not in cols:
-            self.conn.execute(f'ALTER TABLE "{table}" ADD COLUMN {column} {definition}')
+        if column not in self._get_table_columns(table):
+            self.conn.execute(self._ddl(f'ALTER TABLE "{table}" ADD COLUMN {column} {definition}'))
+            self._col_cache.pop(table, None)
 
     def _migrate(self):
         """Run each pending migration in order, tracking applied versions."""
@@ -1191,7 +1342,7 @@ class Database:
             fieldname = "name"
 
         fields = fieldname if isinstance(fieldname, (list, tuple)) else [fieldname]
-        field_str = ", ".join(f'"{f}"' for f in fields)
+        field_str = self._select_fields(doctype, fields)
 
         if isinstance(name, dict) or filters:
             filt = name if isinstance(name, dict) else (filters or {})
@@ -1224,7 +1375,7 @@ class Database:
         if fields == ["*"]:
             field_str = "*"
         else:
-            field_str = ", ".join(f'"{f}"' for f in fields)
+            field_str = self._select_fields(doctype, fields)
         query = f'SELECT {field_str} FROM "{doctype}"'
 
         params = []
@@ -1278,9 +1429,30 @@ class Database:
         return bool(rows)
 
     def _get_table_columns(self, doctype):
-        """Get column names for a table."""
-        cursor = self.conn.execute(f'PRAGMA table_info("{doctype}")')
-        return {row[1] for row in cursor.fetchall()}
+        """Get column names for a table (cached; invalidated on ALTER)."""
+        cached = self._col_cache.get(doctype)
+        if cached is not None:
+            return cached
+        if self.dialect == "postgres":
+            rows = self.conn.execute(
+                "SELECT column_name FROM information_schema.columns WHERE table_name = ?",
+                [doctype],
+            ).fetchall()
+            cols = {row[0] for row in rows}
+        else:
+            cursor = self.conn.execute(f'PRAGMA table_info("{doctype}")')
+            cols = {row[1] for row in cursor.fetchall()}
+        self._col_cache[doctype] = cols
+        return cols
+
+    def _select_fields(self, doctype, fields):
+        """Build the SELECT column list, selecting only columns that exist and
+        padding the rest as NULL. SQLite silently returns an unknown quoted
+        identifier as a string literal; Postgres errors. Padding missing fields
+        as NULL gives portable behaviour (None for absent columns) and supports
+        the cross-doctype field lists the codebase relies on."""
+        valid = self._get_table_columns(doctype)
+        return ", ".join(f'"{f}"' if f in valid else f'NULL AS "{f}"' for f in fields)
 
     def insert(self, doctype, doc):
         """Insert a record from a dict. Ignores fields not in the table schema."""

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/lambda_erp/utils.py

@@ -140,7 +140,17 @@ def new_name(prefix, sequence_store={}):
         try:
             db = get_db()
             # Search all tables for names matching this prefix pattern
-            tables = db.sql("SELECT name FROM sqlite_master WHERE type='table'")
+            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]

{lambda_erp-0.1.4 → lambda_erp-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "0.1.4"
+version = "0.1.6"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "MIT"
@@ -23,6 +23,12 @@ dependencies = [
     "holidays>=0.40",
 ]
 
+# Postgres backend is opt-in: `pip install lambda-erp[postgres]`. SQLite (the
+# default, used by tests and local dev) needs no extra driver. Select Postgres
+# at runtime by setting LAMBDA_ERP_DB to a postgresql:// connection URL.
+[project.optional-dependencies]
+postgres = ["psycopg[binary]>=3.1"]
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"