karrio-seko 2025.5rc1__py3-none-any.whl

karrio/mappers/seko/__init__.py

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

karrio/mappers/seko/mapper.py

@@ -0,0 +1,64 @@
+"""Karrio SEKO Logistics client mapper."""
+
+import typing
+import karrio.lib as lib
+import karrio.api.mapper as mapper
+import karrio.core.models as models
+import karrio.providers.seko as provider
+import karrio.mappers.seko.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 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)
+    

karrio/mappers/seko/proxy.py

@@ -0,0 +1,88 @@
+"""Karrio SEKO Logistics client proxy."""
+
+import karrio.lib as lib
+import karrio.api.proxy as proxy
+import karrio.providers.seko.utils as provider_utils
+import karrio.mappers.seko.settings as provider_settings
+
+
+class Proxy(proxy.Proxy):
+    settings: provider_settings.Settings
+
+    def get_rates(self, request: lib.Serializable) -> lib.Deserializable[str]:
+        response = lib.request(
+            url=f"{self.settings.server_url}/ratesqueryv1/availablerates",
+            data=lib.to_json(request.serialize()),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={
+                "Content-Type": "application/json; charset=utf-8",
+                "access_key": f"{self.settings.access_key}",
+            },
+            on_error=provider_utils.parse_error_response,
+        )
+
+        return lib.Deserializable(response, lib.to_dict)
+
+    def create_shipment(self, request: lib.Serializable) -> lib.Deserializable[str]:
+        response = lib.request(
+            url=f"{self.settings.server_url}/labels/printshipment",
+            data=lib.to_json(request.serialize()),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={
+                "Content-Type": "application/json; charset=utf-8",
+                "access_key": f"{self.settings.access_key}",
+            },
+            on_error=provider_utils.parse_error_response,
+        )
+
+        return lib.Deserializable(response, lib.to_dict, request.ctx)
+
+    def cancel_shipment(self, request: lib.Serializable) -> lib.Deserializable[str]:
+        response = lib.request(
+            url=f"{self.settings.server_url}/labels/delete",
+            data=lib.to_json(request.serialize()),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={
+                "Content-Type": "application/json; charset=utf-8",
+                "access_key": f"{self.settings.access_key}",
+            },
+            on_error=provider_utils.parse_error_response,
+        )
+
+        return lib.Deserializable(
+            response,
+            lib.to_dict,
+        )
+
+    def get_tracking(self, request: lib.Serializable) -> lib.Deserializable[str]:
+        response = lib.request(
+            url=f"{self.settings.server_url}/labels/statusv2",
+            data=lib.to_json(request.serialize()),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={
+                "Content-Type": "application/json; charset=utf-8",
+                "access_key": f"{self.settings.access_key}",
+            },
+            on_error=provider_utils.parse_error_response,
+        )
+
+        return lib.Deserializable(response, lib.to_dict)
+
+    def create_manifest(self, request: lib.Serializable) -> lib.Deserializable[str]:
+        response = lib.request(
+            url=f"{self.settings.server_url}/v2/publishmanifestv4",
+            data=lib.to_json(request.serialize()),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={
+                "Content-Type": "application/json; charset=utf-8",
+                "access_key": f"{self.settings.access_key}",
+            },
+            on_error=provider_utils.parse_error_response,
+        )
+
+        return lib.Deserializable(response, lib.to_dict)

karrio/mappers/seko/settings.py

@@ -0,0 +1,20 @@
+"""Karrio SEKO Logistics client settings."""
+
+import attr
+import karrio.providers.seko.utils as provider_utils
+
+
+@attr.s(auto_attribs=True)
+class Settings(provider_utils.Settings):
+    """SEKO Logistics connection settings."""
+
+    # Add carrier specific API connection properties here
+    access_key: str
+
+    # generic properties
+    id: str = None
+    test_mode: bool = False
+    carrier_id: str = "seko"
+    account_country_code: str = None
+    metadata: dict = {}
+    config: dict = {}

karrio/plugins/seko/__init__.py

@@ -0,0 +1,20 @@
+import karrio.core.metadata as metadata
+import karrio.mappers.seko as mappers
+import karrio.providers.seko.units as units
+import karrio.providers.seko.utils as utils
+
+
+METADATA = metadata.PluginMetadata(
+    status="production-ready",
+    id="seko",
+    label="SEKO Logistics",
+    # Integrations
+    Mapper=mappers.Mapper,
+    Proxy=mappers.Proxy,
+    Settings=mappers.Settings,
+    # Data Units
+    is_hub=False,
+    options=units.ShippingOption,
+    services=units.ShippingService,
+    connection_configs=utils.ConnectionConfig,
+)

karrio/providers/seko/__init__.py

