lambda-erp 0.1.0__py3-none-any.whl

lambda_erp/stock/stock_entry.py

@@ -0,0 +1,330 @@
+"""
+Stock Entry - Material movements.
+
+Stock Entry handles all material movements:
+- Material Receipt: goods coming INTO a warehouse (no source)
+- Material Issue: goods going OUT of a warehouse (no target)
+- Material Transfer: goods moving between warehouses
+
+Each type creates Stock Ledger Entries (SLEs) and optionally
+GL entries for perpetual inventory.
+"""
+
+from lambda_erp.model import Document
+from lambda_erp.utils import _dict, flt, nowdate
+from lambda_erp.database import get_db
+from lambda_erp.stock.stock_ledger import make_sl_entries
+from lambda_erp.accounting.general_ledger import make_gl_entries, make_reverse_gl_entries
+from lambda_erp.exceptions import ValidationError
+
+class StockEntry(Document):
+    DOCTYPE = "Stock Entry"
+    CHILD_TABLES = {
+        "items": ("Stock Entry Detail", None),
+    }
+    PREFIX = "STE"
+
+    LINK_FIELDS = {
+        "company": "Company",
+        "from_warehouse": "Warehouse",
+        "to_warehouse": "Warehouse",
+    }
+    CHILD_LINK_FIELDS = {
+        "items": {
+            "item_code": "Item",
+            "s_warehouse": "Warehouse",
+            "t_warehouse": "Warehouse",
+        },
+    }
+
+    def validate(self):
+        if not self.stock_entry_type:
+            raise ValidationError(
+                "Stock Entry Type is required (Material Receipt, Material Issue, Material Transfer)"
+            )
+        if not self.get("items"):
+            raise ValidationError("At least one item is required")
+        if not self.posting_date:
+            self.posting_date = nowdate()
+
+        self._validate_warehouses()
+        self._set_item_defaults()
+        self._calculate_totals()
+
+    def _validate_warehouses(self):
+        """Validate source/target warehouses based on entry type."""
+        for item in self.get("items"):
+            if self.stock_entry_type in ("Material Receipt", "Opening Stock"):
+                if not item.get("t_warehouse"):
+                    item["t_warehouse"] = self.to_warehouse
+                if not item.get("t_warehouse"):
+                    raise ValidationError(
+                        f"Target Warehouse is required for {self.stock_entry_type} (Item: {item.get('item_code')})"
+                    )
+            elif self.stock_entry_type == "Material Issue":
+                if not item.get("s_warehouse"):
+                    item["s_warehouse"] = self.from_warehouse
+                if not item.get("s_warehouse"):
+                    raise ValidationError(
+                        f"Source Warehouse is required for Material Issue (Item: {item.get('item_code')})"
+                    )
+            elif self.stock_entry_type == "Material Transfer":
+                if not item.get("s_warehouse"):
+                    item["s_warehouse"] = self.from_warehouse
+                if not item.get("t_warehouse"):
+                    item["t_warehouse"] = self.to_warehouse
+                if not item.get("s_warehouse") or not item.get("t_warehouse"):
+                    raise ValidationError(
+                        f"Both Source and Target Warehouse required for Transfer (Item: {item.get('item_code')})"
+                    )
+
+    def _set_item_defaults(self):
+        db = get_db()
+        for item in self.get("items"):
+            if item.get("item_code") and not item.get("item_name"):
+                item_data = db.get_value(
+                    "Item", item["item_code"], ["item_name", "stock_uom", "standard_rate"]
+                )
+                if item_data:
+                    item["item_name"] = item_data.item_name
+                    item["uom"] = item.get("uom") or item_data.stock_uom
+
+    def _calculate_totals(self):
+        """Calculate total values for the stock entry."""
+        total_incoming = 0
+        total_outgoing = 0
+        total_amount = 0
+
+        for item in self.get("items"):
+            qty = flt(item.get("qty", 0))
+            rate = flt(item.get("basic_rate", 0))
+            item["basic_amount"] = flt(qty * rate, 2)
+            item["amount"] = item["basic_amount"]
+
+            if item.get("t_warehouse"):
+                total_incoming += item["basic_amount"]
+            if item.get("s_warehouse"):
+                total_outgoing += item["basic_amount"]
+            total_amount += item["basic_amount"]
+
+        self._data["total_incoming_value"] = flt(total_incoming, 2)
+        self._data["total_outgoing_value"] = flt(total_outgoing, 2)
+        self._data["value_difference"] = flt(total_incoming - total_outgoing, 2)
+        self._data["total_amount"] = flt(total_amount, 2)
+
+    def on_submit(self):
+        """Create Stock Ledger Entries and GL entries.
+
+        - update_stock_ledger() -> make_sl_entries()
+        - make_gl_entries() (for perpetual inventory)
+        """
+        sl_entries = self._get_sl_entries()
+        make_sl_entries(sl_entries)
+
+        # GL entries for perpetual inventory
+        gl_entries = self._get_gl_entries()
+        if gl_entries:
+            make_gl_entries(gl_entries)
+
+    def on_cancel(self):
+        """Reverse SLEs and GL entries."""
+        # Reverse SLEs by creating negative entries
+        sl_entries = self._get_sl_entries()
+        for sle in sl_entries:
+            sle["actual_qty"] = -flt(sle["actual_qty"])
+            # Swap incoming/outgoing rates
+            incoming = sle.get("incoming_rate", 0)
+            outgoing = sle.get("outgoing_rate", 0)
+            sle["incoming_rate"] = outgoing
+            sle["outgoing_rate"] = incoming
+        make_sl_entries(sl_entries, allow_negative_stock=True)
+
+        # Reverse GL entries
+        make_reverse_gl_entries(
+            voucher_type=self.DOCTYPE,
+            voucher_no=self.name,
+        )
+
+    def _get_sl_entries(self):
+        """Build Stock Ledger Entry list.
+
+        For Material Transfer, each item creates TWO SLEs:
+        1. Negative from source warehouse
+        2. Positive to target warehouse
+        """
+        sl_entries = []
+
+        for item in self.get("items"):
+            # Outgoing (from source warehouse)
+            if item.get("s_warehouse"):
+                sl_entries.append(
+                    _dict(
+                        item_code=item["item_code"],
+                        warehouse=item["s_warehouse"],
+                        actual_qty=-flt(item["qty"]),
+                        outgoing_rate=flt(item.get("basic_rate") or item.get("valuation_rate", 0)),
+                        incoming_rate=0,
+                        voucher_type=self.DOCTYPE,
+                        voucher_no=self.name,
+                        voucher_detail_no=item.get("name"),
+                        posting_date=self.posting_date,
+                        posting_time=self.posting_time or "00:00:00",
+                        company=self.company,
+                    )
+                )
+
+            # Incoming (to target warehouse)
+            if item.get("t_warehouse"):
+                sl_entries.append(
+                    _dict(
+                        item_code=item["item_code"],
+                        warehouse=item["t_warehouse"],
+                        actual_qty=flt(item["qty"]),
+                        incoming_rate=flt(item.get("basic_rate") or item.get("valuation_rate", 0)),
+                        outgoing_rate=0,
+                        voucher_type=self.DOCTYPE,
+                        voucher_no=self.name,
+                        voucher_detail_no=item.get("name"),
+                        posting_date=self.posting_date,
+                        posting_time=self.posting_time or "00:00:00",
+                        company=self.company,
+                    )
+                )
+
+        return sl_entries
+
+    def _get_gl_entries(self):
+        """Build GL entries for perpetual inventory.
+
+        In perpetual inventory, stock movements also create accounting entries:
+        - Opening Stock:   Debit Stock In Hand, Credit Opening Balance Equity
+                           (one-time seed of inventory at company setup)
+        - Material Receipt: Debit Stock In Hand, Credit Stock Adjustment
+                           (manual adjustments / found stock, not supplier deliveries)
+        - Material Issue:  Debit Stock Adjustment, Credit Stock In Hand
+                           (write-offs / internal consumption)
+        - Material Transfer: No GL impact (same Stock In Hand account)
+        """
+        db = get_db()
+        if not self.company:
+            return []
+
+        gl_entries = []
+        stock_account = None
+        expense_account = None
+
+        # Get stock and expense accounts from warehouse or company defaults
+        for item in self.get("items"):
+            if item.get("t_warehouse"):
+                stock_account = (
+                    db.get_value("Warehouse", item["t_warehouse"], "account")
+                    or db.get_value("Account",
+                                    {"company": self.company, "account_type": "Stock", "is_group": 0},
+                                    "name")
+                )
+            if item.get("s_warehouse"):
+                stock_account = stock_account or (
+                    db.get_value("Warehouse", item["s_warehouse"], "account")
+                    or db.get_value("Account",
+                                    {"company": self.company, "account_type": "Stock", "is_group": 0},
+                                    "name")
+                )
+
+        if not stock_account:
+            return []  # No perpetual inventory
+
+        cost_center = db.get_value("Company", self.company, "default_cost_center")
+
+        if self.stock_entry_type == "Opening Stock":
+            # One-time seed of inventory at company setup. Contra to equity
+            # (Opening Balance Equity) so the P&L is not distorted by stock
+            # that the business had on day one but didn't "earn".
+            contra_account = db.get_value(
+                "Company", self.company, "default_opening_balance_equity"
+            )
+            if stock_account and contra_account:
+                gl_entries = [
+                    _dict(
+                        account=stock_account,
+                        debit=flt(self.total_incoming_value, 2),
+                        debit_in_account_currency=flt(self.total_incoming_value, 2),
+                        credit=0, credit_in_account_currency=0,
+                        cost_center=cost_center,
+                        voucher_type=self.DOCTYPE, voucher_no=self.name,
+                        posting_date=self.posting_date, company=self.company,
+                        remarks=f"Opening stock via {self.name}",
+                    ),
+                    _dict(
+                        account=contra_account,
+                        credit=flt(self.total_incoming_value, 2),
+                        credit_in_account_currency=flt(self.total_incoming_value, 2),
+                        debit=0, debit_in_account_currency=0,
+                        cost_center=cost_center,
+                        voucher_type=self.DOCTYPE, voucher_no=self.name,
+                        posting_date=self.posting_date, company=self.company,
+                        remarks=f"Opening stock via {self.name}",
+                    ),
+                ]
+
+        elif self.stock_entry_type == "Material Receipt":
+            # Manual inventory receipts (adjustments, found stock). Contra to
+            # Stock Adjustment (expense). For opening balances use the
+            # dedicated "Opening Stock" type above instead.
+            contra_account = db.get_value("Company", self.company, "stock_adjustment_account")
+            if stock_account and contra_account:
+                gl_entries = [
+                    _dict(
+                        account=stock_account,
+                        debit=flt(self.total_incoming_value, 2),
+                        debit_in_account_currency=flt(self.total_incoming_value, 2),
+                        credit=0, credit_in_account_currency=0,
+                        cost_center=cost_center,
+                        voucher_type=self.DOCTYPE, voucher_no=self.name,
+                        posting_date=self.posting_date, company=self.company,
+                        remarks=f"Material Receipt via {self.name}",
+                    ),
+                    _dict(
+                        account=contra_account,
+                        credit=flt(self.total_incoming_value, 2),
+                        credit_in_account_currency=flt(self.total_incoming_value, 2),
+                        debit=0, debit_in_account_currency=0,
+                        cost_center=cost_center,
+                        voucher_type=self.DOCTYPE, voucher_no=self.name,
+                        posting_date=self.posting_date, company=self.company,
+                        remarks=f"Material Receipt via {self.name}",
+                    ),
+                ]
+
+        elif self.stock_entry_type == "Material Issue":
+            # Manual issues are write-offs or internal consumption, not sales.
+            # Route them to Stock Adjustment rather than COGS/default expense —
+            # COGS should only be credited/debited by documents that actually
+            # correspond to a sale (Sales Invoice, Delivery Note, POS).
+            expense_account = db.get_value("Company", self.company, "stock_adjustment_account")
+            if stock_account and expense_account:
+                gl_entries = [
+                    _dict(
+                        account=expense_account,
+                        debit=flt(self.total_outgoing_value, 2),
+                        debit_in_account_currency=flt(self.total_outgoing_value, 2),
+                        credit=0, credit_in_account_currency=0,
+                        cost_center=cost_center,
+                        voucher_type=self.DOCTYPE, voucher_no=self.name,
+                        posting_date=self.posting_date, company=self.company,
+                        remarks=f"Material Issue via {self.name}",
+                    ),
+                    _dict(
+                        account=stock_account,
+                        credit=flt(self.total_outgoing_value, 2),
+                        credit_in_account_currency=flt(self.total_outgoing_value, 2),
+                        debit=0, debit_in_account_currency=0,
+                        cost_center=cost_center,
+                        voucher_type=self.DOCTYPE, voucher_no=self.name,
+                        posting_date=self.posting_date, company=self.company,
+                        remarks=f"Material Issue via {self.name}",
+                    ),
+                ]
+
+        # Material Transfer has no GL impact (stock stays in same Stock In Hand account)
+
+        return gl_entries

