karrio-seko 2025.5rc1__py3-none-any.whl

karrio/providers/seko/shipment/create.py

@@ -0,0 +1,224 @@
+"""Karrio SEKO Logistics shipment API implementation."""
+
+import karrio.schemas.seko.shipping_request as seko
+import karrio.schemas.seko.shipping_response as shipping
+
+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_shipment_response(
+    _response: lib.Deserializable[dict],
+    settings: provider_utils.Settings,
+) -> typing.Tuple[typing.List[models.RateDetails], typing.List[models.Message]]:
+    response = _response.deserialize()
+    print(_response.ctx)
+    messages = error.parse_error_response(response, settings)
+    shipment = lib.identity(
+        _extract_details(response, settings, ctx=_response.ctx)
+        if any(response.get("Consignments", []))
+        else None
+    )
+
+    return shipment, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+    ctx: dict = None,
+) -> models.ShipmentDetails:
+    details = lib.to_object(shipping.ShippingResponseType, data)
+    Connotes = [_.Connote for _ in details.Consignments]
+    TrackingUrls = [_.TrackingUrl for _ in details.Consignments]
+    ConsignmentIds = [_.ConsignmentId for _ in details.Consignments]
+    label_type = ctx.get("label_type")
+    label_format = ctx.get("label_format")
+
+    label = lib.bundle_base64(
+        sum([_["OutputFiles"][label_type] for _ in data["Consignments"]], []),
+        label_format,
+    )
+
+    return models.ShipmentDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        tracking_number=Connotes[0],
+        shipment_identifier=ConsignmentIds[0],
+        label_type=label_format,
+        docs=models.Documents(label=label),
+        meta=dict(
+            carrier_tracking_link=TrackingUrls[0],
+            seko_site_id=details.SiteId,
+            tracking_urls=TrackingUrls,
+            consignment_id=ConsignmentIds[0],
+            consignment_ids=ConsignmentIds,
+            seko_carrier_id=details.CarrierId,
+            seko_carrier_name=details.CarrierName,
+            seko_carrier_type=details.CarrierType,
+            rate_provider=details.CarrierName,
+            seko_invoice_response=details.InvoiceResponse,
+        ),
+    )
+
+
+def shipment_request(
+    payload: models.ShipmentRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+    shipper = lib.to_address(payload.shipper)
+    recipient = lib.to_address(payload.recipient)
+    packages = lib.to_packages(payload.parcels)
+    service = provider_units.ShippingService.map(payload.service).value_or_key
+    options = lib.to_shipping_options(
+        payload.options,
+        package_options=packages.options,
+        initializer=provider_units.shipping_options_initializer,
+    )
+    customs = lib.to_customs_info(
+        payload.customs,
+        shipper=payload.shipper,
+        recipient=payload.recipient,
+        weight_unit=units.WeightUnit.KG.name,
+        option_type=provider_units.CustomsOption,
+    )
+    commodities: units.Products = lib.identity(
+        customs.commodities if payload.customs else packages.items
+    )
+    [label_format, label_type] = lib.identity(
+        provider_units.LabelType.map(payload.label_type).value
+        or provider_units.LabelType.PDF.value
+    )
+    commercial_invoice = lib.identity(
+        options.seko_invoice_data.state
+        or next((
+            _["doc_file"] for _ in options.doc_files.state or []
+            if _["doc_type"] == "commercial_invoice"
+            and _.get("doc_format", "PDF").lower() == "pdf"
+        ), None)
+    )
+
+    # map data to convert karrio model to seko specific type
+    request = seko.ShippingRequestType(
+        DeliveryReference=payload.reference,
+        Reference2=options.seko_reference_2.state,
+        Reference3=options.seko_reference_3.state,
+        Origin=seko.DestinationType(
+            Id=options.seko_origin_id.state,
+            Name=lib.identity(shipper.company_name or shipper.contact or "Shipper"),
+            Address=seko.AddressType(
+                BuildingName=None,
+                StreetAddress=shipper.street,
+                Suburb=shipper.city,
+                City=shipper.state_code or shipper.city,
+                PostCode=shipper.postal_code,
+                CountryCode=shipper.country_code,
+            ),
+            ContactPerson=shipper.contact,
+            PhoneNumber=shipper.phone_number or "000 000 0000",
+            Email=shipper.email or " ",
+            DeliveryInstructions=options.origin_instructions.state,
+            RecipientTaxId=shipper.tax_id,
+            SendTrackingEmail=None,
+        ),
+        Destination=seko.DestinationType(
+            Id=options.seko_destination_id.state,
+            Name=lib.identity(
+                recipient.company_name or recipient.contact or "Recipient"
+            ),
+            Address=seko.AddressType(
+                BuildingName=None,
+                StreetAddress=recipient.street,
+                Suburb=recipient.city,
+                City=recipient.state_code or recipient.city,
+                PostCode=recipient.postal_code,
+                CountryCode=recipient.country_code,
+            ),
+            ContactPerson=recipient.contact,
+            PhoneNumber=recipient.phone_number or "000 000 0000",
+            Email=recipient.email or " ",
+            DeliveryInstructions=options.destination_instructions.state,
+            RecipientTaxId=recipient.tax_id,
+            SendTrackingEmail=options.seko_send_tracking_email.state,
+        ),
+        DangerousGoods=None,
+        Commodities=[
+            seko.CommodityType(
+                Description=lib.identity(
+                    lib.text(commodity.description or commodity.title, max=35) or "item"
+                ),
+                HarmonizedCode=commodity.hs_code or "0000.00.00",
+                Units=commodity.quantity,
+                UnitValue=commodity.value_amount,
+                UnitKg=commodity.weight,
+                Currency=commodity.value_currency,
+                Country=commodity.origin_country,
+                IsDG=None,
+                itemSKU=commodity.sku,
+                DangerousGoodsItem=None,
+            )
+            for commodity in commodities
+        ],
+        Packages=[
+            seko.PackageType(
+                Height=package.height.CM,
+                Length=package.length.CM,
+                Width=package.width.CM,
+                Kg=package.weight.KG,
+                Name=lib.text(package.description, max=50),
+                Type=lib.identity(
+                    provider_units.PackagingType.map(package.packaging_type).value
+                ),
+                OverLabelBarcode=package.reference_number,
+            )
+            for package in packages
+        ],
+        issignaturerequired=options.seko_is_signature_required.state,
+        DutiesAndTaxesByReceiver=lib.identity(
+            customs.duty.paid_by == "recipient" if payload.customs else None
+        ),
+        ProductCategory=options.seko_product_category.state,
+        ShipType=options.seko_ship_type.state,
+        PrintToPrinter=lib.identity(
+            options.seko_print_to_printer.state
+            if options.seko_print_to_printer.state is not None
+            else True
+        ),
+        IncludeLineDetails=True,
+        Carrier=options.seko_carrier.state,
+        Service=service,
+        CostCentreName=settings.connection_config.cost_center.state,
+        CostCentreId=settings.connection_config.cost_center_id.state,
+        CodValue=options.cash_on_delivery.state,
+        TaxCollected=lib.identity(
+            options.seko_tax_collected.state
+            if options.seko_tax_collected.state is not None
+            else True
+        ),
+        AmountCollected=lib.to_money(options.seko_amount_collected.state),
+        CIFValue=options.seko_cif_value.state,
+        FreightValue=options.seko_freight_value.state,
+        SendLabel="Y" if options.seko_send_label.state else None,
+        LabelBranding=settings.connection_config.label_branding.state,
+        InvoiceData=commercial_invoice,
+        TaxIds=[
+            seko.TaxIDType(
+                IdType=option.code,
+                IdNumber=option.state,
+            )
+            for key, option in customs.options.items()
+            if key in provider_units.CustomsOption and option.state is not None
+        ],
+        Outputs=[label_type],
+    )
+
+    return lib.Serializable(
+        request,
+        lib.to_dict,
+        dict(label_type=label_type, label_format=label_format),
+    )

karrio/providers/seko/tracking.py

@@ -0,0 +1,95 @@
+"""Karrio SEKO Logistics tracking API implementation."""
+
+import karrio.schemas.seko.tracking_response as tracking
+
+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_tracking_response(
+    _response: lib.Deserializable[typing.List[dict]],
+    settings: provider_utils.Settings,
+) -> typing.Tuple[typing.List[models.TrackingDetails], typing.List[models.Message]]:
+    responses = _response.deserialize()
+
+    messages: typing.List[models.Message] = error.parse_error_response(
+        responses, settings
+    )
+    tracking_details = [
+        _extract_details(_, settings)
+        for _ in (responses if isinstance(responses, list) else [responses])
+        if any(_.get("Events", []))
+    ]
+
+    return tracking_details, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+) -> models.TrackingDetails:
+    details = lib.to_object(tracking.TrackingResponseElementType, data)
+    events = list(reversed(details.Events))
+    latest_status = lib.identity(
+        events[0].OmniCode if any(events) else getattr(details, "Status", None)
+    )
+    status = next(
+        (
+            status.name
+            for status in list(provider_units.TrackingStatus)
+            if latest_status in status.value
+        ),
+        provider_units.TrackingStatus.in_transit.name,
+    )
+
+    return models.TrackingDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        tracking_number=details.ConsignmentNo,
+        events=[
+            models.TrackingEvent(
+                date=lib.fdate(
+                    event.EventDT,
+                    try_formats=["%Y-%m-%dT%H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S"],
+                ),
+                description=event.Description,
+                code=event.OmniCode or event.Code,
+                time=lib.flocaltime(
+                    event.EventDT,
+                    try_formats=["%Y-%m-%dT%H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S"],
+                ),
+                location=event.Location,
+            )
+            for event in events
+        ],
+        delivered=status == "delivered",
+        status=status,
+        info=models.TrackingInfo(
+            carrier_tracking_link=details.Tracking,
+            expected_delivery=lib.fdate(
+                details.Delivered,
+                try_formats=["%Y-%m-%dT%H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S"],
+            ),
+            shipping_date=lib.fdate(
+                details.Picked,
+                try_formats=["%Y-%m-%dT%H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S"],
+            ),
+        ),
+        meta=dict(reference=details.Reference1),
+    )
+
+
+def tracking_request(
+    payload: models.TrackingRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+
+    # map data to convert karrio model to seko specific type
+    request = payload.tracking_numbers
+
+    return lib.Serializable(request, lib.to_dict)

karrio/providers/seko/units.py

@@ -0,0 +1,239 @@
+import karrio.lib as lib
+import karrio.core.units as units
+
+
+class LabelType(lib.Enum):
+    LABEL_PDF = ("PDF", "LABEL_PDF")
+    LABEL_PNG_100X150 = ("PNG", "LABEL_PNG_100X150")
+    LABEL_PNG_100X175 = ("PNG", "LABEL_PNG_100X175")
+    LABEL_PDF_100X175 = ("PDF", "LABEL_PDF_100X175")
+    LABEL_PDF_100X150 = ("PDF", "LABEL_PDF_100X150")
+    LABEL_ZPL_100X175 = ("ZPL", "LABEL_ZPL_100X175")
+    LABEL_ZPL_100X150 = ("ZPL", "LABEL_ZPL_100X150")
+
+    """ Unified Label type mapping """
+    PDF = LABEL_PDF_100X150
+    ZPL = LABEL_ZPL_100X150
+    PNG = LABEL_PNG_100X150
+
+
+class PackagingType(lib.StrEnum):
+    """Carrier specific packaging type"""
+
+    Bag = "Bag"
+    Box = "Box"
+    Carton = "Carton"
+    Container = "Container"
+    Crate = "Crate"
+    Envelope = "Envelope"
+    Pail = "Pail"
+    Pallet = "Pallet"
+    Satchel = "Satchel"
+    Tube = "Tube"
+    Custom = "Custom"
+
+    """ Unified Packaging type mapping """
+    envelope = Envelope
+    pak = Satchel
+    tube = Tube
+    pallet = Pallet
+    small_box = Box
+    medium_box = Carton
+    your_packaging = Custom
+
+
+class ShippingService(lib.StrEnum):
+    """Carrier specific services"""
+
+    seko_ecommerce_standard_tracked = "eCommerce Standard Tracked"
+    seko_ecommerce_express_tracked = "eCommerce Express Tracked"
+    seko_domestic_express = "Domestic Express"
+    seko_domestic_standard = "Domestic Standard"
+    seko_domestic_large_parcel = "Domestic Large Parcel"
+
+
+class ShippingOption(lib.Enum):
+    """Carrier specific options"""
+
+    seko_carrier = lib.OptionEnum("Carrier")
+    seko_ship_type = lib.OptionEnum("ShipType")
+    seko_package_id = lib.OptionEnum("PackageId")
+    seko_destination_id = lib.OptionEnum("DestinationId")
+    seko_product_category = lib.OptionEnum("ProductCategory")
+    origin_instructions = lib.OptionEnum("OriginInstructions")
+    destination_instructions = lib.OptionEnum("DestinationInstructions")
+    seko_is_saturday_delivery = lib.OptionEnum("IsSaturdayDelivery", bool)
+    seko_is_signature_required = lib.OptionEnum("IsSignatureRequired", bool)
+    seko_send_tracking_email = lib.OptionEnum("SendTrackingEmail", bool)
+    seko_amount_collected = lib.OptionEnum("AmountCollected", float)
+    seko_tax_collected = lib.OptionEnum("TaxCollected", bool)
+    seko_cod_amount = lib.OptionEnum("CODAmount", float)
+    seko_reference_2 = lib.OptionEnum("Reference2")
+    seko_reference_3 = lib.OptionEnum("Reference3")
+    seko_invoice_data = lib.OptionEnum("InvoiceData")
+    seko_origin_id = lib.OptionEnum("OriginId", int)
+    seko_print_to_printer = lib.OptionEnum("PrintToPrinter", bool)
+    seko_cif_value = lib.OptionEnum("CIFValue", float)
+    seko_freight_value = lib.OptionEnum("FreightValue", float)
+    seko_send_label = lib.OptionEnum("SendLabel", bool)
+
+    """ Unified Option type mapping """
+    saturday_delivery = seko_is_saturday_delivery
+    signature_required = seko_is_signature_required
+    email_notification = seko_send_tracking_email
+    doc_files = lib.OptionEnum("doc_files", lib.to_dict)
+    doc_references = lib.OptionEnum("doc_references", lib.to_dict)
+
+
+def shipping_options_initializer(
+    options: dict,
+    package_options: units.ShippingOptions = None,
+) -> units.ShippingOptions:
+    """
+    Apply default values to the given options.
+    """
+
+    if package_options is not None:
+        options.update(package_options.content)
+
+    def items_filter(key: str) -> bool:
+        return key in ShippingOption  # type: ignore
+
+    return units.ShippingOptions(options, ShippingOption, items_filter=items_filter)
+
+
+class CustomsOption(lib.Enum):
+    XIEORINumber = lib.OptionEnum("XIEORINumber")
+    IOSSNUMBER = lib.OptionEnum("IOSSNUMBER")
+    GBEORINUMBER = lib.OptionEnum("GBEORINUMBER")
+    VOECNUMBER = lib.OptionEnum("VOECNUMBER")
+    VATNUMBER = lib.OptionEnum("VATNUMBER")
+    VENDORID = lib.OptionEnum("VENDORID")
+    NZIRDNUMBER = lib.OptionEnum("NZIRDNUMBER")
+    SWISS_VAT = lib.OptionEnum("SWISS VAT")
+    OVRNUMBER = lib.OptionEnum("OVRNUMBER")
+    EUEORINumber = lib.OptionEnum("EUEORINumber")
+    EUVATNumber = lib.OptionEnum("EUVATNumber")
+    LVGRegistrationNumber = lib.OptionEnum("LVGRegistrationNumber")
+
+    """ Unified Customs Identifier type mapping """
+
+    ioss = IOSSNUMBER
+    nip_number = VATNUMBER
+    eori_number = EUEORINumber
+
+
+class TrackingStatus(lib.Enum):
+    pending = [
+        "OP-1",  # Pending
+        "OP-8",  # Manifest Received by Carrier
+        "OP-9",  # Not yet received by carrier
+        "OP-11",  # Received by carrier – no manifest sent
+        "OP-12",  # Collection request received by carrier
+    ]
+    on_hold = [
+        "OP-26",  # Held by carrier
+        "OP-2",  # Held at Export Hub
+        "OP-6",  # Customs held for inspection and clearance
+        "OP-49",  # Held by Delivery Courier
+        "OP-70",  # Parcel Blocked
+        "OP-87",  # Aged Parcel - High Value Unpaid
+        "OP-88",  # Held at Export Hub - Additional Payment Required
+        "OP-41",  # Incorrect details declared by sender
+        "OP-36",  # Delivery arranged with receiver
+        "OP-39",  # Package repacked
+        "OP-44",  # Selected for redelivery
+        "OP-46",  # Customer Enquiry lodged
+        "OP-52",  # Parcel Redirection Requested
+        "OP-53",  # Parcel Redirected
+        "OP-91",  # Parcel Blocked - Declared LIT
+    ]
+    delivered = [
+        "OP-71",  # Delivered in part
+        "OP-72",  # Delivered
+        "OP-73",  # Delivered to neighbour
+        "OP-74",  # Delivered - Authority to Leave / Safe Drop
+        "OP-75",  # Delivered - Parcel Collected
+        "OP-76",  # Delivered to locker/collection point
+        "OP-77",  # Delivered to alternate delivery point
+    ]
+    in_transit = [
+        "OP-18",  # In transit
+        "OP-20",  # Sub-contractor update
+        "OP-22",  # Received by Sub-contractor
+        "OP-3",  # Processed through Export Hub
+        "OP-4",  # International transit to destination country
+        "OP-5",  # Customs cleared
+        "OP-47",  # Processed through Sorting Facility
+        "OP-50",  # Parcel arrived to courier processing facility
+        "OP-51",  # Parcel departed courier processing facility
+        "OP-78",  # Flight Arrived
+        "OP-79",  # InTransit
+        "OP-80",  # Reshipped
+        "OP-81",  # Flight Departed
+        "OP-7",  # Picked up by Delivery Courier
+        "OP-10",  # Received by carrier
+        "OP-14",  # Parcel received and accepted
+        "OP-31",  # Information
+        "OP-32",  # Information
+        "OP-33",  # Collected from sender
+        "OP-48",  # With Delivery Courier
+        "OP-82",  # Inbound freight received
+        "OP-83",  # Delivery exception
+        "OP-84",  # Recipient not available
+        "OP-89",  # Collected from sender
+        "OP-54",  # Transferred to Collection Point
+        "OP-56",  # Transferred to delivery provider
+    ]
+    delivery_failed = [
+        "OP-24",  # Attempted Delivery - Receiver carded
+        "OP-27",  # Attempted Delivery - Customer not known at address
+        "OP-28",  # Attempted Delivery - Refused by customer
+        "OP-29",  # Return to sender
+        "OP-30",  # Non delivery
+        "OP-37",  # Attempted Delivery - No access to receivers address
+        "OP-38",  # Attempted Delivery - Customer Identification failed
+        "OP-45",  # Attempted delivery
+        "OP-55",  # Attempted Delivery - Returned to Sender
+        "OP-15",  # Parcel lost
+        "OP-17",  # Parcel Damaged
+        "OP-23",  # Invalid / Insufficient Address
+        "OP-86",  # Attempted delivery
+        "OP-40",  # Package disposed
+        "OP-92",  # Amazon RTS - DESTROY
+        "OP-43",  # Not collected from store
+    ]
+    delivery_delayed = [
+        "OP-16",  # Parcel Delayed
+        "OP-13",  # Misdirected
+        "OP-35",  # Mis sorted by carrier
+    ]
+    out_for_delivery = [
+        "OP-21",  # Out for delivery
+    ]
+    ready_for_pickup = [
+        "OP-19",  # Awaiting Collection
+        "OP-25",  # Customer to collect from carrier
+        "OP-42",  # Awaiting collection
+    ]
+    cancelled = [
+        "OP-34",  # Cancelled
+        "OP-67",  # RTS - Cancelled Order
+    ]
+    return_to_sender = [
+        "OP-57",  # RTS Received  - Authorised Return
+        "OP-58",  # RTS Received - Cancelled Order
+        "OP-59",  # RTS Received - Card Left, Never Collected
+        "OP-60",  # RTS - Fraudulant
+        "OP-61",  # RTS Received - Invalid or Insufficient Address
+        "OP-62",  # RTS Received- No Reason Given
+        "OP-63",  # RTS - High Value Rejected
+        "OP-64",  # RTS Received - Refused
+        "OP-65",  # RTS Received - Unclaimed
+        "OP-66",  # Return to Sender
+        "OP-68",  # RTS Received
+        "OP-69",  # RTS Received - Damaged Parcel
+        "OP-85",  # RTS - In transit
+        "OP-90",  # Return processed
+        "OP-94",  # RTS consolidated
+    ]

karrio/providers/seko/utils.py

@@ -0,0 +1,114 @@
+import base64
+import datetime
+import karrio.lib as lib
+import karrio.core as core
+import karrio.core.errors as errors
+
+
+class Settings(core.Settings):
+    """SEKO Logistics connection settings."""
+
+    # Add carrier specific api connection properties here
+    access_key: str
+
+    @property
+    def carrier_name(self):
+        return "seko"
+
+    @property
+    def server_url(self):
+        return (
+            "https://staging.omniparcel.com"
+            if self.test_mode
+            else "https://api.omniparcel.com"
+        )
+
+    # """uncomment the following code block to expose a carrier tracking url."""
+    # @property
+    # def tracking_url(self):
+    #     return "https://www.carrier.com/tracking?tracking-id={}"
+
+    # """uncomment the following code block to implement the Basic auth."""
+    # @property
+    # def authorization(self):
+    #     pair = "%s:%s" % (self.username, self.password)
+    #     return base64.b64encode(pair.encode("utf-8")).decode("ascii")
+
+    @property
+    def connection_config(self) -> lib.units.Options:
+        return lib.to_connection_config(
+            self.config or {},
+            option_type=ConnectionConfig,
+        )
+
+
+#     """uncomment the following code block to implement the oauth login."""
+#     @property
+#     def access_token(self):
+#         """Retrieve the access_token using the client_id|client_secret pair
+#         or collect it from the cache if an unexpired access_token exist.
+#         """
+#         cache_key = f"{self.carrier_name}|{self.client_id}|{self.client_secret}"
+#         now = datetime.datetime.now() + datetime.timedelta(minutes=30)
+
+#         auth = self.connection_cache.get(cache_key) or {}
+#         token = auth.get("access_token")
+#         expiry = lib.to_date(auth.get("expiry"), current_format="%Y-%m-%d %H:%M:%S")
+
+#         if token is not None and expiry is not None and expiry > now:
+#             return token
+
+#         self.connection_cache.set(cache_key, lambda: login(self))
+#         new_auth = self.connection_cache.get(cache_key)
+
+#         return new_auth["access_token"]
+
+# """uncomment the following code block to implement the oauth login."""
+# def login(settings: Settings):
+#     import karrio.providers.seko.error as error
+
+#     result = lib.request(
+#         url=f"{settings.server_url}/oauth/token",
+#         method="POST",
+#         headers={"content-Type": "application/x-www-form-urlencoded"},
+#         data=lib.to_query_string(
+#             dict(
+#                 grant_type="client_credentials",
+#                 client_id=settings.client_id,
+#                 client_secret=settings.client_secret,
+#             )
+#         ),
+#     )
+
+#     response = lib.to_dict(result)
+#     messages = error.parse_error_response(response, settings)
+
+#     if any(messages):
+#         raise errors.ParsedMessagesError(messages)
+
+#     expiry = datetime.datetime.now() + datetime.timedelta(
+#         seconds=float(response.get("expires_in", 0))
+#     )
+#     return {**response, "expiry": lib.fdatetime(expiry)}
+
+
+class ConnectionConfig(lib.Enum):
+    """SEKO Logistics connection configuration."""
+
+    currency = lib.OptionEnum("currency", str)
+    cost_center = lib.OptionEnum("cost_center", str)
+    cost_center_id = lib.OptionEnum("cost_center_id", str)
+    shipping_options = lib.OptionEnum("shipping_options", list)
+    shipping_services = lib.OptionEnum("shipping_services", list)
+
+
+def parse_error_response(response):
+    """Parse the error response from the SAPIENT API."""
+    content = lib.failsafe(lambda: lib.decode(response.read()))
+
+    if any(content or ""):
+        return content
+
+    return lib.to_json(
+        dict(Errors=[dict(code=str(response.code), Message=response.reason)])
+    )

karrio/schemas/seko/error_response.py

@@ -0,0 +1,11 @@
+import attr
+import jstruct
+import typing
+
+
+@attr.s(auto_attribs=True)
+class ErrorResponseType:
+    Property: typing.Optional[str] = None
+    Message: typing.Optional[str] = None
+    Key: typing.Optional[str] = None
+    Value: typing.Optional[str] = None