@@ -0,0 +1,17 @@
+"""Karrio SEKO Logistics provider imports."""
+from karrio.providers.seko.utils import Settings
+from karrio.providers.seko.rate import parse_rate_response, rate_request
+from karrio.providers.seko.shipment import (
+    parse_shipment_cancel_response,
+    parse_shipment_response,
+    shipment_cancel_request,
+    shipment_request,
+)
+from karrio.providers.seko.tracking import (
+    parse_tracking_response,
+    tracking_request,
+)
+from karrio.providers.seko.manifest import (
+    parse_manifest_response,
+    manifest_request,
+)

karrio/providers/seko/error.py

@@ -0,0 +1,73 @@
+"""Karrio SEKO Logistics error parser."""
+
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+import karrio.providers.seko.utils as provider_utils
+
+
+def parse_error_response(
+    response: typing.Union[typing.List[dict], dict],
+    settings: provider_utils.Settings,
+    **kwargs,
+) -> typing.List[models.Message]:
+    responses = response if isinstance(response, list) else [response]
+    errors: list = []
+
+    for response_item in responses:
+        if validation_errors := response_item.get("ValidationErrors"):
+            if isinstance(validation_errors, dict):
+                errors.append(
+                    {
+                        "code": "ValidationError",
+                        "message": validation_errors.get(
+                            "Message", next(iter(validation_errors.values()))
+                        ),
+                        **{
+                            k: v for k, v in validation_errors.items() if k != "Message"
+                        },
+                    }
+                )
+            else:
+                errors.append(
+                    {"code": "ValidationError", "message": str(validation_errors)}
+                )
+            break
+
+        if rejected := response_item.get("Rejected", []):
+            error = rejected[0]
+            errors.append(
+                {
+                    "code": "Rejected",
+                    "message": error.get("Reason"),
+                    **{k: v for k, v in error.items() if k != "Reason"},
+                }
+            )
+            break
+
+        if general_errors := (
+            response_item.get("Errors", []) or response_item.get("Error", [])
+        ):
+            error = general_errors[0]
+            errors.append(
+                {
+                    "code": "Error",
+                    "message": error.get("Message"),
+                    **{k: v for k, v in error.items() if k != "Message"},
+                }
+            )
+            break
+
+    return [
+        models.Message(
+            carrier_id=settings.carrier_id,
+            carrier_name=settings.carrier_name,
+            code=error["code"],
+            message=error["message"],
+            details={
+                **kwargs,
+                **{k: v for k, v in error.items() if k not in ["code", "message"]},
+            },
+        )
+        for error in errors
+    ]

karrio/providers/seko/manifest.py

