karrio-dicom 2025.5rc1__py3-none-any.whl

karrio/mappers/dicom/__init__.py

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

karrio/mappers/dicom/mapper.py

@@ -0,0 +1,107 @@
+from typing import List, Tuple
+from karrio.core.utils.serializable import Serializable, Deserializable
+from karrio.api.mapper import Mapper as BaseMapper
+from karrio.core.models import (
+    # ShipmentCancelRequest,
+    # PickupUpdateRequest,
+    # PickupCancelRequest,
+    # ShipmentRequest,
+    TrackingRequest,
+    # PickupRequest,
+    # RateRequest,
+    #
+    # ConfirmationDetails,
+    TrackingDetails,
+    # ShipmentDetails,
+    # PickupDetails,
+    # RateDetails,
+    Message,
+)
+from karrio.providers.dicom import (
+    # parse_shipment_cancel_response,
+    # parse_pickup_update_response,
+    # parse_pickup_cancel_response,
+    # parse_shipment_response,
+    parse_tracking_response,
+    # parse_pickup_response,
+    # parse_rate_response,
+    #
+    # shipment_cancel_request,
+    # pickup_update_request,
+    # pickup_cancel_request,
+    tracking_request,
+    # shipment_request,
+    # pickup_request,
+    # rate_request,
+)
+from karrio.mappers.dicom.settings import Settings
+
+
+class Mapper(BaseMapper):
+    settings: Settings
+
+    # def create_rate_request(
+    #     self, payload: RateRequest
+    # ) -> Serializable:
+    #     return rate_request(payload, self.settings)
+
+    def create_tracking_request(self, payload: TrackingRequest) -> Serializable:
+        return tracking_request(payload, self.settings)
+
+    # def create_shipment_request(
+    #     self, payload: ShipmentRequest
+    # ) -> Serializable:
+    #     return shipment_request(payload, self.settings)
+    #
+    # def create_pickup_request(
+    #     self, payload: PickupRequest
+    # ) -> Serializable:
+    #     return pickup_request(payload, self.settings)
+    #
+    # def create_pickup_update_request(
+    #     self, payload: PickupUpdateRequest
+    # ) -> Serializable:
+    #     return pickup_update_request(payload, self.settings)
+    #
+    # def create_cancel_pickup_request(
+    #     self, payload: PickupCancelRequest
+    # ) -> Serializable:
+    #     return pickup_cancel_request(payload, self.settings)
+    #
+    # def create_cancel_shipment_request(self, payload: ShipmentCancelRequest) -> Serializable:
+    #     return shipment_cancel_request(payload, self.settings)
+
+    # def parse_cancel_pickup_response(
+    #     self, response: Deserializable
+    # ) -> Tuple[ConfirmationDetails, List[Message]]:
+    #     return parse_pickup_cancel_response(response, self.settings)
+    #
+    # def parse_cancel_shipment_response(
+    #     self, response: Deserializable
+    # ) -> Tuple[ConfirmationDetails, List[Message]]:
+    #     return parse_shipment_cancel_response(response, self.settings)
+    #
+    # def parse_pickup_response(
+    #     self, response: Deserializable
+    # ) -> Tuple[PickupDetails, List[Message]]:
+    #     return parse_pickup_response(response, self.settings)
+    #
+    # def parse_pickup_update_response(
+    #     self, response: Deserializable
+    # ) -> Tuple[PickupDetails, List[Message]]:
+    #     return parse_pickup_update_response(response, self.settings)
+    #
+    # def parse_rate_response(
+    #     self, response: Deserializable
+    # ) -> Tuple[List[RateDetails], List[Message]]:
+    #     return parse_rate_response(response, self.settings)
+    #
+    # def parse_shipment_response(
+    #     self, response: Deserializable
+    # ) -> Tuple[ShipmentDetails, List[Message]]:
+    #     return parse_shipment_response(response, self.settings)
+
+    def parse_tracking_response(
+        self, response: Deserializable
+    ) -> Tuple[List[TrackingDetails], List[Message]]:
+        return parse_tracking_response(response, self.settings)

