python-sendparcel 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

python_sendparcel-0.1.1.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.4
+Name: python-sendparcel
+Version: 0.1.1
+Summary: Framework-agnostic parcel shipping core for Python.
+Project-URL: Homepage, https://github.com/sendparcel/python-sendparcel
+Project-URL: Documentation, https://python-sendparcel.readthedocs.io/
+Project-URL: Repository, https://github.com/sendparcel/python-sendparcel
+Project-URL: Changelog, https://github.com/sendparcel/python-sendparcel/blob/main/CHANGELOG.md
+Project-URL: Issue Tracker, https://github.com/sendparcel/python-sendparcel/issues
+Author-email: Dominik Kozaczko <dominik@kozaczko.info>
+License: MIT
+License-File: LICENSE
+Keywords: delivery,logistics,parcel,sendparcel,shipping
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: anyio>=4.0
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: all
+Requires-Dist: django-sendparcel>=0.1.0; extra == 'all'
+Requires-Dist: fastapi-sendparcel>=0.1.0; extra == 'all'
+Requires-Dist: litestar-sendparcel>=0.1.0; extra == 'all'
+Requires-Dist: python-sendparcel-cli>=0.1.0; extra == 'all'
+Requires-Dist: python-sendparcel-dpdpl>=0.1.0; extra == 'all'
+Requires-Dist: python-sendparcel-inpost>=0.1.0; extra == 'all'
+Provides-Extra: cli
+Requires-Dist: python-sendparcel-cli>=0.1.0; extra == 'cli'
+Provides-Extra: dev
+Requires-Dist: pre-commit-hooks>=6.0.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.9.0; extra == 'dev'
+Requires-Dist: ty>=0.0.16; extra == 'dev'
+Provides-Extra: django
+Requires-Dist: django-sendparcel>=0.1.0; extra == 'django'
+Provides-Extra: dpdpl
+Requires-Dist: python-sendparcel-dpdpl>=0.1.0; extra == 'dpdpl'
+Provides-Extra: dummy
+Provides-Extra: fastapi
+Requires-Dist: fastapi-sendparcel>=0.1.0; extra == 'fastapi'
+Provides-Extra: frameworks
+Requires-Dist: django-sendparcel>=0.1.0; extra == 'frameworks'
+Requires-Dist: fastapi-sendparcel>=0.1.0; extra == 'frameworks'
+Requires-Dist: litestar-sendparcel>=0.1.0; extra == 'frameworks'
+Provides-Extra: inpost
+Requires-Dist: python-sendparcel-inpost>=0.1.0; extra == 'inpost'
+Provides-Extra: litestar
+Requires-Dist: litestar-sendparcel>=0.1.0; extra == 'litestar'
+Provides-Extra: providers
+Requires-Dist: python-sendparcel-dpdpl>=0.1.0; extra == 'providers'
+Requires-Dist: python-sendparcel-inpost>=0.1.0; extra == 'providers'
+Description-Content-Type: text/markdown
+
+# python-sendparcel
+
+Framework-agnostic parcel shipping core for Python.
+
+> Alpha notice: `0.1.1` is still unstable. The API can change fast because the
+> ecosystem is still being cleaned up.
+
+## What it is
+
+- Provider-agnostic shipment orchestration with a single core flow.
+- Explicit shipment metadata persistence: `id`, `status`, `provider`, `external_id`, `tracking_number`.
+- Label payloads are operation results, not persisted shipment fields.
+- One normalized provider update contract for both callbacks and polling.
+- Runtime-checkable `Shipment` and `ShipmentRepository` protocols so adapters can use their own models.
+
+## Core contract
+
+- `ShipmentFlow.create_shipment(...) -> CreateShipmentOutcome`
+- `ShipmentFlow.create_label(...) -> CreateLabelOutcome`
+- `ShipmentFlow.handle_callback(...) -> ShipmentUpdateOutcome`
+- `ShipmentFlow.fetch_and_update_status(...) -> ShipmentUpdateOutcome`
+- `ShipmentFlow.cancel_shipment(...) -> bool`
+
+`CreateShipmentOutcome` and `CreateLabelOutcome` return label payloads when available.
+The shipment object never stores label bytes or a persisted `label_url` in the core contract.
+
+## Quick start
+
+```python
+from dataclasses import dataclass
+from decimal import Decimal
+
+import anyio
+
+from sendparcel import ShipmentFlow
+from sendparcel.types import AddressInfo, ParcelInfo
+
+
+@dataclass
+class MyShipment:
+    id: str
+    status: str = "new"
+    provider: str = ""
+    external_id: str = ""
+    tracking_number: str = ""
+
+
+class InMemoryRepository:
+    def __init__(self) -> None:
+        self._store: dict[str, MyShipment] = {}
+        self._counter = 0
+
+    async def get_by_id(self, shipment_id: str) -> MyShipment:
+        return self._store[shipment_id]
+
+    async def create(self, **kwargs) -> MyShipment:
+        self._counter += 1
+        shipment = MyShipment(
+            id=str(self._counter),
+            status=str(kwargs.get("status", "new")),
+            provider=str(kwargs.get("provider", "")),
+        )
+        self._store[shipment.id] = shipment
+        return shipment
+
+    async def save(self, shipment: MyShipment) -> MyShipment:
+        self._store[shipment.id] = shipment
+        return shipment
+
+
+async def main() -> None:
+    flow = ShipmentFlow(repository=InMemoryRepository())
+
+    created = await flow.create_shipment(
+        "dummy",
+        sender_address=AddressInfo(
+            name="Sender Co.",
+            line1="Marszalkowska 1",
+            city="Warsaw",
+            postal_code="00-001",
+            country_code="PL",
+        ),
+        receiver_address=AddressInfo(
+            name="Jan Kowalski",
+            line1="Dluga 10",
+            city="Gdansk",
+            postal_code="80-001",
+            country_code="PL",
+        ),
+        parcels=[ParcelInfo(weight_kg=Decimal("2.5"))],
+    )
+
+    print(created.shipment.status)
+    print(created.shipment.external_id)
+    print(created.shipment.tracking_number)
+
+    labelled = await flow.create_label(created.shipment)
+    print(labelled.label.get("url"))
+
+
+anyio.run(main)
+```
+
+## Provider model
+
+- `BaseProvider.create_shipment(...)` returns `ShipmentCreateResult`.
+- `BaseProvider.confirmation_method` defaults to `ConfirmationMethod.NONE`.
+- `LabelProvider.create_label(...)` returns `LabelInfo`.
+- `PushCallbackProvider.handle_callback(...)` returns `ShipmentUpdateResult`.
+- `PullStatusProvider.fetch_shipment_status(...)` returns `ShipmentUpdateResult`.
+- `CancellableProvider.cancel_shipment(...)` returns `bool`.
+
+Use `ConfirmationMethod.PUSH` only with `PushCallbackProvider` and
+`ConfirmationMethod.PULL` only with `PullStatusProvider`.
+
+The core owns shipment state transitions. Providers translate carrier responses
+into normalized results.
+
+## Installation
+
+```bash
+pip install python-sendparcel
+```
+
+With `uv`:
+
+```bash
+uv add python-sendparcel
+```
+
+## Extras
+
+- `django`
+- `fastapi`
+- `litestar`
+- `inpost`
+- `dpdpl`
+- `cli`
+- `frameworks`
+- `providers`
+- `all`
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check src tests
+uv run mypy src tests
+```

python_sendparcel-0.1.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+sendparcel/__init__.py,sha256=laO3AFTeFkq_XiqzIvFWMZPblm35Rt51tKteNrNgh9Y,1314
+sendparcel/enums.py,sha256=9tg9eMD5QpHOTNfsedncYQqfkxW_IXVcFfgJL6dCD1o,659
+sendparcel/exceptions.py,sha256=zC5_o9oQfNuOBKaiw5csaHAJmhYsZc3WVbOaoq7s1W0,1437
+sendparcel/flow.py,sha256=gLQuIJXxde_Ta4oseBJvyjCNc80YPq4g1tK4KwnOv90,6940
+sendparcel/fsm.py,sha256=TbKkDNEjqWPDBDdnzvGWEaUtTcEXPJPpcZdSkuqIquI,3147
+sendparcel/protocols.py,sha256=y4TQb0p0z0WO39KCqwiCU0uTi4pXbvgRMbB_LsIPvJ8,689
+sendparcel/provider.py,sha256=6f6Z3hmLNrN2t-pulVAFEPrZnNttX1kmK6ATCnqdZD4,2690
+sendparcel/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sendparcel/registry.py,sha256=lVWpNZuXISC2c12GC7fvk-fULHVQ6exFvMqv5ilswg8,2700
+sendparcel/types.py,sha256=afPuER1CslkvcTMMogY0EVYrTjUsA36gPxVQguYtIBg,2201
+sendparcel/validators.py,sha256=i_y-edT1hgS_2HeRdARlFaQXiL9sYAzWVsjYPVBqRDc,589
+sendparcel/providers/__init__.py,sha256=ff82dvrWuPS-UIGF5AoX_fgpcYZaGu2k6q2yrxMZacI,192
+sendparcel/providers/dummy.py,sha256=sbXDtPel3DEH_FIN9_gX2xXBLEqZ7Pto3CP_JMcsaEM,3102
+python_sendparcel-0.1.1.dist-info/METADATA,sha256=-vbQtZxuDuTQeZLa40hfZlqEJefWJAuC-IsnGqt33vc,6888
+python_sendparcel-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_sendparcel-0.1.1.dist-info/licenses/LICENSE,sha256=IZXSBOjgGvChgayLmtTnU40iE7hsrrU3WVEYKx0sywY,1075
+python_sendparcel-0.1.1.dist-info/RECORD,,

{python_sendparcel-0.1.0.dist-info → python_sendparcel-0.1.1.dist-info}/WHEEL

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

sendparcel/__init__.py

@@ -1,29 +1,54 @@
 """sendparcel core package."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 
-from sendparcel.enums import ConfirmationMethod, ShipmentStatus
+from sendparcel.enums import ConfirmationMethod, LabelFormat, ShipmentStatus
 from sendparcel.exceptions import (
     CommunicationError,
     InvalidCallbackError,
     InvalidTransitionError,
+    ProviderCapabilityError,
+    ProviderNotFoundError,
     SendParcelException,
+    ShipmentNotFoundError,
 )
 from sendparcel.flow import ShipmentFlow
-from sendparcel.provider import BaseProvider
+from sendparcel.provider import (
+    BaseProvider,
+    CancellableProvider,
+    LabelProvider,
+    PullStatusProvider,
+    PushCallbackProvider,
+)
 from sendparcel.providers.dummy import DummyProvider
 from sendparcel.registry import registry
+from sendparcel.types import (
+    CreateLabelOutcome,
+    CreateShipmentOutcome,
+    ShipmentUpdateOutcome,
+)
 
 __all__ = [
     "BaseProvider",
+    "CancellableProvider",
     "CommunicationError",
     "ConfirmationMethod",
+    "CreateLabelOutcome",
+    "CreateShipmentOutcome",
     "DummyProvider",
     "InvalidCallbackError",
     "InvalidTransitionError",
+    "LabelFormat",
+    "LabelProvider",
+    "ProviderCapabilityError",
+    "ProviderNotFoundError",
+    "PullStatusProvider",
+    "PushCallbackProvider",
     "SendParcelException",
     "ShipmentFlow",
+    "ShipmentNotFoundError",
     "ShipmentStatus",
+    "ShipmentUpdateOutcome",
     "__version__",
     "registry",
 ]

sendparcel/enums.py

@@ -17,8 +17,18 @@ class ShipmentStatus(StrEnum):
     RETURNED = "returned"
 
 
+class LabelFormat(StrEnum):
+    """Shipping label format."""
+
+    PDF = "PDF"
+    ZPL = "ZPL"
+    PNG = "PNG"
+    EPL = "EPL"
+
+
 class ConfirmationMethod(StrEnum):
     """How the provider confirms shipment status updates."""
 
+    NONE = "NONE"
     PUSH = "PUSH"
     PULL = "PULL"

sendparcel/exceptions.py

@@ -1,10 +1,16 @@
 """Exception hierarchy for sendparcel."""
 
+from __future__ import annotations
+
+from typing import Any
+
 
 class SendParcelException(Exception):
     """Base exception for sendparcel."""
 
-    def __init__(self, message: str = "", context: dict | None = None) -> None:
+    def __init__(
+        self, message: str = "", context: dict[str, Any] | None = None
+    ) -> None:
         super().__init__(message)
         self.context = context or {}
 
@@ -19,3 +25,29 @@ class InvalidCallbackError(SendParcelException):
 
 class InvalidTransitionError(SendParcelException):
     """Invalid shipment state transition requested."""
+
+
+class ShipmentNotFoundError(SendParcelException):
+    """Shipment not found in repository."""
+
+    def __init__(
+        self, shipment_id: str, context: dict[str, Any] | None = None
+    ) -> None:
+        super().__init__(f"Shipment {shipment_id} not found", context)
+        self.shipment_id = shipment_id
+
+
+class ProviderNotFoundError(SendParcelException):
+    """Provider slug not found in the registry."""
+
+    def __init__(
+        self, provider_slug: str, context: dict[str, Any] | None = None
+    ) -> None:
+        super().__init__(
+            f"Provider {provider_slug!r} is not registered", context
+        )
+        self.provider_slug = provider_slug
+
+
+class ProviderCapabilityError(SendParcelException):
+    """Provider does not support the requested capability."""

sendparcel/flow.py

@@ -1,19 +1,34 @@
 """Shipment flow orchestrator."""
 
+from __future__ import annotations
+
+from typing import Any
+
 import httpx
 
 from sendparcel.enums import ShipmentStatus
 from sendparcel.exceptions import (
     CommunicationError,
-    InvalidTransitionError,
+    ProviderCapabilityError,
     SendParcelException,
 )
-from sendparcel.fsm import (
-    STATUS_TO_CALLBACK,
-    create_shipment_machine,
+from sendparcel.fsm import transition_shipment
+from sendparcel.protocols import Shipment, ShipmentRepository
+from sendparcel.provider import (
+    BaseProvider,
+    CancellableProvider,
+    LabelProvider,
+    PullStatusProvider,
+    PushCallbackProvider,
+)
+from sendparcel.types import (
+    AddressInfo,
+    CreateLabelOutcome,
+    CreateShipmentOutcome,
+    ParcelInfo,
+    ShipmentUpdateOutcome,
+    ShipmentUpdateResult,
 )
-from sendparcel.protocols import Order, Shipment, ShipmentRepository
-from sendparcel.registry import registry
 from sendparcel.validators import run_validators
 
 
@@ -23,100 +38,145 @@ class ShipmentFlow:
     def __init__(
         self,
         repository: ShipmentRepository,
-        config: dict | None = None,
-        validators: list | None = None,
+        config: dict[str, Any] | None = None,
+        validators: list[Any] | None = None,
+        registry: Any = None,
     ) -> None:
         self.repository = repository
         self.config = config or {}
         self.validators = validators or []
+        from sendparcel.registry import registry as default_registry
+
+        self.registry = registry or default_registry
 
     async def create_shipment(
         self,
-        order: Order,
         provider_slug: str,
-        **kwargs,
-    ) -> Shipment:
-        """Create a shipment record for an order."""
-        registry.get_by_slug(provider_slug)
+        *,
+        sender_address: AddressInfo,
+        receiver_address: AddressInfo,
+        parcels: list[ParcelInfo],
+        **kwargs: Any,
+    ) -> CreateShipmentOutcome:
+        """Create a shipment record with explicit address and parcel data."""
+
+        self.registry.get_by_slug(provider_slug)
         shipment = await self.repository.create(
-            order=order,
             provider=provider_slug,
-            status=ShipmentStatus.NEW,
+            status=ShipmentStatus.NEW.value,
             **kwargs,
         )
-        create_shipment_machine(shipment)
         provider = self._get_provider(shipment)
-        result = await self._call_provider(provider.create_shipment(**kwargs))
-        shipment.external_id = result.get("external_id", "")
-        shipment.tracking_number = result.get("tracking_number", "")
-        self._trigger(shipment, "confirm_created")
-        label = result.get("label") or {}
-        label_url = label.get("url", "")
-        if label_url:
-            shipment.label_url = label_url
-            if shipment.may_trigger("confirm_label"):  # ty: ignore[unresolved-attribute]  # dynamic FSM trigger guard
-                shipment.confirm_label()  # ty: ignore[unresolved-attribute]  # dynamic FSM trigger
-        return await self.repository.save(shipment)
+        result = await self._call_provider(
+            provider.create_shipment(
+                sender_address=sender_address,
+                receiver_address=receiver_address,
+                parcels=parcels,
+                **kwargs,
+            )
+        )
+        shipment.external_id = str(result.get("external_id", ""))
+        shipment.tracking_number = str(result.get("tracking_number", ""))
+        transition_shipment(shipment, ShipmentStatus.CREATED)
+        label = result.get("label")
+        if label is not None:
+            transition_shipment(shipment, ShipmentStatus.LABEL_READY)
+        saved = await self.repository.save(shipment)
+        return CreateShipmentOutcome(shipment=saved, label=label)
+
+    async def create_label(
+        self, shipment: Shipment, **kwargs: Any
+    ) -> CreateLabelOutcome:
+        """Create provider label and persist shipment metadata."""
 
-    async def create_label(self, shipment: Shipment, **kwargs) -> Shipment:
-        """Create provider label and persist shipment."""
         run_validators({"shipment": shipment}, validators=self.validators)
-        create_shipment_machine(shipment)
         provider = self._get_provider(shipment)
+        if not isinstance(provider, LabelProvider):
+            raise ProviderCapabilityError(
+                f"Provider {shipment.provider!r} does not support "
+                "label creation"
+            )
         label = await self._call_provider(provider.create_label(**kwargs))
-        shipment.label_url = label.get("url", "")
-        if shipment.may_trigger("confirm_label"):  # ty: ignore[unresolved-attribute]  # dynamic FSM trigger guard
-            shipment.confirm_label()  # ty: ignore[unresolved-attribute]  # dynamic FSM trigger
-        return await self.repository.save(shipment)
+        transition_shipment(shipment, ShipmentStatus.LABEL_READY)
+        saved = await self.repository.save(shipment)
+        return CreateLabelOutcome(shipment=saved, label=label)
 
     async def handle_callback(
         self,
         shipment: Shipment,
-        data: dict,
-        headers: dict,
-        **kwargs,
-    ) -> Shipment:
+        data: dict[str, Any],
+        headers: dict[str, Any],
+        **kwargs: Any,
+    ) -> ShipmentUpdateOutcome:
         """Verify and apply provider callback."""
+
         provider = self._get_provider(shipment)
-        create_shipment_machine(shipment)
+        if not isinstance(provider, PushCallbackProvider):
+            raise ProviderCapabilityError(
+                f"Provider {shipment.provider!r} does not support "
+                "push callbacks"
+            )
         await self._call_provider(
             provider.verify_callback(data, headers, **kwargs)
         )
-        await self._call_provider(
+        update = await self._call_provider(
             provider.handle_callback(data, headers, **kwargs)
         )
-        return await self.repository.save(shipment)
+        normalized_update = update or ShipmentUpdateResult()
+        saved = await self._apply_update(shipment, normalized_update)
+        return ShipmentUpdateOutcome(shipment=saved, update=normalized_update)
 
-    async def fetch_and_update_status(self, shipment: Shipment) -> Shipment:
+    async def fetch_and_update_status(
+        self, shipment: Shipment
+    ) -> ShipmentUpdateOutcome:
         """Fetch status from provider and persist."""
+
         provider = self._get_provider(shipment)
-        create_shipment_machine(shipment)
-        response = await self._call_provider(provider.fetch_shipment_status())
-        status_value = response.get("status")
-        callback = self._resolve_callback(status_value)
-        if callback:
-            self._trigger(shipment, callback)
-        return await self.repository.save(shipment)
+        if not isinstance(provider, PullStatusProvider):
+            raise ProviderCapabilityError(
+                f"Provider {shipment.provider!r} does not support "
+                "status polling"
+            )
+        update = await self._call_provider(provider.fetch_shipment_status())
+        normalized_update = update or ShipmentUpdateResult()
+        saved = await self._apply_update(shipment, normalized_update)
+        return ShipmentUpdateOutcome(shipment=saved, update=normalized_update)
 
-    async def cancel_shipment(self, shipment: Shipment, **kwargs) -> bool:
+    async def cancel_shipment(self, shipment: Shipment, **kwargs: Any) -> bool:
         """Cancel shipment via provider and persist state."""
+
         provider = self._get_provider(shipment)
-        create_shipment_machine(shipment)
+        if not isinstance(provider, CancellableProvider):
+            raise ProviderCapabilityError(
+                f"Provider {shipment.provider!r} does not support cancellation"
+            )
         cancelled = await self._call_provider(
             provider.cancel_shipment(**kwargs)
         )
         if cancelled:
-            self._trigger(shipment, "cancel")
+            transition_shipment(shipment, ShipmentStatus.CANCELLED)
             await self.repository.save(shipment)
-        return cancelled
+        return bool(cancelled)
 
-    def _get_provider(self, shipment: Shipment):
-        provider_class = registry.get_by_slug(shipment.provider)
+    def _get_provider(self, shipment: Shipment) -> BaseProvider:
+        provider_class = self.registry.get_by_slug(shipment.provider)
         provider_config = self.config.get(shipment.provider, {})
         return provider_class(shipment, config=provider_config)
 
-    async def _call_provider(self, coro):
+    async def _apply_update(
+        self, shipment: Shipment, update: ShipmentUpdateResult
+    ) -> Shipment:
+        tracking_number = update.get("tracking_number")
+        if tracking_number:
+            shipment.tracking_number = str(tracking_number)
+        status = update.get("status")
+        if status is not None:
+            transition_shipment(shipment, status)
+        return await self.repository.save(shipment)
+
+    async def _call_provider(self, coro: Any) -> Any:
         """Call a provider coroutine, wrapping non-domain errors."""
+
         try:
             return await coro
         except SendParcelException:
@@ -131,34 +191,3 @@ class ShipmentFlow:
                 str(exc),
                 context={"original_error": type(exc).__name__},
             ) from exc
-
-    def _resolve_callback(self, status_value: str | None) -> str | None:
-        """Map a provider status value to an FSM callback name.
-
-        Only accepts values from STATUS_TO_CALLBACK mapping.
-        Raw callback names (e.g., "cancel") are NOT accepted as
-        status values -- providers must return status enum values
-        (e.g., "cancelled").
-        """
-        if status_value is None:
-            return None
-        callback = STATUS_TO_CALLBACK.get(status_value)
-        if callback:
-            return callback
-        raise InvalidTransitionError(
-            f"Unknown status value {status_value!r}. "
-            f"Expected one of: {', '.join(sorted(STATUS_TO_CALLBACK))}"
-        )
-
-    def _trigger(self, shipment: Shipment, callback: str, **kwargs) -> None:
-        trigger = getattr(shipment, callback, None)
-        if trigger is None or not callable(trigger):
-            raise InvalidTransitionError(
-                f"Shipment has no callback trigger {callback!r}"
-            )
-        if not shipment.may_trigger(callback):  # ty: ignore[unresolved-attribute]  # dynamic FSM trigger guard
-            raise InvalidTransitionError(
-                f"Callback {callback!r} cannot be executed from status "
-                f"{shipment.status!r}"
-            )
-        trigger(**kwargs)