karrio-canadapost 2025.5rc1__py3-none-any.whl

karrio/mappers/canadapost/__init__.py

@@ -0,0 +1,3 @@
+from karrio.mappers.canadapost.mapper import Mapper
+from karrio.mappers.canadapost.proxy import Proxy
+from karrio.mappers.canadapost.settings import Settings

karrio/mappers/canadapost/mapper.py

@@ -0,0 +1,88 @@
+"""Karrio Canada Post client mapper."""
+
+import typing
+import karrio.lib as lib
+import karrio.api.mapper as mapper
+import karrio.core.models as models
+import karrio.providers.canadapost as provider
+import karrio.mappers.canadapost.settings as provider_settings
+
+
+class Mapper(mapper.Mapper):
+    settings: provider_settings.Settings
+
+    def create_rate_request(self, payload: models.RateRequest) -> lib.Serializable:
+        return provider.rate_request(payload, self.settings)
+
+    def create_tracking_request(
+        self, payload: models.TrackingRequest
+    ) -> lib.Serializable:
+        return provider.tracking_request(payload, self.settings)
+
+    def create_shipment_request(
+        self, payload: models.ShipmentRequest
+    ) -> lib.Serializable:
+        return provider.shipment_request(payload, self.settings)
+
+    def create_cancel_shipment_request(
+        self, payload: models.ShipmentCancelRequest
+    ) -> lib.Serializable[str]:
+        return provider.shipment_cancel_request(payload, self.settings)
+
+    def create_manifest_request(
+        self, payload: models.ManifestRequest
+    ) -> lib.Serializable:
+        return provider.manifest_request(payload, self.settings)
+
+    def create_pickup_request(self, payload: models.PickupRequest) -> lib.Serializable:
+        return provider.pickup_request(payload, self.settings)
+
+    def create_pickup_update_request(
+        self, payload: models.PickupUpdateRequest
+    ) -> lib.Serializable:
+        return provider.pickup_update_request(payload, self.settings)
+
+    def create_cancel_pickup_request(
+        self, payload: models.PickupCancelRequest
+    ) -> lib.Serializable:
+        return provider.pickup_cancel_request(payload, self.settings)
+
+    def parse_cancel_shipment_response(
+        self, response: lib.Deserializable[str]
+    ) -> typing.Tuple[models.ConfirmationDetails, typing.List[models.Message]]:
+        return provider.parse_shipment_cancel_response(response, self.settings)
+
+    def parse_rate_response(
+        self, response: lib.Deserializable[str]
+    ) -> typing.Tuple[typing.List[models.RateDetails], typing.List[models.Message]]:
+        return provider.parse_rate_response(response, self.settings)
+
+    def parse_shipment_response(
+        self, response: lib.Deserializable[str]
+    ) -> typing.Tuple[models.ShipmentDetails, typing.List[models.Message]]:
+        return provider.parse_shipment_response(response, self.settings)
+
+    def parse_tracking_response(
+        self, response: lib.Deserializable[str]
+    ) -> typing.Tuple[typing.List[models.TrackingDetails], typing.List[models.Message]]:
+        return provider.parse_tracking_response(response, self.settings)
+
+    def parse_manifest_response(
+        self, response: lib.Deserializable[str]
+    ) -> typing.Tuple[models.ManifestDetails, typing.List[models.Message]]:
+        return provider.parse_manifest_response(response, self.settings)
+
+    def parse_pickup_response(
+        self, response: lib.Deserializable[str]
+    ) -> typing.Tuple[models.PickupDetails, typing.List[models.Message]]:
+        return provider.parse_pickup_response(response, self.settings)
+
+    def parse_pickup_update_response(
+        self, response: lib.Deserializable[str]
+    ) -> typing.Tuple[models.PickupDetails, typing.List[models.Message]]:
+        return provider.parse_pickup_update_response(response, self.settings)
+
+    def parse_pickup_cancel_response(
+        self, response: lib.Deserializable[str]
+    ) -> typing.Tuple[models.ConfirmationDetails, typing.List[models.Message]]:
+        return provider.parse_pickup_cancel_response(response, self.settings)

karrio/mappers/canadapost/proxy.py