karrio/mappers/dicom/proxy.py

@@ -0,0 +1,31 @@
+from typing import List
+from karrio.core.utils import (
+    Serializable,
+    Deserializable,
+    request as http,
+    exec_async,
+    DP,
+)
+from karrio.api.proxy import Proxy as BaseProxy
+from karrio.mappers.dicom.settings import Settings
+
+
+class Proxy(BaseProxy):
+    settings: Settings
+
+    def get_tracking(self, request: Serializable) -> Deserializable:
+        def _get_tracking(tracking_number: str):
+            return http(
+                url=f"{self.settings.server_url}/v1/tracking/{tracking_number}",
+                trace=self.trace_as("json"),
+                method="GET",
+                headers={
+                    "Accept": "application/json",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                },
+            )
+
+        responses: List[dict] = exec_async(_get_tracking, request.serialize())
+        return Deserializable(
+            responses, lambda res: [DP.to_dict(r) for r in res if any(r.strip())]
+        )

karrio/mappers/dicom/settings.py

@@ -0,0 +1,22 @@
+"""Karrio Dicom client settings."""
+
+import attr
+from karrio.providers.dicom.utils import Settings as BaseSettings
+
+
+@attr.s(auto_attribs=True)
+class Settings(BaseSettings):
+    """Dicom connection settings."""
+
+    # Carrier specific properties
+    username: str
+    password: str
+    billing_account: str = None
+
+    # Base properties
+    id: str = None
+    test_mode: bool = False
+    carrier_id: str = "dicom"
+    account_country_code: str = None
+    metadata: dict = {}
+    config: dict = {}

karrio/plugins/dicom/__init__.py

@@ -0,0 +1,16 @@
+import karrio.core.metadata as metadata
+import karrio.mappers.dicom as mappers
+
+
+METADATA = metadata.PluginMetadata(
+    status="beta",
+    id="dicom",
+    label="Dicom",
+
+    # Integrations
+    Mapper=mappers.Mapper,
+    Proxy=mappers.Proxy,
+    Settings=mappers.Settings,
+
+    # Data Units
+)

karrio/providers/dicom/__init__.py

@@ -0,0 +1,20 @@
+# from karrio.providers.dicom.utils import Settings
+# from karrio.providers.dicom.rate import parse_rate_response, rate_request
+# from karrio.providers.dicom.shipment import (
+#     parse_shipment_cancel_response,
+#     parse_shipment_response,
+#     shipment_cancel_request,
+#     shipment_request,
+# )
+# from karrio.providers.dicom.pickup import (
+#     parse_pickup_cancel_response,
+#     parse_pickup_update_response,
+#     parse_pickup_response,
+#     pickup_update_request,
+#     pickup_cancel_request,
+#     pickup_request,
+# )
+from karrio.providers.dicom.tracking import (
+    parse_tracking_response,
+    tracking_request,
+)

karrio/providers/dicom/error.py

@@ -0,0 +1,19 @@
+from typing import List
+from karrio.providers.sendle import Settings
+from karrio.core.models import Message
+
+
+def parse_error_response(response: List[dict], settings: Settings) -> List[Message]:
+    return [_extract_error(e, settings) for e in response]
+
+
+def _extract_error(carrier_error: dict, settings: Settings) -> Message:
+    return Message(
+        # context info
+        carrier_name=settings.carrier_name,
+        carrier_id=settings.carrier_id,
+
+        # carrier error info
+        code=carrier_error.get('Code'),
+        message=carrier_error.get('Message')
+    )

karrio/providers/dicom/pickup/__init__.py

@@ -0,0 +1,3 @@
+from karrio.providers.dicom.pickup.create import parse_pickup_response, pickup_request
+from karrio.providers.dicom.pickup.update import parse_pickup_update_response, pickup_update_request
+from karrio.providers.dicom.pickup.cancel import parse_pickup_cancel_response, pickup_cancel_request