lambda_erp/stock/stock_ledger.py

@@ -0,0 +1,337 @@
+"""
+Stock Ledger Entry processing.
+
+The heart of inventory management, equivalent to what general_ledger.py is
+for accounting.
+
+Every stock movement creates Stock Ledger Entries (SLEs) that track:
+- actual_qty: quantity change (+/-)
+- qty_after_transaction: running balance
+- incoming_rate / outgoing_rate: unit cost
+- valuation_rate: weighted average cost per unit
+- stock_value: total value of stock after this transaction
+
+Valuation methods supported:
+- FIFO (First In First Out)
+- Moving Average (weighted average)
+
+The flow:
+  Document.on_submit() -> StockController.make_sl_entries()
+    -> stock_ledger.make_sl_entries(sl_entries)
+      -> create SLE records
+      -> update_entries_after() (recalculate valuation)
+      -> update_bin_qty() (update Bin summary)
+"""
+
+from lambda_erp.utils import _dict, flt, new_name, now, nowdate
+from lambda_erp.database import get_db
+from lambda_erp.exceptions import NegativeStockError
+
+def make_sl_entries(sl_entries, allow_negative_stock=False):
+    """Create Stock Ledger Entries from a list of SLE dicts.
+
+    Called on every stock transaction.
+
+    Args:
+        sl_entries: list of _dict with item_code, warehouse, actual_qty,
+                   incoming_rate, voucher_type, voucher_no, etc.
+        allow_negative_stock: if False, raises NegativeStockError
+    """
+    db = get_db()
+
+    if not sl_entries:
+        return
+
+    for sle in sl_entries:
+        if not flt(sle.get("actual_qty")):
+            continue
+
+        # Create the SLE record
+        sle_doc = _dict(
+            name=new_name("SLE"),
+            posting_date=sle.get("posting_date") or nowdate(),
+            posting_time=sle.get("posting_time", "00:00:00"),
+            item_code=sle["item_code"],
+            warehouse=sle["warehouse"],
+            actual_qty=flt(sle["actual_qty"]),
+            incoming_rate=flt(sle.get("incoming_rate", 0)),
+            outgoing_rate=flt(sle.get("outgoing_rate", 0)),
+            voucher_type=sle.get("voucher_type"),
+            voucher_no=sle.get("voucher_no"),
+            voucher_detail_no=sle.get("voucher_detail_no"),
+            batch_no=sle.get("batch_no"),
+            serial_no=sle.get("serial_no"),
+            company=sle.get("company"),
+            is_cancelled=0,
+            creation=now(),
+            modified=now(),
+        )
+
+        # Calculate running balances
+        update_stock_values(sle_doc, allow_negative_stock)
+
+        # Persist
+        db.insert("Stock Ledger Entry", sle_doc)
+
+        # Update Bin (summary table)
+        update_bin(sle_doc)
+
+    db.commit()
+
+def update_stock_values(sle, allow_negative_stock=False):
+    """Calculate qty_after_transaction, valuation_rate, stock_value.
+
+    This is a simplified port of the reference implementation's update_entries_after() which
+    handles the full FIFO queue or moving average calculation.
+
+    We implement Moving Average here for simplicity, which is the most
+    common valuation method.
+    """
+    db = get_db()
+
+    # Get current stock state from Bin
+    bin_data = db.get_value(
+        "Bin",
+        {"item_code": sle["item_code"], "warehouse": sle["warehouse"]},
+        ["actual_qty", "valuation_rate", "stock_value"],
+    )
+
+    prev_qty = flt(bin_data.actual_qty) if bin_data else 0
+    prev_val_rate = flt(bin_data.valuation_rate) if bin_data else 0
+    prev_stock_value = flt(bin_data.stock_value) if bin_data else 0
+
+    new_qty = prev_qty + flt(sle["actual_qty"])
+
+    # Check for negative stock
+    if new_qty < 0 and not allow_negative_stock:
+        raise NegativeStockError(
+            f"Negative stock not allowed for Item {sle['item_code']} "
+            f"in Warehouse {sle['warehouse']}. "
+            f"Available: {prev_qty}, Requested: {abs(flt(sle['actual_qty']))}"
+        )
+
+    # Calculate valuation using Moving Average
+    # (the reference implementation also supports FIFO via a stock queue, but moving average
+    # is the simpler and more common method)
+    if flt(sle["actual_qty"]) > 0:
+        # Incoming: weighted average of existing stock + new stock.
+        # If the caller passes 0 (e.g. a customer-return delivery note), use
+        # the current moving-average so the return lands at the same cost
+        # basis the shipment went out at — symmetric with the outgoing branch.
+        incoming_rate = flt(sle.get("incoming_rate")) or prev_val_rate
+        incoming_value = flt(sle["actual_qty"]) * incoming_rate
+        new_stock_value = prev_stock_value + incoming_value
+
+        if new_qty > 0:
+            new_val_rate = new_stock_value / new_qty
+        else:
+            new_val_rate = incoming_rate
+
+        sle["incoming_rate"] = incoming_rate
+        sle["stock_value_difference"] = incoming_value
+    else:
+        # Outgoing: use current valuation rate
+        outgoing_rate = flt(sle.get("outgoing_rate")) or prev_val_rate
+        outgoing_value = abs(flt(sle["actual_qty"])) * outgoing_rate
+        new_stock_value = prev_stock_value - outgoing_value
+        new_val_rate = prev_val_rate  # doesn't change on outgoing
+
+        sle["outgoing_rate"] = outgoing_rate
+        sle["stock_value_difference"] = -outgoing_value
+
+    sle["qty_after_transaction"] = flt(new_qty)
+    sle["valuation_rate"] = flt(new_val_rate, 2)
+    sle["stock_value"] = flt(new_stock_value, 2)
+
+def update_bin(sle):
+    """Update the Bin (stock summary) table after an SLE.
+
+    The Bin table maintains current stock levels per item+warehouse.
+    It's the quick-lookup table for "how much do we have in stock?"
+    """
+    db = get_db()
+    bin_name = f"{sle['item_code']}-{sle['warehouse']}"
+
+    if db.exists("Bin", bin_name):
+        db.set_value("Bin", bin_name, {
+            "actual_qty": flt(sle["qty_after_transaction"]),
+            "valuation_rate": flt(sle["valuation_rate"]),
+            "stock_value": flt(sle["stock_value"]),
+        })
+    else:
+        db.insert("Bin", _dict(
+            name=bin_name,
+            item_code=sle["item_code"],
+            warehouse=sle["warehouse"],
+            actual_qty=flt(sle["qty_after_transaction"]),
+            valuation_rate=flt(sle["valuation_rate"]),
+            stock_value=flt(sle["stock_value"]),
+        ))
+
+def get_stock_balance(item_code, warehouse):
+    """Get current stock balance for an item in a warehouse."""
+    db = get_db()
+    bin_data = db.get_value(
+        "Bin",
+        {"item_code": item_code, "warehouse": warehouse},
+        ["actual_qty", "valuation_rate", "stock_value"],
+    )
+    if bin_data:
+        return _dict(bin_data)
+    return _dict(actual_qty=0, valuation_rate=0, stock_value=0)
+
+def get_stock_balance_all(item_code=None, warehouse=None):
+    """Get stock balances, optionally filtered by item or warehouse."""
+    db = get_db()
+    filters = {}
+    if item_code:
+        filters["item_code"] = item_code
+    if warehouse:
+        filters["warehouse"] = warehouse
+
+    return db.get_all(
+        "Bin",
+        filters=filters,
+        fields=["item_code", "warehouse", "actual_qty", "valuation_rate", "stock_value"],
+    )
+
+# ---------------------------------------------------------------------------
+# Voucher-level helpers
+#
+# Four documents all move stock and post matching GL: Delivery Note, Sales
+# Invoice (update_stock), POS Invoice (update_stock), Purchase Invoice
+# (update_stock). Before this section existed, each doc reimplemented the
+# SLE + GL boilerplate, which is how POS drifted (sell-rate SLE, no GL) and
+# needed a second fix round. These helpers are the single source of truth.
+# ---------------------------------------------------------------------------
+
+def build_sell_side_sles(doc, items):
+    """SLEs for outgoing-stock docs (DN, direct-ship SI, POS update_stock).
+
+    Negative actual_qty on a normal ship; positive on a return. Rates are
+    passed as 0 so the stock ledger uses the moving-average cost for both
+    directions — posting COGS at sell value was the original bug.
+    """
+    sl_entries = []
+    for item in items:
+        warehouse = item.get("warehouse")
+        if not warehouse or not item.get("item_code"):
+            continue
+        actual_qty = -flt(item.get("qty"))
+        sl_entries.append(_dict(
+            item_code=item["item_code"],
+            warehouse=warehouse,
+            actual_qty=actual_qty,
+            outgoing_rate=0,
+            incoming_rate=0,
+            voucher_type=doc.DOCTYPE,
+            voucher_no=doc.name,
+            voucher_detail_no=item.get("name"),
+            posting_date=doc.posting_date,
+            company=doc.company,
+        ))
+    return sl_entries
+
+def build_buy_side_sles(doc, items):
+    """SLEs for incoming-stock docs (direct-receive PI update_stock).
+
+    Positive actual_qty on a normal receipt uses the supplier's invoice rate
+    as the incoming cost — that's what the business actually paid, not a
+    moving-average over prior stock. Negative actual_qty (return-to-supplier)
+    falls back to moving-average via outgoing_rate=0.
+    """
+    # Inventory is valued in the company's base currency; line rates are in
+    # document currency, so scale by the doc's conversion_rate (1.0 = no-op).
+    conversion_rate = flt(doc.get("conversion_rate")) or 1.0
+    sl_entries = []
+    for item in items:
+        warehouse = item.get("warehouse")
+        if not warehouse or not item.get("item_code"):
+            continue
+        actual_qty = flt(item["qty"])
+        rate = flt(item.get("net_rate") or item.get("rate", 0)) * conversion_rate
+        sl_entries.append(_dict(
+            item_code=item["item_code"],
+            warehouse=warehouse,
+            actual_qty=actual_qty,
+            incoming_rate=rate if actual_qty > 0 else 0,
+            outgoing_rate=0,
+            voucher_type=doc.DOCTYPE,
+            voucher_no=doc.name,
+            voucher_detail_no=item.get("name"),
+            posting_date=doc.posting_date,
+            company=doc.company,
+        ))
+    return sl_entries
+
+def build_cost_basis_gl(doc, *, remarks=None):
+    """Dr COGS / Cr Stock In Hand at cost for a sell-side doc.
+
+    Reads stock_value_difference from the SLEs already posted for this
+    voucher, so call this AFTER make_sl_entries. Sign handles returns:
+    stock_value_difference is negative for outgoing (Dr COGS/Cr SIH) and
+    positive for returns (Cr COGS/Dr SIH).
+    """
+    db = get_db()
+
+    default_expense = db.get_value("Company", doc.company, "default_expense_account")
+    stock_account = db.get_value("Company", doc.company, "stock_in_hand_account")
+    if not default_expense or not stock_account:
+        return []
+
+    cost_rows = db.sql(
+        'SELECT COALESCE(SUM(stock_value_difference), 0) as diff '
+        'FROM "Stock Ledger Entry" '
+        'WHERE voucher_type = ? AND voucher_no = ? AND is_cancelled = 0',
+        [doc.DOCTYPE, doc.name],
+    )
+    cost_diff = flt(cost_rows[0]["diff"]) if cost_rows else 0
+    if not cost_diff:
+        return []
+
+    cogs_debit = -cost_diff
+    sih_credit = -cost_diff
+    cost_center = db.get_value("Company", doc.company, "default_cost_center")
+    remark = remarks or f"{doc.DOCTYPE} {doc.name}"
+
+    return [
+        _dict(
+            account=default_expense,
+            debit=flt(cogs_debit, 2),
+            debit_in_account_currency=flt(cogs_debit, 2),
+            credit=0,
+            credit_in_account_currency=0,
+            cost_center=cost_center,
+            voucher_type=doc.DOCTYPE,
+            voucher_no=doc.name,
+            posting_date=doc.posting_date,
+            company=doc.company,
+            remarks=remark,
+        ),
+        _dict(
+            account=stock_account,
+            debit=0,
+            debit_in_account_currency=0,
+            credit=flt(sih_credit, 2),
+            credit_in_account_currency=flt(sih_credit, 2),
+            voucher_type=doc.DOCTYPE,
+            voucher_no=doc.name,
+            posting_date=doc.posting_date,
+            company=doc.company,
+            remarks=remark,
+        ),
+    ]
+
+def reverse_stock_sles(sl_entries):
+    """Flip actual_qty and swap incoming/outgoing rates for cancel-time
+    reversal. Returns new dicts so the caller's originals stay intact."""
+    reversed_ = []
+    for sle in sl_entries:
+        flipped = _dict(dict(sle))
+        flipped["actual_qty"] = -flt(sle["actual_qty"])
+        incoming = sle.get("incoming_rate", 0)
+        outgoing = sle.get("outgoing_rate", 0)
+        flipped["incoming_rate"] = outgoing
+        flipped["outgoing_rate"] = incoming
+        reversed_.append(flipped)
+    return reversed_