@@ -0,0 +1,373 @@
+import time
+import typing
+import karrio.lib as lib
+import karrio.api.proxy as proxy
+import karrio.providers.canadapost.utils as provider_utils
+import karrio.mappers.canadapost.settings as provider_settings
+
+
+class Proxy(proxy.Proxy):
+    settings: provider_settings.Settings
+
+    def get_rates(self, requests: lib.Serializable) -> lib.Deserializable:
+        responses = lib.run_asynchronously(
+            lambda data: lib.request(
+                url=f"{self.settings.server_url}/rs/ship/price",
+                trace=self.trace_as("xml"),
+                method="POST",
+                data=data,
+                headers={
+                    "Content-Type": "application/vnd.cpc.ship.rate-v4+xml",
+                    "Accept": "application/vnd.cpc.ship.rate-v4+xml",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept-language": f"{self.settings.language}-CA",
+                },
+            ),
+            requests.serialize(),
+        )
+
+        return lib.Deserializable(
+            responses,
+            lambda __: [lib.to_element(_) for _ in __],
+        )
+
+    def get_tracking(self, request: lib.Serializable) -> lib.Deserializable:
+        """get_tracking make parallel request for each pin"""
+        _throttle = 0.0
+
+        def _track(tracking_pin: str) -> str:
+            nonlocal _throttle
+            time.sleep(_throttle)
+            _throttle += 0.025
+
+            return lib.request(
+                url=f"{self.settings.server_url}/vis/track/pin/{tracking_pin}/detail",
+                trace=self.trace_as("xml"),
+                method="GET",
+                headers={
+                    "Accept": "application/vnd.cpc.track-v2+xml",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept-language": f"{self.settings.language}-CA",
+                },
+            )
+
+        responses: typing.List[str] = lib.run_asynchronously(
+            _track,
+            request.serialize(),
+        )
+
+        return lib.Deserializable(responses, lib.to_element)
+
+    def create_shipment(self, requests: lib.Serializable) -> lib.Deserializable:
+        shipment_responses = lib.run_asynchronously(
+            lambda data: lib.request(
+                url=f"{self.settings.server_url}/rs/{self.settings.customer_number}/{self.settings.customer_number}/shipment",
+                data=data,
+                trace=self.trace_as("xml"),
+                method="POST",
+                headers={
+                    "Content-Type": "application/vnd.cpc.shipment-v8+xml",
+                    "Accept": "application/vnd.cpc.shipment-v8+xml",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept-language": f"{self.settings.language}-CA",
+                },
+            ),
+            requests.serialize(),
+        )
+        responses: typing.List[dict] = lib.run_asynchronously(
+            lambda data: dict(
+                shipment=data["shipment"],
+                label=(
+                    lib.request(
+                        decoder=lib.encode_base64,
+                        url=data["href"],
+                        method="GET",
+                        headers={
+                            "Authorization": f"Basic {self.settings.authorization}",
+                            "Accept": data["media"],
+                        },
+                    )
+                    if data["href"] is not None
+                    else None
+                ),
+            ),
+            [
+                {**provider_utils.parse_label_references(_), "shipment": _}
+                for _ in shipment_responses
+            ],
+        )
+
+        return lib.Deserializable(
+            responses,
+            lambda __: [(lib.to_element(_["shipment"]), _["label"]) for _ in __],
+            requests.ctx,
+        )
+
+    def cancel_shipment(self, requests: lib.Serializable) -> lib.Deserializable:
+        # retrieve shipment infos to check if refund is necessary
+        infos: typing.List[typing.Tuple[str, str]] = lib.run_asynchronously(
+            lambda shipment_id: (
+                shipment_id,
+                lib.request(
+                    url=f"{self.settings.server_url}/rs/{self.settings.customer_number}/{self.settings.customer_number}/shipment/{shipment_id}",
+                    trace=self.trace_as("xml"),
+                    method="GET",
+                    headers={
+                        "Content-Type": "application/vnd.cpc.shipment-v8+xml",
+                        "Accept": "application/vnd.cpc.shipment-v8+xml",
+                        "Authorization": f"Basic {self.settings.authorization}",
+                        "Accept-language": f"{self.settings.language}-CA",
+                    },
+                ),
+            ),
+            requests.serialize(),
+        )
+
+        # make refund requests for submitted shipments
+        refunds: typing.List[typing.Tuple[str, str]] = lib.run_asynchronously(
+            lambda payload: (
+                payload["id"],
+                (
+                    lib.request(
+                        url=f"{self.settings.server_url}/rs/{self.settings.customer_number}/{self.settings.customer_number}/shipment/{payload['id']}/refund",
+                        trace=self.trace_as("xml"),
+                        data=payload["data"],
+                        method="POST",
+                        headers={
+                            "Content-Type": "application/vnd.cpc.shipment-v8+xml",
+                            "Accept": "application/vnd.cpc.shipment-v8+xml",
+                            "Authorization": f"Basic {self.settings.authorization}",
+                            "Accept-language": f"{self.settings.language}-CA",
+                        },
+                    )
+                    if payload["data"] is not None
+                    else payload["info"]
+                ),
+            ),
+            [
+                dict(
+                    id=_,
+                    info=info,
+                    data=provider_utils.parse_submitted_shipment(info, requests.ctx),
+                )
+                for _, info in infos
+            ],
+        )
+
+        # make cancel requests for non-submitted shipments
+        responses: typing.List[typing.Tuple[str, str]] = lib.run_asynchronously(
+            lambda payload: (
+                payload["id"],
+                (
+                    lib.request(
+                        url=f"{self.settings.server_url}/rs/{self.settings.customer_number}/{self.settings.customer_number}/shipment/{payload['id']}",
+                        trace=self.trace_as("xml"),
+                        method="DELETE",
+                        headers={
+                            "Content-Type": "application/vnd.cpc.shipment-v8+xml",
+                            "Accept": "application/vnd.cpc.shipment-v8+xml",
+                            "Authorization": f"Basic {self.settings.authorization}",
+                            "Accept-language": f"{self.settings.language}-CA",
+                        },
+                    )
+                    if payload["refunded"]
+                    else payload["response"]
+                ),
+            ),
+            [
+                dict(
+                    id=_,
+                    response=response,
+                    refunded=(
+                        getattr(lib.to_element(response), "tag", None)
+                        != "shipment-refund-request-info"
+                    ),
+                )
+                for _, response in refunds
+            ],
+        )
+
+        return lib.Deserializable(
+            responses, lambda ___: [(_, lib.to_element(__)) for _, __ in ___]
+        )
+
+    def schedule_pickup(self, request: lib.Serializable) -> lib.Deserializable:
+        def _availability(job: lib.Job) -> str:
+            return lib.request(
+                url=f"{self.settings.server_url}/ad/pickup/pickupavailability/{job.data}",
+                trace=self.trace_as("xml"),
+                method="GET",
+                headers={
+                    "Accept": "application/vnd.cpc.pickup+xml",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept-language": f"{self.settings.language}-CA",
+                },
+            )
+
+        def _create_pickup(job: lib.Job) -> str:
+            return lib.request(
+                url=f"{self.settings.server_url}/enab/{self.settings.customer_number}/pickuprequest",
+                data=job.data.serialize(),
+                trace=self.trace_as("xml"),
+                method="POST",
+                headers={
+                    "Accept": "application/vnd.cpc.pickuprequest+xml",
+                    "Content-Type": "application/vnd.cpc.pickuprequest+xml",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept-language": f"{self.settings.language}-CA",
+                },
+            )
+
+        def _process(job: lib.Job):
+            if job.data is None:
+                return job.fallback
+
+            subprocess = {
+                "create_pickup": _create_pickup,
+                "availability": _availability,
+            }
+            if job.id not in subprocess:
+                raise lib.ShippingSDKError(f"Unknown pickup request job id: {job.id}")
+
+            return subprocess[job.id](job)
+
+        pipeline: lib.Pipeline = request.serialize()
+        responses = pipeline.apply(_process)
+
+        return lib.Deserializable(responses, lib.to_element)
+
+    def modify_pickup(self, request: lib.Serializable) -> lib.Deserializable:
+        def _get_pickup(job: lib.Job) -> str:
+            return lib.request(
+                url=f"{self.settings.server_url}{job.data.serialize()}",
+                trace=self.trace_as("xml"),
+                method="GET",
+                headers={
+                    "Accept": "application/vnd.cpc.pickup+xml",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept-language": f"{self.settings.language}-CA",
+                },
+            )
+
+        def _update_pickup(job: lib.Job) -> str:
+            payload = job.data.serialize()
+            return lib.request(
+                url=f"{self.settings.server_url}/enab/{self.settings.customer_number}/pickuprequest/{payload['pickuprequest']}",
+                data=payload["data"],
+                trace=self.trace_as("xml"),
+                method="PUT",
+                headers={
+                    "Accept": "application/vnd.cpc.pickuprequest+xml",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept-language": f"{self.settings.language}-CA",
+                },
+            )
+
+        def _process(job: lib.Job):
+            if job.data is None:
+                return job.fallback
+
+            subprocess = {
+                "update_pickup": _update_pickup,
+                "get_pickup": _get_pickup,
+            }
+            if job.id not in subprocess:
+                raise lib.ShippingSDKError(f"Unknown pickup request job id: {job.id}")
+
+            return subprocess[job.id](job)
+
+        pipeline: lib.Pipeline = request.serialize()
+        responses = pipeline.apply(_process)
+
+        return lib.Deserializable(responses, lib.to_element)
+
+    def cancel_pickup(self, request: lib.Serializable) -> lib.Deserializable:
+        pickuprequest = request.serialize()
+        response = lib.request(
+            url=f"{self.settings.server_url}/enab/{self.settings.customer_number}/pickuprequest/{pickuprequest}",
+            trace=self.trace_as("xml"),
+            method="DELETE",
+            headers={
+                "Accept": "application/vnd.cpc.pickuprequest+xml",
+                "Authorization": f"Basic {self.settings.authorization}",
+                "Accept-language": f"{self.settings.language}-CA",
+            },
+        )
+
+        return lib.Deserializable(response or "<wrapper></wrapper>", lib.to_element)
+
+    def create_manifest(self, request: lib.Serializable) -> lib.Deserializable:
+        ctx = request.ctx.copy()
+        data = request.serialize()
+
+        if ctx["retrieve_shipments"]:
+            shipments = lib.run_asynchronously(
+                lambda pin: lib.request(
+                    url=f"{self.settings.server_url}/{self.settings.customer_number}/{self.settings.customer_number}/shipment/{pin}/details",
+                    trace=self.trace_as("xml"),
+                    method="GET",
+                    headers={
+                        "Accept": "application/vnd.cpc.shipment-v8+xml",
+                        "Authorization": f"Basic {self.settings.authorization}",
+                        "Accept-language": f"{self.settings.language}-CA",
+                    },
+                ),
+                ctx["shipment_identifiers"],
+            )
+
+            group_ids = [
+                _.text for _ in lib.find_element("group-id", lib.to_element(shipments))
+            ]
+            ctx.update(group_ids=[*set([*ctx["group_ids"], *group_ids])])
+
+        response = lib.request(
+            url=f"{self.settings.server_url}/rs/{self.settings.customer_number}/{self.settings.customer_number}/manifest",
+            data=data.replace(
+                "<group-id>[GROUP_IDS]</group-id>",
+                "".join(f"<group-id>{_}</group-id>" for _ in ctx["group_ids"]),
+            ),
+            trace=self.trace_as("xml"),
+            method="POST",
+            headers={
+                "Content-Type": "application/vnd.cpc.manifest-v8+xml",
+                "Accept": "application/vnd.cpc.manifest-v8+xml",
+                "Authorization": f"Basic {self.settings.authorization}",
+                "Accept-language": f"{self.settings.language}-CA",
+            },
+        )
+
+        manifests = lib.run_asynchronously(
+            lambda link: lib.request(
+                url=link.get("href"),
+                trace=self.trace_as("xml"),
+                headers={
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept": (
+                        lib.text(link.get("media-type"))
+                        or "application/vnd.cpc.manifest-v8+xml"
+                    ),
+                },
+            ),
+            lib.find_element("link", lib.to_element(response)),
+        )
+
+        if any(manifests):
+            ctx.update(
+                files=lib.run_asynchronously(
+                    lambda link: lib.request(
+                        decoder=lib.encode_base64,
+                        url=link.get("href"),
+                        headers={
+                            "Authorization": f"Basic {self.settings.authorization}",
+                            "Accept": link.get("media-type"),
+                        },
+                    ),
+                    [
+                        _
+                        for _ in lib.find_element("link", lib.to_element(manifests))
+                        if _.get("rel") == "artifact"
+                    ],
+                )
+            )
+
+        return lib.Deserializable(response, lib.to_element, ctx)