karrio/providers/dicom/pickup/cancel.py

@@ -0,0 +1,33 @@
+from typing import Tuple, List
+from karrio.core.utils import Serializable
+from karrio.core.models import PickupCancelRequest, ConfirmationDetails, Message
+
+from karrio.providers.dicom.error import parse_error_response
+from karrio.providers.dicom.utils import Settings
+import karrio.lib as lib
+
+
+def parse_pickup_cancel_response(
+    _response: lib.Deserializable[dict],
+    settings: Settings,
+) -> Tuple[ConfirmationDetails, List[Message]]:
+    response = _response.deserialize()
+    errors = parse_error_response(response, settings)
+    details = (
+        ConfirmationDetails(
+            carrier_id=settings.carrier_id,
+            carrier_name=settings.carrier_name,
+            success=True,
+            operation="Pickup Cancel",
+        )
+        if not any(errors)
+        else None
+    )
+
+    return details, errors
+
+
+def pickup_cancel_request(payload: PickupCancelRequest, _) -> Serializable:
+    request = payload.confirmation_number
+
+    return Serializable(request)

karrio/providers/dicom/pickup/create.py

@@ -0,0 +1,102 @@
+import urllib.parse
+from typing import Tuple, List
+from functools import partial
+from karrio.schemas.dicom.pickups import (
+    PickupRequest as DicomPickupRequest,
+    Sender,
+    Contact,
+    Pickup,
+)
+from karrio.core.utils import Serializable, Pipeline, Job, DP, SF
+from karrio.core.models import PickupRequest, PickupDetails, Message
+
+from karrio.providers.dicom.error import parse_error_response
+from karrio.providers.dicom.utils import Settings
+import karrio.lib as lib
+
+
+def parse_pickup_response(
+    _response: lib.Deserializable[dict], settings: Settings
+) -> Tuple[PickupDetails, List[Message]]:
+    response = _response.deserialize()
+    errors = parse_error_response(response, settings)
+    pickup = next(
+        (DP.to_object(Pickup, pickup) for pickup in response.get("pickups", [])), None
+    )
+    details = _extract_details(pickup, settings) if pickup is not None else None
+
+    return details, errors
+
+
+def _extract_details(pickup: Pickup, settings: Settings) -> PickupDetails:
+    return PickupDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        confirmation_number=str(pickup.id),
+        closing_time=pickup.officeClose,
+        pickup_date=pickup.date,
+        ready_time=pickup.ready,
+    )
+
+
+def pickup_request(payload: PickupRequest, settings: Settings) -> Serializable:
+    request: Pipeline = Pipeline(
+        create_pickup=lambda *_: _create_pickup(payload),
+        retrieve_pickup=partial(_retrieve_pickup, payload=payload, settings=settings),
+    )
+
+    return Serializable(request)
+
+
+def _create_pickup(payload: PickupRequest) -> Job:
+    request = DicomPickupRequest(
+        date=payload.pickup_date,
+        ready=payload.ready_time,
+        category=payload.options.get("category", "Parcel"),
+        officeClose=payload.closing_time,
+        sender=Sender(
+            city=payload.address.city,
+            provinceCode=payload.address.state_code,
+            postalCode=payload.address.postal_code,
+            countryCode=payload.address.country_code,
+            customerName=payload.address.company_name,
+            streetNumber=payload.address.street_number,
+            contact=Contact(
+                fullName=payload.address.person_name,
+                email=payload.address.email,
+                telephone=payload.address.phone_number,
+            ),
+        ),
+        location=payload.options.get("dicom_location", "OT"),
+        otherLocation=payload.package_location,
+    )
+
+    return Job(id="create_pickup", data=Serializable(request, DP.to_dict))
+
+
+def _retrieve_pickup(
+    creation_response: str, payload: PickupRequest, settings: Settings
+) -> Job:
+    errors = parse_error_response(DP.to_dict(creation_response), settings)
+    data = (
+        Serializable(
+            dict(
+                category=payload.options.get("category", "Parcel"),
+                pickupDate=payload.pickup_date,
+                streetNumber=SF.concat_str(
+                    payload.address.address_line1,
+                    payload.address.address_line2,
+                    join=True,
+                ),
+                postalCode=payload.address.postal_code,
+                offset=10,
+            ),
+            urllib.parse.urlencode,
+        )
+        if not any(errors)
+        else None
+    )
+
+    return Job(
+        id="retrieve_pickup", data=data, fallback=("{}" if data is None else None)
+    )