@@ -0,0 +1,62 @@
+"""Karrio SEKO Logistics manifest API implementation."""
+
+import karrio.schemas.seko.manifest_response as manifest
+
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+import karrio.providers.seko.error as error
+import karrio.providers.seko.utils as provider_utils
+import karrio.providers.seko.units as provider_units
+
+
+def parse_manifest_response(
+    _response: lib.Deserializable[dict],
+    settings: provider_utils.Settings,
+) -> typing.Tuple[models.ManifestDetails, typing.List[models.Message]]:
+    response = _response.deserialize()
+
+    messages = error.parse_error_response(response, settings)
+    details = lib.identity(
+        _extract_details(response, settings)
+        if any(response.get("OutboundManifest") or [])
+        else None
+    )
+
+    return details, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+) -> models.ManifestDetails:
+    details = lib.to_object(manifest.ManifestResponseType, data)
+    manifest_numbers = [_.ManifestNumber for _ in details.OutboundManifest]
+    manifest_connotes: list = sum(
+        [_.ManifestedConnotes for _ in details.OutboundManifest], []
+    )
+    manifest_doc = lib.bundle_base64(
+        [_.ManifestContent for _ in details.OutboundManifest], "PDF"
+    )
+
+    return models.ManifestDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_id,
+        doc=models.ManifestDocument(manifest=manifest_doc),
+        meta=dict(
+            ManifestNumber=manifest_numbers[0],
+            ManifestNumbers=manifest_numbers,
+            ManifestConnotes=manifest_connotes,
+        ),
+    )
+
+
+def manifest_request(
+    payload: models.ManifestRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+
+    # map data to convert karrio model to seko specific type
+    request = payload.shipment_identifiers
+
+    return lib.Serializable(request, lib.to_dict)

karrio/providers/seko/rate.py

@@ -0,0 +1,107 @@
+"""Karrio SEKO Logistics rating API implementation."""
+
+import karrio.schemas.seko.rating_request as seko
+import karrio.schemas.seko.rating_response as rating
+
+import typing
+import karrio.lib as lib
+import karrio.core.units as units
+import karrio.core.models as models
+import karrio.providers.seko.error as error
+import karrio.providers.seko.utils as provider_utils
+import karrio.providers.seko.units as provider_units
+
+
+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()
+
+    messages = error.parse_error_response(response, settings)
+    rates = [_extract_details(rate, settings) for rate in response.get("Available", [])]
+
+    return rates, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+) -> models.RateDetails:
+    details = lib.to_object(rating.AvailableType, data)
+    service = provider_units.ShippingService.map(details.DeliveryType)
+
+    return models.RateDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        service=service.name_or_key,
+        total_charge=lib.to_money(details.Cost),
+        currency=settings.connection_config.currency.state or "USD",
+        meta=dict(
+            service_name=service.value_or_key,
+            seko_carrier=details.CarrierName,
+            Route=details.Route,
+            QuoteId=details.QuoteId,
+            DeliveryType=details.DeliveryType,
+            CarrierServiceType=details.CarrierServiceType,
+            IsFreightForward=details.IsFreightForward,
+            IsRuralDelivery=details.IsRuralDelivery,
+            IsSaturdayDelivery=details.IsSaturdayDelivery,
+        ),
+    )
+
+
+def rate_request(
+    payload: models.RateRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+    recipient = lib.to_address(payload.recipient)
+    options = lib.to_shipping_options(
+        payload.options,
+        initializer=provider_units.shipping_options_initializer,
+    )
+    packages = lib.to_packages(
+        payload.parcels,
+        options=options,
+        shipping_options_initializer=provider_units.shipping_options_initializer,
+    )
+
+    # map data to convert karrio model to seko specific type
+    request = seko.RatingRequestType(
+        DeliveryReference=payload.reference,
+        Destination=seko.DestinationType(
+            Id=options.seko_destination_id.state,
+            Name=recipient.company_name,
+            Address=seko.AddressType(
+                BuildingName="",
+                StreetAddress=recipient.street,
+                Suburb=recipient.city,
+                City=recipient.state_code,
+                PostCode=recipient.postal_code,
+                CountryCode=recipient.country_code,
+            ),
+            ContactPerson=recipient.contact,
+            PhoneNumber=recipient.phone_number,
+            Email=recipient.email,
+            DeliveryInstructions=options.destination_instructions.state,
+            RecipientTaxId=recipient.tax_id,
+        ),
+        IsSaturdayDelivery=options.seko_is_saturday_delivery.state,
+        IsSignatureRequired=options.seko_is_signature_required.state,
+        Packages=[
+            seko.PackageType(
+                Height=package.height.CM,
+                Length=package.length.CM,
+                Id=package.options.seko_package_id.state,
+                Width=package.width.CM,
+                Kg=package.weight.KG,
+                Name=lib.text(package.description, max=50),
+                Type=provider_units.PackagingType.map(
+                    package.packaging_type or "your_packaging"
+                ).value,
+            )
+            for package in packages
+        ],
+    )
+
+    return lib.Serializable(request, lib.to_dict)

karrio/providers/seko/shipment/__init__.py

@@ -0,0 +1,9 @@
+
+from karrio.providers.seko.shipment.create import (
+    parse_shipment_response,
+    shipment_request,
+)
+from karrio.providers.seko.shipment.cancel import (
+    parse_shipment_cancel_response,
+    shipment_cancel_request,
+)

karrio/providers/seko/shipment/cancel.py

@@ -0,0 +1,61 @@
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+import karrio.providers.seko.error as error
+import karrio.providers.seko.utils as provider_utils
+import karrio.providers.seko.units as provider_units
+
+
+def parse_shipment_cancel_response(
+    _response: lib.Deserializable[dict],
+    settings: provider_utils.Settings,
+) -> typing.Tuple[models.ConfirmationDetails, typing.List[models.Message]]:
+    response = _response.deserialize()
+    messages = error.parse_error_response(
+        dict(
+            Errors=[
+                {"ConsignmentId": _, "Message": __}
+                for _, __ in response.items()
+                if isinstance(__, str) and "Deleted" not in __
+            ]
+        ),
+        settings,
+    )
+    success = any(["Deleted" in _ for _ in response.values() if isinstance(_, str)])
+
+    confirmation = (
+        models.ConfirmationDetails(
+            carrier_id=settings.carrier_id,
+            carrier_name=settings.carrier_name,
+            operation="Cancel Shipment",
+            success=success,
+        )
+        if success
+        else None
+    )
+
+    return confirmation, messages
+
+
+def shipment_cancel_request(
+    payload: models.ShipmentCancelRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+    options = lib.units.Options(
+        payload.options,
+        option_type=lib.units.create_enum(
+            "PickupOptions",
+            # fmt: off
+            {
+                "shipment_identifiers": lib.OptionEnum("shipment_identifiers", lib.to_list),
+            },
+            # fmt: on
+        ),
+    )
+
+    # map data to convert karrio model to seko specific type
+    request = lib.identity(
+        options.shipment_identifiers.state or [payload.shipment_identifier]
+    )
+
+    return lib.Serializable(request, lib.to_dict)