karrio/mappers/canadapost/settings.py

@@ -0,0 +1,23 @@
+"""Karrio Canada post client settings."""
+
+import attr
+import karrio.lib as lib
+import karrio.providers.canadapost.utils as utils
+
+
+@attr.s(auto_attribs=True)
+class Settings(utils.Settings):
+    """Canada post connection settings."""
+
+    username: str
+    password: str
+    customer_number: str = None
+    contract_id: str = None
+    language: utils.LanguageEnum = "en"  # type: ignore
+
+    id: str = None
+    test_mode: bool = False
+    carrier_id: str = "canadapost"
+    account_country_code: str = "CA"
+    metadata: dict = {}
+    config: dict = {}

karrio/plugins/canadapost/__init__.py

@@ -0,0 +1,23 @@
+import karrio.core.metadata as metadata
+import karrio.mappers.canadapost as mappers
+import karrio.providers.canadapost.units as units
+
+
+METADATA = metadata.PluginMetadata(
+    status="production-ready",
+    id="canadapost",
+    label="Canada Post",
+    # Integrations
+    Mapper=mappers.Mapper,
+    Proxy=mappers.Proxy,
+    Settings=mappers.Settings,
+    # Data Units
+    options=units.ShippingOption,
+    package_presets=units.PackagePresets,
+    services=units.ServiceType,
+    connection_configs=units.ConnectionConfig,
+    # New fields
+    website="https://www.canadapost-postescanada.ca/cpc/en/home.page",
+    documentation="https://www.canadapost-postescanada.ca/information/app/drc/home",
+    description="Mailing and shipping for Personal and Business.",
+)