karrio/providers/dicom/pickup/update.py

@@ -0,0 +1,57 @@
+from typing import Tuple, List, cast
+from functools import partial
+from karrio.core.utils import Serializable, Pipeline, Job
+from karrio.core.models import (
+    PickupCancelRequest,
+    PickupUpdateRequest,
+    PickupRequest,
+    PickupDetails,
+    Message,
+)
+
+from karrio.providers.dicom.pickup.create import (
+    _create_pickup as _create_pickup_job,
+    parse_pickup_response,
+    _retrieve_pickup,
+)
+from karrio.providers.dicom.pickup.cancel import pickup_cancel_request
+from karrio.providers.dicom.error import parse_error_response
+from karrio.providers.dicom.utils import Settings
+import karrio.lib as lib
+
+
+def parse_pickup_update_response(
+    _response: lib.Deserializable[dict], settings: Settings
+) -> Tuple[PickupDetails, List[Message]]:
+    response = _response.deserialize()
+    return parse_pickup_response(response, settings)
+
+
+def pickup_update_request(
+    payload: PickupUpdateRequest, settings: Settings
+) -> Serializable:
+    request: Pipeline = Pipeline(
+        delete_pickup=lambda *_: _delete_pickup(payload, settings),
+        create_pickup=partial(_create_pickup_job, payload=payload, settings=settings),
+        retrieve_pickup=partial(_retrieve_pickup, payload=payload, settings=settings),
+    )
+
+    return Serializable(request)
+
+
+def _delete_pickup(payload: PickupUpdateRequest, settings: Settings) -> Job:
+    data = pickup_cancel_request(
+        settings=settings, payload=cast(PickupCancelRequest, payload)
+    )
+
+    return Job(id="delete_pickup", data=data)
+
+
+def _create_pickup(deletion_response: str, payload: PickupUpdateRequest) -> Job:
+    errors = parse_error_response(deletion_response)
+    create_job: Job = (
+        _create_pickup_job(cast(PickupRequest, payload)) if not any(errors) else None
+    )
+    data = create_job.data if create_job is not None else None
+
+    return Job(id="create_pickup", data=data, fallback=("{}" if data is None else None))

karrio/providers/dicom/rate.py

