celerp 2.5.2__tar.gz → 2.5.3__tar.gz

{celerp-2.5.2 → celerp-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celerp
-Version: 2.5.2
+Version: 2.5.3
 Summary: Free, self-hosted ERP for small businesses
 License: Business Source License 1.1
         
@@ -143,13 +143,15 @@ Requires-Dist: cffi==2.1.1; platform_python_implementation != "PyPy"
 Requires-Dist: charset-normalizer==3.5.1
 Requires-Dist: click==8.5.0
 Requires-Dist: colorama==0.4.6; sys_platform == "win32"
-Requires-Dist: cryptography==50.0.1
-Requires-Dist: deprecated==1.3.1
+Requires-Dist: cryptography==48.0.1; platform_machine == "x86_64" and sys_platform == "darwin"
+Requires-Dist: cryptography==50.0.1; platform_machine != "x86_64" or sys_platform != "darwin"
+Requires-Dist: deprecated==1.3.1; python_full_version < "3.12"
+Requires-Dist: deprecated==3.0.0; python_full_version >= "3.12"
 Requires-Dist: ecdsa==0.19.2
 Requires-Dist: et-xmlfile==2.0.0
 Requires-Dist: exceptiongroup==1.3.1; python_full_version < "3.11"
 Requires-Dist: fastapi==0.141.1
-Requires-Dist: fastcore==2.2.30
+Requires-Dist: fastcore==2.2.31
 Requires-Dist: greenlet==3.5.6
 Requires-Dist: h11==0.16.0
 Requires-Dist: httpcore==1.0.9
@@ -166,7 +168,7 @@ Requires-Dist: markupsafe==3.0.3
 Requires-Dist: numpy==2.2.6; python_full_version < "3.11"
 Requires-Dist: numpy==2.4.6; python_full_version == "3.11.*"
 Requires-Dist: numpy==2.5.3; python_full_version >= "3.12"
-Requires-Dist: oauthlib==3.3.1
+Requires-Dist: oauthlib==4.0.0
 Requires-Dist: openpyxl==3.1.5
 Requires-Dist: packaging==26.3
 Requires-Dist: passlib==1.7.4
@@ -205,7 +207,7 @@ Requires-Dist: uvloop==0.22.1; platform_python_implementation != "PyPy" and sys_
 Requires-Dist: watchfiles==1.3.0
 Requires-Dist: websockets==16.1.1; python_full_version < "3.11"
 Requires-Dist: websockets==17.1; python_full_version >= "3.11"
-Requires-Dist: wrapt==2.4.1
+Requires-Dist: wrapt==2.5.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"

{celerp-2.5.2 → celerp-2.5.3}/celerp/ai/memory.py

@@ -27,6 +27,7 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from celerp.models.company import Company
+from celerp.services.company_lock import locked_company
 
 MAX_NOTES = 50
 MAX_KV_KEYS = 100
@@ -52,7 +53,7 @@ async def set_memory(
     memory: dict[str, Any],
 ) -> None:
     """Persist AI memory. Caller is responsible for committing the session."""
-    row = await session.get(Company, company_id)
+    row = await locked_company(session, company_id)
     if row is None:
         return
     settings = dict(row.settings)
@@ -67,6 +68,7 @@ async def add_note(
     content: str,
 ) -> None:
     """Append a note to AI memory, trimming to MAX_NOTES oldest."""
+    await locked_company(session, company_id)
     mem = await get_memory(session, company_id)
     notes = list(mem.get("notes", []))
     notes.append({"content": content, "added_at": datetime.now(timezone.utc).isoformat()})
@@ -83,6 +85,7 @@ async def set_kv(
     value: str,
 ) -> None:
     """Set a key-value fact in AI memory."""
+    await locked_company(session, company_id)
     mem = await get_memory(session, company_id)
     kv = dict(mem.get("kv", {}))
     if len(kv) >= MAX_KV_KEYS and key not in kv:

{celerp-2.5.2 → celerp-2.5.3}/celerp/connectors/ownership.py

@@ -14,6 +14,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from celerp.config import ensure_instance_id
 from celerp.models.company import Company
 from celerp.models.connector_config import ConnectorConfig
+from celerp.services.company_lock import lock_company
 
 
 class ConnectorOwnershipError(RuntimeError):
@@ -128,9 +129,9 @@ async def _lock_active_company(
         cid = uuid.UUID(str(company_id))
     except (TypeError, ValueError) as exc:
         raise ConnectorOwnershipError("Connector company is invalid") from exc
-    company = await session.get(
-        Company, cid, with_for_update=for_update, populate_existing=True
-    )
+    if for_update:
+        await lock_company(session, cid)
+    company = await session.get(Company, cid, populate_existing=True)
     if company is None or not company.is_active:
         raise ConnectorOwnershipError("Connector company is inactive")
     return company

{celerp-2.5.2 → celerp-2.5.3}/celerp/events/engine.py

@@ -69,7 +69,7 @@ async def _check_period_lock(session, company_id, data: dict) -> None:
                         raise HTTPException(status_code=422, detail=str(exc)) from exc
                     event_date = instant.astimezone(zone).date()
         except (ValueError, TypeError):
-            return
+            raise HTTPException(status_code=422, detail=f"{event_date_str} is not a date. Enter it as YYYY-MM-DD.") from None
     else:
         try:
             zone = business_timezone((company.settings or {}).get("timezone"))

{celerp-2.5.2 → celerp-2.5.3}/celerp/events/schemas.py

@@ -3,7 +3,7 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import BaseModel, Field, model_validator
 
@@ -627,10 +627,23 @@ class DocPaymentReceived(BaseModel):
     paired_index: int | None = None
 
 
+class PaymentBatchRecorded(BaseModel):
+    doc_ids: list[str]
+    amount: float
+    currency: str
+    payment_date: str
+    allocations: list[dict]
+    skipped: list[dict]
+    total_allocated: float
+    remaining: float
+
+
 class DocPaymentRefunded(BaseModel):
     amount: float
     reason: str | None = None
     method: str | None = None
+    payment_index: int | None = None  # the payment the money is given back from
+    refund_date: str | None = None
 
 
 class DocPaymentVoided(BaseModel):
@@ -681,6 +694,39 @@ class DocSharedImport(BaseModel):
     model_config = {"extra": "allow"}  # carries the allowlisted shared-document fields
 
 
+class ReceivedDocImported(BaseModel):
+    """A document another business shared, held apart from our own documents.
+
+    Carries the sender identity, the revision digest and the sanitized document.
+    The same event type records a first import and a later sender revision."""
+    source_installation: str
+    source_company: str = ""
+    source_document: str
+    source_revision: str | None = None
+    source_link: str | None = None
+    digest: str
+    received_at: str
+    document: dict[str, Any]
+
+
+class ReceivedDocBooked(BaseModel):
+    """The recipient booked a received document as a local draft."""
+    target_id: str
+    target_kind: Literal["doc", "list"]
+    target_type: str
+    revision_seq: int
+    revision_digest: str
+    target_version: int
+
+
+class ReceivedDocDraftUpdated(BaseModel):
+    """The booked draft now stands for a newer revision: the recipient applied
+    it (draft_updated) or reconciled the draft with it by hand (reconciled)."""
+    revision_seq: int
+    revision_digest: str
+    target_version: int
+
+
 class DocNoteAdded(BaseModel):
     doc_id: str
     note_id: str
@@ -1067,7 +1113,7 @@ class ListCreated(BaseModel):
     model_config = {"extra": "allow"}
     list_type: str | None = None
     ref_id: str | None = None
-    customer_id: str | None = None
+    contact_id: str | None = None
     status: str = "draft"
 
 
@@ -1226,11 +1272,17 @@ EVENT_SCHEMA_MAP: dict[str, type[BaseModel]] = {
     "doc.sent": DocSent,
     "doc.payment.received": DocPaymentReceived,
     "doc.payment.refunded": DocPaymentRefunded,
+    "payment_batch.recorded": PaymentBatchRecorded,
     "doc.payment.voided": DocPaymentVoided,
     "doc.payment.deleted": DocPaymentDeleted,
     "doc.converted": DocConverted,
     "doc.received": DocReceived,
     "doc.shared_import": DocSharedImport,
+    "received_doc.imported": ReceivedDocImported,
+    "received_doc.revised": ReceivedDocImported,
+    "received_doc.booked": ReceivedDocBooked,
+    "received_doc.draft_updated": ReceivedDocDraftUpdated,
+    "received_doc.reconciled": ReceivedDocDraftUpdated,
     "doc.note_added": DocNoteAdded,
     "doc.note_updated": DocNoteUpdated,
     "doc.note_removed": DocNoteRemoved,

{celerp-2.5.2 → celerp-2.5.3}/celerp/gateway/state.py

@@ -826,7 +826,7 @@ def _launch_mode() -> str | None:
 
 def activate_payload(
     instance_id: str, *, first_boot: bool | None = None,
-    activation_verifier: str | None = None,
+    activation_verifier: str | None = None, boot_id: str | None = None,
 ) -> dict:
     """Build Connect activation and check-in metadata."""
     import platform as _platform
@@ -843,6 +843,8 @@ def activate_payload(
         payload["first_boot"] = first_boot
     if activation_verifier:
         payload["activation_verifier"] = activation_verifier
+    if boot_id:
+        payload["boot_id"] = boot_id
     from celerp.config import settings as _settings
     if _settings.backup_encryption_key:
         payload["backup_encryption_key"] = _settings.backup_encryption_key

{celerp-2.5.2 → celerp-2.5.3}/celerp/main.py

@@ -4,9 +4,13 @@
 from contextlib import asynccontextmanager
 import asyncio
 import logging
+import math
 import sys
+import uuid
 
 from fastapi import FastAPI, Request
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from slowapi import Limiter, _rate_limit_exceeded_handler
 from slowapi.errors import RateLimitExceeded
@@ -16,12 +20,16 @@ from celerp import __version__, runtime as _runtime
 _runtime.watch_supervisor_pipe()
 from celerp.db import engine, lifecycle_engine, mask_db_credentials
 from celerp.inventory_codes import CodeConflictError
+from celerp.services.auto_je import UnbalancedJournalEntry
 from celerp.config import settings, assert_secure_jwt, ensure_instance_id, load_cloud_config, load_backup_config
 from celerp.gateway.state import load_commercial_context
 load_cloud_config()
 load_backup_config()
 load_commercial_context()
 assert_secure_jwt()
+# Read before ensure_instance_id() writes the id.
+_FIRST_BOOT = not settings.gateway_instance_id
+_BOOT_ID = uuid.uuid4().hex
 ensure_instance_id()
 from celerp.middleware import DrainMiddleware, MaxBodySizeMiddleware, SecurityHeadersMiddleware, SlidingTokenRefreshMiddleware, log_unhandled_exception
 from celerp.models.base import Base
@@ -82,45 +90,28 @@ _MODULE_DIR = _os.environ["MODULE_DIR"]
 
 
 async def _try_auto_activate() -> None:
-    """Recover a challenge-approved activation, otherwise only check in.
-
-    The verifier is durable, so retrying it after response loss returns the same
-    credential. UUID-only activation is intentionally not retried at startup.
-    """
+    """Check in with the relay at startup, or finish a pending activation."""
     _log = logging.getLogger(__name__)
     try:
-        import httpx
-        from celerp.config import (
-            settings as _s, ensure_instance_id, config_path)
+        from celerp.config import settings as _s, ensure_instance_id
         if _s.cloud_disconnected:
             return
-        first_boot = not config_path().exists()
         iid = await asyncio.to_thread(ensure_instance_id)
-        from celerp.gateway.state import activate_payload, relay_http_url as _rhu
+        from celerp.gateway.state import (
+            activate_payload, relay_http_url as _rhu, relay_post_with_retry)
         relay_base = _rhu()
         verifier = _s.activation_verifier or ""
 
         if not verifier:
-            async def _checkin():
-                async with httpx.AsyncClient(timeout=6.0) as c:
-                    return await c.post(
-                        f"{relay_base}/auth/checkin",
-                        json=activate_payload(iid, first_boot=first_boot),
-                    )
-
-            try:
-                await asyncio.wait_for(_checkin(), timeout=6.0)
-            except (httpx.HTTPError, asyncio.TimeoutError):
-                pass
+            await relay_post_with_retry(
+                f"{relay_base}/auth/checkin",
+                activate_payload(iid, first_boot=_FIRST_BOOT, boot_id=_BOOT_ID))
             return
-        else:
-            # Challenge redemption is idempotent for this verifier, so transient
-            # transport retries are safe here.
-            from celerp.gateway.state import relay_post_with_retry
-            r = await relay_post_with_retry(
-                f"{relay_base}/auth/activate",
-                activate_payload(
-                    iid, first_boot=first_boot, activation_verifier=verifier))
+        r = await relay_post_with_retry(
+            f"{relay_base}/auth/activate",
+            activate_payload(
+                iid, first_boot=_FIRST_BOOT, activation_verifier=verifier,
+                boot_id=_BOOT_ID))
 
         if r is None or r.status_code != 200:
             return
@@ -146,7 +137,8 @@ async def _try_sync_existing_entitlement() -> None:
     """Best-effort boot convergence for an already-persisted relay credential."""
     try:
         from celerp.services.cloud_entitlement import sync_existing_entitlement
-        await sync_existing_entitlement(require_persisted_key=True)
+        await sync_existing_entitlement(
+            require_persisted_key=True, first_boot=_FIRST_BOOT, boot_id=_BOOT_ID)
     except Exception as exc:
         logging.getLogger(__name__).debug(
             "Cloud startup reconciliation failed (non-fatal): %s", exc)
@@ -218,7 +210,7 @@ async def lifespan(_app: FastAPI):
         if _enabled_env:
             _enabled: set[str] = set(_enabled_env.split(","))
         else:
-            # Fall back to config.toml (written by setup wizard apply-preset)
+            # Fall back to the module list saved in config.toml.
             _cfg = _read_config()
             _enabled = set(_cfg.get("modules", {}).get("enabled") or [])
         if _enabled:
@@ -544,6 +536,17 @@ async def unhandled_exception_handler(request: Request, exc: Exception):
     return JSONResponse(status_code=500, content={"detail": "Internal server error"})
 
 
+def _finite_or_text(value: float) -> float | str:
+    return value if math.isfinite(value) else str(value)
+
+
+@app.exception_handler(RequestValidationError)
+async def request_validation_handler(_request: Request, exc: RequestValidationError):
+    # A rejected NaN or Infinity is echoed back as text, since JSON cannot carry it as a number.
+    return JSONResponse(status_code=422, content={
+        "detail": jsonable_encoder(exc.errors(), custom_encoder={float: _finite_or_text})})
+
+
 @app.exception_handler(RateLimitExceeded)
 async def rate_limit_handler(_request: Request, _exc: RateLimitExceeded):
     return JSONResponse(status_code=429, content={"detail": "Rate limit exceeded"})
@@ -557,6 +560,13 @@ async def code_conflict_handler(_request: Request, exc: CodeConflictError):
     return JSONResponse(status_code=409, content={"detail": str(exc)})
 
 
+@app.exception_handler(UnbalancedJournalEntry)
+async def unbalanced_je_handler(_request: Request, exc: UnbalancedJournalEntry):
+    # An automatic journal entry that would not balance is refused, and the write that
+    # produced it rolls back with it; the message names the document and the amounts.
+    return JSONResponse(status_code=422, content={"detail": str(exc)})
+
+
 # Kernel routes — always present regardless of module configuration
 app.include_router(health.router, tags=["system"])
 app.include_router(health.settings_router, tags=["settings"])

celerp-2.5.3/celerp/migrations/versions/l9a0b1c2d3e4_fold_list_contact_fields.py

@@ -0,0 +1,46 @@
+# Copyright (c) 2026 Noah Severs
+# SPDX-License-Identifier: BUSL-1.1
+
+"""Store every List's counterparty as contact_id and contact_name.
+
+Revision ID: l9a0b1c2d3e4
+Revises: k8f9a0b1c2d3
+Create Date: 2026-09-29
+
+Lists stored their counterparty as customer_id and customer_name (transfers:
+receiver). Lists now read contact_id and contact_name only, so this moves the
+older fields onto them. A contact already on the List is kept.
+"""
+
+from __future__ import annotations
+
+from alembic import op
+
+from celerp.migrations._json_compat import update_projection_state
+
+revision = "l9a0b1c2d3e4"
+down_revision = "k8f9a0b1c2d3"
+branch_labels = None
+depends_on = None
+
+# Hardcoded (migrations must be self-contained), in the order the List projection folds them.
+_FOLD = (("customer_id", "contact_id"), ("customer_name", "contact_name"), ("receiver", "contact_name"))
+
+
+def upgrade() -> None:
+    def _fold(state, row):
+        changed = False
+        for older, field in _FOLD:
+            if older not in state:
+                continue
+            value = state.pop(older)
+            if value and not state.get(field):
+                state[field] = value
+            changed = True
+        return changed
+
+    update_projection_state(op.get_bind(), _fold, where="entity_type = 'list'")
+
+
+def downgrade() -> None:
+    pass  # Data migration - no safe downgrade

{celerp-2.5.2 → celerp-2.5.3}/celerp/models/__init__.py

@@ -11,3 +11,4 @@ from celerp.models.notification import Notification  # noqa: F401
 from celerp.models.share import DocShareToken  # noqa: F401 - ensure doc_share_tokens table registered
 from celerp.models.sync_run import SyncRun  # noqa: F401 - ensure sync_runs table registered
 from celerp.models.supporter import SupporterBadge  # noqa: F401 - ensure supporter_badges table registered
+import celerp.services.company_lock  # noqa: F401,E402 - company settings changes need the company lock

{celerp-2.5.2 → celerp-2.5.3}/celerp/modules/loader.py

@@ -313,6 +313,15 @@ def _module_candidates(
     return out
 
 
+def module_search_path() -> str:
+    """Every directory an installed module can live in, as a MODULE_DIR-style string:
+    the MODULE_DIR entries (administrative precedence) followed by the bundled and
+    trusted dirs. Lets a caller locate an installed module's data even when the
+    module system is off or the module is not enabled."""
+    entries = [e.strip() for e in os.environ.get("MODULE_DIR", "").split(",") if e.strip()]
+    return ",".join([*entries, *(str(d) for d in _BUNDLED_MODULES_DIRS)])
+
+
 def resolve_module_path(
     name: str, module_dir: str | Path | None = None,
 ) -> Path | None:
@@ -514,6 +523,28 @@ def is_running(pkg_name: str) -> bool:
     return any(m["name"] == pkg_name for m in _loaded) or is_core_folded(pkg_name)
 
 
+def restart_would_load(pkg_name: str) -> bool:
+    """True when a server restart would load *pkg_name*.
+
+    That needs the module system on with an installed copy in MODULE_DIR, and an
+    enabled list the restart re-reads from the config file: under the supervisor
+    ENABLED_MODULES is rebuilt from config on every restart, while outside it a set
+    ENABLED_MODULES pins the list and only the names it holds can load."""
+    if not _module_candidates(pkg_name):
+        return False
+    pinned = os.environ.get("ENABLED_MODULES", "")
+    if not pinned or os.environ.get("CELERP_SUPERVISED") == "1":
+        return True
+    return pkg_name in {n.strip() for n in pinned.split(",")}
+
+
+def module_label(pkg_name: str) -> str:
+    """The module's display name from its manifest, or the package name."""
+    path = resolve_runtime_module_path(pkg_name, module_search_path())
+    meta = read_manifest_metadata(path) if path is not None else {}
+    return meta.get("display_name") or meta.get("label") or pkg_name
+
+
 # Fields to extract from PLUGIN_MANIFEST for display purposes.
 # All must be string or list-of-strings literals in __init__.py (safe for ast.literal_eval).
 _MANIFEST_DISPLAY_FIELDS: frozenset[str] = frozenset({

{celerp-2.5.2 → celerp-2.5.3}/celerp/output/doc_print.py

@@ -21,6 +21,7 @@ from fasthtml.common import (
 
 from celerp.output.branding import BRAND_TEXT as _BRAND_LABEL, brand_url as _brand_url
 from celerp.output.document_context import prepare_document_output
+from celerp.services.doc_balance import outstanding_balance
 from celerp.services.line_measures import line_identifier as _line_identifier, measure_sublines, qty_label
 from celerp.services.shipping import REASON_EXPORT_LABELS, SHIPPING_LIST_TYPE
 from celerp.services.units import DEFAULT_UNITS, build_unit_map
@@ -30,9 +31,24 @@ EMPTY = "--"
 # Doc types that show pieces/weight measure sub-lines (the invoice layout).
 INVOICE_LAYOUT_DOC_TYPES: frozenset[str] = frozenset({"invoice", "memo", "list"})
 
-# Doc types a recipient can import on their own instance; only these get the
-# Import-into-Celerp footer link (an import link on a memo would just 422).
-IMPORTABLE_DOC_TYPES: frozenset[str] = frozenset({"invoice", "purchase_order", "quotation", "list"})
+# The celerp.com page a recipient lands on to import a shared document. It is
+# handed the share page's own address as `link`.
+IMPORT_ACCEPT_URL = "https://www.celerp.com/accept"
+
+
+def import_accept_url(page: str) -> str:
+    """Accept URL carrying the share page address as `link`."""
+    from urllib.parse import urlencode
+    return f"{IMPORT_ACCEPT_URL}?{urlencode({'link': page})}"
+
+
+# On a share page the address the recipient is actually reading is the one to
+# import from; behind the relay the server cannot know it, so the page fills it in.
+_IMPORT_FROM_PAGE_JS = (
+    "(function(){var a=document.getElementById('dp-import');"
+    "if(a&&/^https?:$/.test(location.protocol)){a.href='" + IMPORT_ACCEPT_URL
+    + "?link='+encodeURIComponent(location.origin+location.pathname);}})();"
+)
 
 _BRAND_URL = _brand_url("doc-print")
 
@@ -179,17 +195,20 @@ body { font-family: Arial, sans-serif; font-size: 10pt; color: #111; background:
 """
 
 
-def _doc_footer(import_url: str | None):
+def _doc_footer(import_url: str | None, import_from_page: bool = False):
     """One footer format everywhere: brand left, pipe, import link right.
     The import link is only rendered when the document's share link is live,
-    so a printed or PDF'd copy never carries a URL that 404s."""
+    so a printed or PDF'd copy never carries a URL that 404s. On the share
+    page itself (``import_from_page``) the link is pointed at the page's own
+    address once it loads."""
     brand = A(_BRAND_LABEL, href=_BRAND_URL, target="_blank", rel="noopener")
     if not import_url:
         return Div(brand, cls="dp-footer")
     return Div(
         brand,
         Span("|", cls="dp-footer__sep"),
-        A("Import into Celerp", href=import_url),
+        A("Import into Celerp", href=import_url, id="dp-import"),
+        Script(_IMPORT_FROM_PAGE_JS) if import_from_page else None,
         cls="dp-footer",
     )
 
@@ -201,10 +220,7 @@ def _pay_bar(pay_url: str | None, doc: dict, currency: str):
     buttons."""
     if not pay_url:
         return None
-    try:
-        outstanding = float(doc.get("amount_outstanding", doc.get("total", 0)) or 0)
-    except (TypeError, ValueError):
-        outstanding = 0.0
+    outstanding = float(outstanding_balance(doc) or 0)
     if outstanding <= 0:
         return None
     amount = fmt_money(outstanding, currency)
@@ -216,6 +232,7 @@ def _pay_bar(pay_url: str | None, doc: dict, currency: str):
 
 
 def render_doc_print_html(doc: dict, *, import_url: str | None = None,
+                          import_from_page: bool = False,
                           pay_url: str | None = None, auto_print: bool = False,
                           layout: str | None = None,
                           line_identifier: str = "sku") -> str:
@@ -225,7 +242,8 @@ def render_doc_print_html(doc: dict, *, import_url: str | None = None,
     fields, and (for invoice-layout types) enriched line measures - both the
     UI print routes and the API share view prepare it the same way.
     ``pay_url`` adds the screen-only payment bar (public share view of a
-    payable doc on a Stripe-connected instance).
+    payable doc on a Stripe-connected instance). ``import_from_page`` marks
+    the public share view, whose import link points at its own address.
 
     A shipping document (list_type="shipping_doc") is one shipment record with
     two paper renderings, chosen via ``layout``: "delivery_note" (the default -
@@ -622,7 +640,7 @@ def render_doc_print_html(doc: dict, *, import_url: str | None = None,
             Div(P("Note to Customer", cls="dp-notes-label"), P(customer_note), cls="dp-notes") if customer_note else None,
             declaration_section,
             signature_section,
-            _doc_footer(import_url),
+            _doc_footer(import_url, import_from_page),
             Script("window.onload = function() { window.print(); }") if auto_print else None,
         ),
     )