karrio/providers/canadapost/__init__.py

@@ -0,0 +1,25 @@
+from karrio.providers.canadapost.utils import Settings
+from karrio.providers.canadapost.error import process_error
+from karrio.providers.canadapost.rate import parse_rate_response, rate_request
+from karrio.providers.canadapost.shipment import (
+    parse_shipment_cancel_response,
+    parse_shipment_response,
+    shipment_cancel_request,
+    shipment_request,
+)
+from karrio.providers.canadapost.pickup import (
+    parse_pickup_cancel_response,
+    parse_pickup_update_response,
+    parse_pickup_response,
+    pickup_update_request,
+    pickup_cancel_request,
+    pickup_request,
+)
+from karrio.providers.canadapost.tracking import (
+    parse_tracking_response,
+    tracking_request,
+)
+from karrio.providers.canadapost.manifest import (
+    parse_manifest_response,
+    manifest_request,
+)

karrio/providers/canadapost/error.py

@@ -0,0 +1,42 @@
+import karrio.schemas.canadapost.messages as canadapost
+
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+from karrio.providers.canadapost import Settings
+from urllib.error import HTTPError
+
+
+def parse_error_response(
+    responses: typing.Union[lib.Element, typing.List[lib.Element]],
+    settings: Settings,
+    **kwargs,
+) -> typing.List[models.Message]:
+    messages: typing.List[canadapost.messageType] = sum(
+        [
+            lib.find_element("message", response, canadapost.messageType)
+            for response in lib.to_list(responses)
+        ],
+        start=[],
+    )
+
+    return [
+        models.Message(
+            code=message.code,
+            message=message.description,
+            carrier_name=settings.carrier_name,
+            carrier_id=settings.carrier_id,
+            details={**kwargs},
+        )
+        for message in messages
+    ]
+
+
+def process_error(error: HTTPError) -> str:
+    return f"""<messages xmlns="http://www.canadapost.ca/ws/messages">
+        <message>
+            <code>{error.code}</code>
+            <description>{typing.cast(typing.Any, error).msg}</description>
+        </message>
+    </messages>
+    """