@@ -0,0 +1,127 @@
+from karrio.schemas.dicom.rates import (
+    RateRequest as DicomRateRequest,
+    Address,
+    Parcel,
+    Surcharge,
+    Rate,
+    RateResponse,
+)
+
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+import karrio.providers.dicom.error as provider_error
+import karrio.providers.dicom.units as provider_units
+import karrio.providers.dicom.utils as provider_utils
+
+
+def parse_rate_response(
+    _response: lib.Deserializable[dict], settings: provider_utils.Settings
+) -> typing.Tuple[typing.List[models.RateDetails], typing.List[models.Message]]:
+    response = _response.deserialize()
+    errors = provider_error.parse_error_response(response, settings)
+    rate_response = (
+        lib.to_object(RateResponse, response) if "rates" in response else RateResponse()
+    )
+    details = [
+        _extract_details(rate, rate_response, settings)
+        for rate in (rate_response.rates or [])
+    ]
+
+    return details, errors
+
+
+def _extract_details(
+    rate: Rate, response: RateResponse, settings: provider_utils.Settings
+) -> models.RateDetails:
+    charges = [
+        ("Base Charge", rate.basicCharge),
+        ("Discount", rate.discountAmount),
+        ("Taxes", rate.taxes),
+        *((charge.name, charge.amount) for charge in rate.surcharges),
+    ]
+
+    return models.RateDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        currency="CAD",
+        transit_days=response.delay,
+        service=provider_units.Service(rate.rateType),
+        total_charge=lib.to_decimal(rate.total),
+        extra_charges=[
+            provider_units.ChargeDetails(
+                currency="CAD",
+                name=name,
+                amount=lib.to_decimal(charge),
+            )
+            for name, charge in charges
+            if charge
+        ],
+        meta=dict(accountType=rate.accountType),
+    )
+
+
+def rate_request(
+    payload: models.RateRequest, settings: provider_utils.Settings
+) -> lib.Serializable:
+    packages = lib.to_packages(payload.parcels)
+    service = (
+        provider_units.Services(payload.services, provider_units.Service).first
+        or provider_units.Service.dicom_ground_delivery.value
+    ).value
+    options = lib.to_shipping_options(
+        payload.options,
+        package_options=packages.options,
+        initializer=provider_units.shipping_options_initializer,
+    )
+
+    request = DicomRateRequest(
+        category="Parcel",
+        paymentType=provider_units.PaymentType.prepaid.value,
+        deliveryType=service,
+        unitOfMeasurement=provider_units.UnitOfMeasurement.KC.value,
+        sender=Address(
+            postalCode=payload.shipper.postal_code,
+            provinceCode=payload.shipper.state_code,
+            countryCode=payload.shipper.country_code,
+            name=(payload.shipper.company_name or payload.shipper.person_name),
+        ),
+        consignee=Address(
+            postalCode=payload.recipient.postal_code,
+            provinceCode=payload.recipient.state_code,
+            countryCode=payload.recipient.country_code,
+            name=(payload.recipient.company_name or payload.recipient.person_name),
+        ),
+        parcels=[
+            Parcel(
+                quantity=1,
+                parcelType=provider_units.ParcelType[
+                    package.packaging_type or "dicom_box"
+                ].value,
+                id=None,
+                weight=package.weight.KG,
+                length=package.height.CM,
+                depth=package.length.CM,
+                width=package.width.CM,
+                note=None,
+                status=None,
+                FCA_Class=None,
+                hazmat=None,
+                requestReturnLabel=None,
+                returnWaybill=None,
+            )
+            for package in packages
+        ],
+        billing=settings.billing_account,
+        promoCodes=None,
+        surcharges=[
+            Surcharge(
+                type=option.code,
+                value=lib.to_money(option.state),
+            )
+            for _, option in options.items()
+        ],
+        appointment=None,
+    )
+
+    return lib.Serializable(request, lib.to_dict)

karrio/providers/dicom/shipment/__init__.py

@@ -0,0 +1,2 @@
+from karrio.providers.dicom.shipment.create import parse_shipment_response, shipment_request
+from karrio.providers.dicom.shipment.cancel import parse_shipment_cancel_response, shipment_cancel_request

karrio/providers/dicom/shipment/cancel.py

@@ -0,0 +1,32 @@
+from typing import Tuple, List
+from karrio.core.utils import Serializable
+from karrio.core.models import ShipmentCancelRequest, ConfirmationDetails, Message
+
+from karrio.providers.dicom.error import parse_error_response
+from karrio.providers.dicom.utils import Settings
+import karrio.lib as lib
+
+
+def parse_shipment_cancel_response(
+    response: lib.Deserializable[dict],
+    settings: Settings,
+) -> Tuple[ConfirmationDetails, List[Message]]:
+    errors = parse_error_response(response, settings)
+    details = (
+        ConfirmationDetails(
+            carrier_id=settings.carrier_id,
+            carrier_name=settings.carrier_name,
+            operation="Shipment Cancel",
+            success=True,
+        )
+        if not any(errors)
+        else None
+    )
+
+    return details, errors
+
+
+def shipment_cancel_request(payload: ShipmentCancelRequest, _) -> Serializable:
+    request = payload.shipment_identifier
+
+    return Serializable(request)