karrio-colissimo 2025.5rc1__py3-none-any.whl

karrio/mappers/colissimo/__init__.py

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

karrio/mappers/colissimo/mapper.py

@@ -0,0 +1,41 @@
+"""Karrio Colissimo client mapper."""
+
+import typing
+import karrio.lib as lib
+import karrio.api.mapper as mapper
+import karrio.core.models as models
+import karrio.providers.colissimo as provider
+import karrio.mappers.colissimo.settings as provider_settings
+import karrio.universal.providers.rating as universal_provider
+
+
+class Mapper(mapper.Mapper):
+    settings: provider_settings.Settings
+
+    def create_rate_request(self, payload: models.RateRequest) -> lib.Serializable:
+        return universal_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 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)

karrio/mappers/colissimo/proxy.py

@@ -0,0 +1,39 @@
+"""Karrio Colissimo client proxy."""
+
+import karrio.lib as lib
+import karrio.api.proxy as proxy
+import karrio.providers.colissimo.utils as provider_utils
+import karrio.mappers.colissimo.settings as provider_settings
+import karrio.universal.mappers.rating_proxy as rating_proxy
+
+
+class Proxy(rating_proxy.RatingMixinProxy, proxy.Proxy):
+    settings: provider_settings.Settings
+
+    def get_rates(self, request: lib.Serializable) -> lib.Deserializable[str]:
+        return super().get_rates(request)
+
+    def create_shipment(self, request: lib.Serializable) -> lib.Deserializable[str]:
+        response = lib.request(
+            url=f"{self.settings.server_url}/generateLabel",
+            data=request.serialize(),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={"Content-Type": "application/json;charset=UTF-8"},
+        )
+
+        return lib.Deserializable(response, provider_utils.parse_response, request.ctx)
+
+    def get_tracking(self, request: lib.Serializable) -> lib.Deserializable[str]:
+        idships = ",".join(request.serialize())
+        response = lib.request(
+            url=f"{self.settings.laposte_server_url}/idships/{idships}?lang={self.settings.connection_config.lang.state or 'fr_FR'}",
+            trace=self.trace_as("json"),
+            method="GET",
+            headers={
+                "accept": "application/json",
+                "X-Okapi-Key": self.settings.laposte_api_key,
+            },
+        )
+
+        return lib.Deserializable(response, lib.to_dict)

karrio/mappers/colissimo/settings.py

@@ -0,0 +1,35 @@
+"""Karrio Colissimo client settings."""
+
+import attr
+import typing
+import jstruct
+import karrio.core.models as models
+import karrio.providers.colissimo.utils as provider_utils
+import karrio.providers.colissimo.units as provider_units
+
+
+@attr.s(auto_attribs=True)
+class Settings(provider_utils.Settings):
+    """Colissimo connection settings."""
+
+    # required carrier specific properties
+    password: str
+    contract_number: str
+    laposte_api_key: str = None
+
+    # generic properties
+    id: str = None
+    test_mode: bool = False
+    carrier_id: str = "colissimo"
+    account_country_code: str = "FR"
+    metadata: dict = {}
+    config: dict = {}
+
+    services: typing.List[models.ServiceLevel] = jstruct.JList[models.ServiceLevel, False, dict(default=provider_units.DEFAULT_SERVICES)]  # type: ignore
+
+    @property
+    def shipping_services(self) -> typing.List[models.ServiceLevel]:
+        if any(self.services or []):
+            return self.services
+
+        return provider_units.DEFAULT_SERVICES

karrio/plugins/colissimo/__init__.py

@@ -0,0 +1,23 @@
+import karrio.core.metadata as metadata
+import karrio.mappers.colissimo as mappers
+import karrio.providers.colissimo.units as units
+
+
+METADATA = metadata.PluginMetadata(
+    status="beta",
+    id="colissimo",
+    label="Colissimo",
+    # Integrations
+    Mapper=mappers.Mapper,
+    Proxy=mappers.Proxy,
+    Settings=mappers.Settings,
+    # Data Units
+    options=units.ShippingOption,
+    services=units.ShippingService,
+    connection_configs=units.ConnectionConfig,
+    service_levels=units.DEFAULT_SERVICES,
+    # New fields
+    website="https://www.colissimo.entreprise.laposte.fr/en",
+    documentation="https://www.colissimo.entreprise.laposte.fr/en/tools-and-services",
+    description="Envoi de colis en France et dans le monde entier, livraison à domicile ou en point de retrait, Colissimo vous offre un choix de services qui facilitent votre quotidien.",
+)

karrio/providers/colissimo/__init__.py

@@ -0,0 +1,9 @@
+from karrio.providers.colissimo.utils import Settings
+from karrio.providers.colissimo.shipment import (
+    parse_shipment_response,
+    shipment_request,
+)
+from karrio.providers.colissimo.tracking import (
+    parse_tracking_response,
+    tracking_request,
+)

karrio/providers/colissimo/error.py

@@ -0,0 +1,52 @@
+import karrio.schemas.colissimo.error_response as laposte
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+import karrio.providers.colissimo.utils as provider_utils
+
+
+def parse_error_response(
+    response: dict,
+    settings: provider_utils.Settings,
+    **kwargs,
+) -> typing.List[models.Message]:
+    messages = response.get("json_info", {}).get("messages", [])
+
+    return [
+        models.Message(
+            carrier_id=settings.carrier_id,
+            carrier_name=settings.carrier_name,
+            code=msg.get("type"),
+            message=msg.get("messageContent"),
+            details={**kwargs},
+        )
+        for msg in messages
+        if msg.get("type") == "ERROR"
+    ]
+
+
+def parse_laposte_error_response(
+    response: typing.Union[dict, typing.List[dict]],
+    settings: provider_utils.Settings,
+    **kwargs,
+) -> typing.List[models.Message]:
+    responses = response if isinstance(response, list) else [response]
+    errors = [
+        lib.to_object(laposte.ErrorResponse, res)
+        for res in responses
+        if (
+            not str(res.get("returnCode")).startswith("20")
+            or res.get("code") is not None
+        )
+    ]
+
+    return [
+        models.Message(
+            carrier_id=settings.carrier_id,
+            carrier_name=settings.carrier_name,
+            code=(error.returnCode or error.code),
+            message=(error.returnMessage or error.message),
+            details={**kwargs},
+        )
+        for error in errors
+    ]

karrio/providers/colissimo/shipment/__init__.py

@@ -0,0 +1,4 @@
+from karrio.providers.colissimo.shipment.create import (
+    parse_shipment_response,
+    shipment_request,
+)

karrio/providers/colissimo/shipment/create.py

@@ -0,0 +1,295 @@
+import karrio.schemas.colissimo.label_request as colissimo
+import karrio.schemas.colissimo.label_response as shipping
+import typing
+import base64
+import karrio.lib as lib
+import karrio.core.units as units
+import karrio.core.models as models
+import karrio.providers.colissimo.error as error
+import karrio.providers.colissimo.utils as provider_utils
+import karrio.providers.colissimo.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()
+
+    messages = error.parse_error_response(response, settings)
+    shipment = (
+        _extract_details(response, settings, _response.ctx)
+        if response.get("json_info", {}).get("labelV2Response") is not None
+        else None
+    )
+
+    return shipment, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+    ctx: dict = {},
+) -> models.ShipmentDetails:
+    shipment = lib.to_object(shipping.LabelResponse, data.get("json_info"))
+    label_type = ctx.get("label_type") or "PDF"
+    label = data.get("label")
+
+    if label_type != "ZPL":
+        label = base64.b64encode(bytes(label, encoding="raw_unicode_escape")).decode(
+            "utf-8"
+        )
+
+    return models.ShipmentDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        tracking_number=shipment.labelV2Response.parcelNumber,
+        shipment_identifier=shipment.labelV2Response.parcelNumber,
+        label_type="ZPL" if "ZPL" in label_type else "PDF",
+        docs=models.Documents(label=label),
+        meta=dict(
+            carrier_tracking_link=settings.tracking_url.format(
+                shipment.labelV2Response.parcelNumber
+            ),
+            request_uuid=data.get("uuid"),
+            pdfUrl=shipment.labelV2Response.pdfUrl,
+            parcelNumber=shipment.labelV2Response.parcelNumber,
+            parcelNumberPartner=shipment.labelV2Response.parcelNumberPartner,
+        ),
+    )
+
+
+def shipment_request(
+    payload: models.ShipmentRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+    shipper = lib.to_address(payload.shipper)
+    recipient = lib.to_address(payload.recipient)
+    package = lib.to_packages(payload.parcels).single
+    service = provider_units.ShippingService.map(payload.service).value_or_key
+    options = lib.to_shipping_options(
+        payload.options,
+        package_options=package.options,
+        option_type=provider_units.ShippingOption,
+    )
+    customs = lib.to_customs_info(
+        payload.customs,
+        option_type=provider_units.ShippingOption,
+        shipper=shipper,
+        recipient=recipient,
+    )
+
+    request = colissimo.LabelRequest(
+        contractNumber=settings.contract_number,
+        password=settings.password,
+        outputFormat=colissimo.OutputFormat(
+            x=0,
+            y=0,
+            outputPrintingType=(
+                provider_units.LabelType.map(payload.label_type).value
+                or provider_utils.LabelType.PDF.value
+            ),
+            dematerialized=None,
+            returnType=None,
+            printCODDocument=None,
+        ),
+        letter=colissimo.Letter(
+            service=colissimo.Service(
+                productCode=service,
+                depositDate=lib.fdate(options.shipment_date.state, "%Y-%m-%d"),
+                mailBoxPicking=None,
+                mailBoxPickingDate=None,
+                vatCode=None,
+                vatPercentage=None,
+                vatAmount=None,
+                transportationAmount=options.declared_value.state,
+                totalAmount=options.declared_value.state,
+                orderNumber=None,
+                commercialName=shipper.company_name,
+                returnTypeChoice=None,
+                reseauPostal=0,
+            ),
+            parcel=colissimo.Parcel(
+                parcelNumber=package.parcel.reference_number,
+                insuranceAmount=None,
+                insuranceValue=options.insurance.state,
+                recommendationLevel=None,
+                weight=package.weight.KG,
+                nonMachinable=options.colissimo_non_machinable.state,
+                returnReceipt=options.colissimo_retun_receipt.state,
+                instructions=None,
+                pickupLocationId=None,
+                ftd=options.colissimo_ftd.state,
+                ddp=options.colissimo_ddp.state,
+                codamount=options.cash_on_delivery.state,
+                codcurrency=options.currency.state,
+                cod=options.cash_on_delivery.state is not None,
+            ),
+            customsDeclarations=(
+                colissimo.CustomsDeclarations(
+                    includeCustomsDeclarations=True,
+                    numberOfCopies=None,
+                    contents=colissimo.Contents(
+                        article=[
+                            colissimo.Article(
+                                description=item.description,
+                                quantity=item.quantity,
+                                weight=item.weight,
+                                value=item.value_amount,
+                                hsCode=item.hs_code,
+                                originCountry=item.origin_country,
+                                originCountryLabel=None,
+                                currency=options.currency.state,
+                                artref=item.metadata.get("artref", None),
+                                originalIdent=None,
+                                vatAmount=None,
+                                customsFees=item.metadata.get("customs_fees", None),
+                            )
+                            for item in customs.commodities
+                        ],
+                        category=None,
+                        original=None,
+                        explanations=None,
+                    ),
+                    importersReference=None,
+                    importersContact=shipper.contact,
+                    officeOrigin=None,
+                    comments=None,
+                    description=customs.content_description,
+                    invoiceNumber=customs.invoice,
+                    licenceNumber=customs.options.license_number.state,
+                    certificatNumber=customs.options.certificate_number.state,
+                    importerAddress=colissimo.Address(
+                        companyName=customs.duty_billing_address.company_name,
+                        lastName=customs.duty_billing_address.person_name,
+                        firstName=None,
+                        line0=customs.duty_billing_address.suite,
+                        line1=customs.duty_billing_address.street_number,
+                        line2=customs.duty_billing_address.address_line1,
+                        line3=customs.duty_billing_address.address_line2,
+                        countryCode=customs.duty_billing_address.country_code,
+                        countryLabel=customs.duty_billing_address.country_name,
+                        city=customs.duty_billing_address.city,
+                        zipCode=customs.duty_billing_address.postal_code,
+                        phoneNumber=None,
+                        mobileNumber=customs.duty_billing_address.phone_number,
+                        doorCode1=None,
+                        doorCode2=None,
+                        intercom=None,
+                        email=customs.duty_billing_address.email,
+                        language=None,
+                        stateOrProvinceCode=customs.duty_billing_address.state_code,
+                    ),
+                )
+                if payload.customs is not None
+                else None
+            ),
+            sender=colissimo.Sender(
+                senderParcelRef=payload.reference or package.parcel.reference_number,
+                address=colissimo.Address(
+                    companyName=shipper.company_name,
+                    lastName=shipper.person_name,
+                    firstName=None,
+                    line0=shipper.suite,
+                    line1=shipper.street_number,
+                    line2=shipper.address_line1,
+                    line3=shipper.address_line2,
+                    countryCode=shipper.country_code,
+                    countryLabel=shipper.country_name,
+                    city=shipper.city,
+                    zipCode=shipper.postal_code,
+                    phoneNumber=shipper.phone_number,
+                    mobileNumber=None,
+                    doorCode1=None,
+                    doorCode2=None,
+                    intercom=None,
+                    email=shipper.email,
+                    language="FR",
+                    stateOrProvinceCode=shipper.state_code,
+                ),
+            ),
+            addressee=colissimo.Addressee(
+                addresseeParcelRef=payload.reference or package.parcel.reference_number,
+                codeBarForReference=None,
+                serviceInfo=None,
+                promotionCode=None,
+                address=colissimo.Address(
+                    companyName=recipient.company_name,
+                    lastName=recipient.person_name,
+                    firstName=None,
+                    line0=recipient.suite,
+                    line1=recipient.street_number,
+                    line2=recipient.address_line1,
+                    line3=recipient.address_line2,
+                    countryCode=recipient.country_code,
+                    countryLabel=recipient.country_name,
+                    city=recipient.city,
+                    zipCode=recipient.postal_code,
+                    phoneNumber=recipient.phone_number,
+                    mobileNumber=None,
+                    doorCode1=None,
+                    doorCode2=None,
+                    intercom=None,
+                    email=recipient.email,
+                    language="FR",
+                    stateOrProvinceCode=recipient.state_code,
+                ),
+            ),
+            codSenderAddress=(
+                colissimo.Address(
+                    companyName=recipient.company_name,
+                    lastName=recipient.person_name,
+                    firstName=None,
+                    line0=recipient.suite,
+                    line1=recipient.street_number,
+                    line2=recipient.address_line1,
+                    line3=recipient.address_line2,
+                    countryCode=recipient.country_code,
+                    countryLabel=recipient.country_name,
+                    city=recipient.city,
+                    zipCode=recipient.postal_code,
+                    phoneNumber=recipient.phone_number,
+                    mobileNumber=None,
+                    doorCode1=None,
+                    doorCode2=None,
+                    intercom=None,
+                    email=recipient.email,
+                    language="FR",
+                    stateOrProvinceCode=recipient.state_code,
+                )
+                if options.cash_on_delivery.state is not None
+                else None
+            ),
+            uploadDocument=None,
+            features=colissimo.Features(printTrackingBarcode=True),
+        ),
+        fields=(
+            colissimo.Fields(
+                customField=[
+                    colissimo.Field(
+                        key=key,
+                        value=value,
+                    )
+                    for key, value in [
+                        ("LENGTH", package.length.value),
+                        ("WIDTH", package.width.value),
+                        ("HEIGHT", package.height.value),
+                    ]
+                ]
+            )
+            if any(
+                [
+                    package.length.value,
+                    package.width.value,
+                    package.height.value,
+                ]
+            )
+            else None
+        ),
+    )
+
+    return lib.Serializable(
+        request,
+        lib.to_dict,
+        dict(label_type=payload.label_type or "PDF"),
+    )

karrio/providers/colissimo/tracking.py

@@ -0,0 +1,79 @@
+import karrio.schemas.colissimo.tracking_response as colissimo
+import typing
+import karrio.lib as lib
+import karrio.core.units as units
+import karrio.core.models as models
+import karrio.providers.colissimo.error as error
+import karrio.providers.colissimo.utils as provider_utils
+import karrio.providers.colissimo.units as provider_units
+
+
+def parse_tracking_response(
+    _response: lib.Deserializable[typing.Union[dict, typing.List[dict]]],
+    settings: provider_utils.Settings,
+) -> typing.Tuple[typing.List[models.TrackingDetails], typing.List[models.Message]]:
+    response = _response.deserialize()
+
+    responses = response if isinstance(response, list) else [response]
+    messages = error.parse_laposte_error_response(responses, settings)
+    tracking_details = [
+        _extract_details(res["shipment"], settings)
+        for res in responses
+        if str(res.get("returnCode")).startswith("20")
+    ]
+
+    return tracking_details, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+) -> models.TrackingDetails:
+    shipment = lib.to_object(colissimo.Shipment, data)
+    status = next(
+        (
+            status.name
+            for status in list(provider_units.TrackingStatus)
+            if shipment.event[0].code in status.value
+        ),
+        provider_units.TrackingStatus.in_transit.name,
+    )
+
+    return models.TrackingDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        tracking_number=shipment.idShip,
+        status=status,
+        events=[
+            models.TrackingEvent(
+                date=lib.fdate(event.date, "%Y-%m-%dT%H:%M:%S%z"),
+                description=event.label,
+                code=event.code,
+                time=lib.flocaltime(event.date, "%Y-%m-%dT%H:%M:%S%z"),
+            )
+            for event in shipment.event
+        ],
+        estimated_delivery=lib.fdate(shipment.deliveryDate, "%Y-%m-%dT%H:%M:%S%z"),
+        delivered=shipment.isFinal,
+        info=models.TrackingInfo(
+            carrier_tracking_link=shipment.url,
+            expected_delivery=lib.fdate(shipment.estimDate, "%Y-%m-%dT%H:%M:%S%z"),
+            shipment_service=shipment.product,
+            shipping_date=lib.fdate(shipment.entryDate, "%Y-%m-%dT%H:%M:%S%z"),
+            shipment_origin_country=getattr(
+                shipment.contextData, "originCountry", None
+            ),
+            shipment_destination_country=getattr(
+                shipment.contextData, "arrivalCountry", None
+            ),
+        ),
+    )
+
+
+def tracking_request(
+    payload: models.TrackingRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+    request = payload.tracking_numbers
+
+    return lib.Serializable(request)

karrio/providers/colissimo/units.py

@@ -0,0 +1,169 @@
+import karrio.lib as lib
+import karrio.core.units as units
+import karrio.core.models as models
+
+
+class PackagingType(lib.StrEnum):
+    """Carrier specific packaging type"""
+
+    PACKAGE = "PACKAGE"
+
+    """ Unified Packaging type mapping """
+    envelope = PACKAGE
+    pak = PACKAGE
+    tube = PACKAGE
+    pallet = PACKAGE
+    small_box = PACKAGE
+    medium_box = PACKAGE
+    your_packaging = PACKAGE
+
+
+class LabelType(lib.Enum):
+    ZPL_10x15_203dpi = "ZPL_10x15_203dpi"
+    ZPL_10x15_300dpi = "ZPL_10x15_300dpi"
+    DPL_10x15_203dpi = "DPL_10x15_203dpi"
+    DPL_10x15_300dpi = "DPL_10x15_300dpi"
+    PDF_10x15_300dpi = "PDF_10x15_300dpi"
+    PDF_A4_300dpi = "PDF_A4_300dpi"
+    ZPL_10x10_203dpi = "ZPL_10x10_203dpi"
+    ZPL_10x10_300dpi = "ZPL_10x10_300dpi"
+    DPL_10x10_203dpi = "DPL_10x10_203dpi"
+    DPL_10x10_300dpi = "DPL_10x10_300dpi"
+    PDF_10x10_300dpi = "PDF_10x10_300dpi"
+    PDF_10x12_300dpi = "PDF_10x12_300dpi"
+    ZPL_10x15_203dpi_UL = "ZPL_10x15_203dpi_UL"
+    ZPL_10x15_300dpi_UL = "ZPL_10x15_300dpi_UL"
+    DPL_10x15_203dpi_UL = "DPL_10x15_203dpi_UL"
+    DPL_10x15_300dpi_UL = "DPL_10x15_300dpi_UL"
+    PDF_10x15_300dpi_UL = "PDF_10x15_300dpi_UL"
+    PDF_A4_300dpi_UL = "PDF_A4_300dpi_UL"
+
+    """ Unified Label type mapping """
+    PDF = PDF_10x15_300dpi
+    ZPL = ZPL_10x10_300dpi
+
+
+class ConnectionConfig(lib.Enum):
+    lang = lib.OptionEnum("lang", lib.units.create_enum("Lang", ["FR", "EN"]))
+
+
+class ServiceName(lib.Enum):
+    """Carrier specific services"""
+
+    colissimo_home_without_signature = "Colissimo Home - without signature"
+    colissimo_home_with_signature = "Colissimo Home - with signature"
+    colissimo_eco_france = "Colissimo Eco France"
+    colissimo_return_france = "Colissimo Return France CORE 8R***"
+    colissimo_flash_without_signature = "Colissimo Flash – without signature"
+    colissimo_flash_with_signature = "Colissimo Flash – with signature"
+    colissimo_oversea_home_without_signature = "Colissimo Home OM - without signature"
+    colissimo_oversea_home_with_signature = "Colissimo Home OM - with signature"
+    colissimo_eco_om_without_signature = "Colissimo Eco OM - without signature"
+    colissimo_eco_om_with_signature = "Colissimo Eco OM - with signature"
+    colissimo_retour_om = "Colissimo Retour OM"
+    colissimo_home_international_without_signature = (
+        "Colissimo Home International - without signature***"
+    )
+    colissimo_home_international_with_signature = (
+        "Colissimo Home International - with signature***"
+    )
+    colissimo_return_international_to_france = (
+        "Colissimo Return International – Foreign country to France"
+    )
+    colissimo_return_international_from_france = (
+        "Colissimo Return International – France to foreign cournty"
+    )
+    colissimo_economical_big_export_offer = (
+        "Economical Big Export offer (test offer for China for a pilot customer)"
+    )
+    colissimo_out_of_home_national_international = (
+        "Colissimo Out Of Home National and International : **"
+    )
+    colissimo_out_of_home_post_office = "Colissimo - Out Of Home – at Post Office"
+    colissimo_out_of_home_pickup_points_station_lockers = (
+        "Colissimo - Out Of Home – at Pickup points or Pickup Station lockers"
+    )
+    colissimo_out_of_home_pickup_point = "Colissimo - Out Of Home – at pickup point"
+    colissimo_out_of_home_pickup_station_lockers = (
+        "Colissimo - Out Of Home – at Pickup Station lockers"
+    )
+
+
+class ShippingService(lib.StrEnum):
+    """Carrier specific services"""
+
+    colissimo_home_without_signature = "DOM"
+    colissimo_home_with_signature = "DOS"
+    colissimo_eco_france = "CECO"
+    colissimo_return_france = "CORE"
+    colissimo_flash_without_signature = "COLR"
+    colissimo_flash_with_signature = "J+1"
+    colissimo_oversea_home_without_signature = "COM"
+    colissimo_oversea_home_with_signature = "CDS"
+    colissimo_eco_om_without_signature = "ECO"
+    colissimo_eco_om_with_signature = "ECOS"
+    colissimo_retour_om = "CORI"
+    colissimo_home_international_without_signature = colissimo_home_without_signature
+    colissimo_home_international_with_signature = colissimo_home_with_signature
+    colissimo_return_international_to_france = colissimo_retour_om
+    colissimo_return_international_from_france = "CORF"
+    colissimo_economical_big_export_offer = "ACCI"
+    colissimo_out_of_home_national_international = "HD"
+    colissimo_out_of_home_post_office = colissimo_out_of_home_national_international
+    colissimo_out_of_home_pickup_points_station_lockers = (
+        colissimo_out_of_home_national_international
+    )
+    colissimo_out_of_home_pickup_point = colissimo_out_of_home_national_international
+    colissimo_out_of_home_pickup_station_lockers = (
+        colissimo_out_of_home_national_international
+    )
+
+
+class ShippingOption(lib.Enum):
+    """Carrier specific options"""
+
+    colissimo_insurance_value = lib.OptionEnum("insuranceValue", lib.to_money)
+    colissimo_cod_amount = lib.OptionEnum("CODAmount", lib.to_money)
+    colissimo_return_receipt = lib.OptionEnum("returnReceipt", bool)
+    colissimo_ftd = lib.OptionEnum("ftd", bool)
+    colissimo_non_machinable = lib.OptionEnum("nonMachinable", bool)
+    colissimo_ddp = lib.OptionEnum("ddp", bool)
+    colissimo_instructions = lib.OptionEnum("instructions")
+
+    """ Unified Option type mapping """
+    insurance = colissimo_insurance_value
+    cash_on_delivery = colissimo_cod_amount
+
+
+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 TrackingStatus(lib.Enum):
+    delivered = ["DI1"]
+    in_transit = [""]
+    out_for_delivery = ["MD2", "ET1"]
+
+
+DEFAULT_SERVICES = [
+    models.ServiceLevel(
+        service_name="Colissimo Home - without signature",
+        service_code="colissimo_home_without_signature",
+        currency="EUR",
+        domicile=True,
+        zones=[models.ServiceZone(label="Zone 1", rate=0.0)],
+    ),
+]

karrio/providers/colissimo/utils.py

@@ -0,0 +1,71 @@
+import karrio.lib as lib
+import karrio.core as core
+
+JSON_START = """<jsonInfos>
+
+{"""
+JSON_END = """}
+--uuid:"""
+LABEL_START = """<label>
+
+"""
+LABEL_END = r"""
+--uuid:"""
+
+
+class Settings(core.Settings):
+    """Colissimo connection settings."""
+
+    password: str
+    contract_number: str
+    laposte_api_key: str = None
+
+    account_country_code: str = "FR"
+    config: dict = {}
+
+    @property
+    def carrier_name(self):
+        return "colissimo"
+
+    @property
+    def server_url(self):
+        return "https://ws.colissimo.fr/sls-ws/SlsServiceWSRest/2.0"
+
+    @property
+    def laposte_server_url(self):
+        return "https://api.laposte.fr/suivi/v2"
+
+    @property
+    def tracking_url(self):
+        return "https://www.laposte.fr/outils/suivre-vos-envois?code={}"
+
+
+def parse_response(response: str) -> dict:
+    """Parse colissimo multipart response."""
+
+    uuid = lib.failsafe(
+        lambda: response[
+            response.rfind("--uuid:") + len("--uuid:") : response.rfind("--")
+        ]
+    )
+    json_info = lib.failsafe(
+        lambda: response[
+            response.find(JSON_START) + len(JSON_START) : response.rfind(JSON_END)
+        ]
+    )
+    label = lib.failsafe(
+        lambda: (
+            response[
+                response.find(LABEL_START)
+                + len(LABEL_START) : response.rfind(LABEL_END)
+            ]
+            if "<label>" in response
+            else None
+        )
+    )
+
+    return dict(
+        uuid=uuid,
+        label=label,
+        json_info=lib.to_dict("{" + (json_info or "") + "}"),
+    )

karrio/schemas/colissimo/error_response.py

@@ -0,0 +1,13 @@
+from attr import s
+from typing import Optional
+
+
+@s(auto_attribs=True)
+class ErrorResponse:
+    returnCode: Optional[int] = None
+    returnMessage: Optional[str] = None
+    lang: Optional[str] = None
+    scope: Optional[str] = None
+    idShip: Optional[str] = None
+    code: Optional[str] = None
+    message: Optional[str] = None

karrio/schemas/colissimo/label_request.py

@@ -0,0 +1,182 @@
+from attr import s
+from typing import Optional, List
+from jstruct import JList, JStruct
+
+
+@s(auto_attribs=True)
+class Field:
+    key: Optional[str] = None
+    value: Optional[str] = None
+
+
+@s(auto_attribs=True)
+class Fields:
+    field: List[Field] = JList[Field]
+    customField: List[Field] = JList[Field]
+
+
+@s(auto_attribs=True)
+class Address:
+    companyName: Optional[str] = None
+    lastName: Optional[str] = None
+    firstName: Optional[str] = None
+    line0: Optional[str] = None
+    line1: Optional[str] = None
+    line2: Optional[str] = None
+    line3: Optional[str] = None
+    countryCode: Optional[str] = None
+    countryLabel: Optional[str] = None
+    city: Optional[str] = None
+    zipCode: Optional[str] = None
+    phoneNumber: Optional[str] = None
+    mobileNumber: Optional[str] = None
+    doorCode1: Optional[str] = None
+    doorCode2: Optional[str] = None
+    intercom: Optional[str] = None
+    email: Optional[str] = None
+    language: Optional[str] = None
+    stateOrProvinceCode: Optional[str] = None
+
+
+@s(auto_attribs=True)
+class Addressee:
+    addresseeParcelRef: Optional[str] = None
+    codeBarForReference: Optional[bool] = None
+    serviceInfo: Optional[str] = None
+    promotionCode: Optional[str] = None
+    address: Optional[Address] = JStruct[Address]
+
+
+@s(auto_attribs=True)
+class Article:
+    description: Optional[str] = None
+    quantity: Optional[int] = None
+    weight: Optional[int] = None
+    value: Optional[int] = None
+    hsCode: Optional[str] = None
+    originCountry: Optional[str] = None
+    originCountryLabel: Optional[str] = None
+    currency: Optional[str] = None
+    artref: Optional[str] = None
+    originalIdent: Optional[str] = None
+    vatAmount: Optional[int] = None
+    customsFees: Optional[int] = None
+
+
+@s(auto_attribs=True)
+class Category:
+    value: Optional[int] = None
+
+
+@s(auto_attribs=True)
+class Original:
+    originalIdent: Optional[str] = None
+    originalInvoiceNumber: Optional[str] = None
+    originalInvoiceDate: Optional[str] = None
+    originalParcelNumber: Optional[str] = None
+
+
+@s(auto_attribs=True)
+class Contents:
+    article: List[Article] = JList[Article]
+    category: Optional[Category] = JStruct[Category]
+    original: List[Original] = JList[Original]
+    explanations: Optional[str] = None
+
+
+@s(auto_attribs=True)
+class CustomsDeclarations:
+    includeCustomsDeclarations: Optional[bool] = None
+    numberOfCopies: Optional[int] = None
+    contents: Optional[Contents] = JStruct[Contents]
+    importersReference: Optional[str] = None
+    importersContact: Optional[str] = None
+    officeOrigin: Optional[str] = None
+    comments: Optional[str] = None
+    description: Optional[str] = None
+    invoiceNumber: Optional[str] = None
+    licenceNumber: Optional[str] = None
+    certificatNumber: Optional[str] = None
+    importerAddress: Optional[Address] = JStruct[Address]
+
+
+@s(auto_attribs=True)
+class Features:
+    printTrackingBarcode: Optional[bool] = None
+
+
+@s(auto_attribs=True)
+class Parcel:
+    parcelNumber: Optional[str] = None
+    insuranceAmount: Optional[int] = None
+    insuranceValue: Optional[int] = None
+    recommendationLevel: Optional[str] = None
+    weight: Optional[int] = None
+    nonMachinable: Optional[bool] = None
+    returnReceipt: Optional[bool] = None
+    instructions: Optional[str] = None
+    pickupLocationId: Optional[str] = None
+    ftd: Optional[bool] = None
+    ddp: Optional[bool] = None
+    codamount: Optional[int] = None
+    codcurrency: Optional[str] = None
+    cod: Optional[bool] = None
+
+
+@s(auto_attribs=True)
+class Sender:
+    senderParcelRef: Optional[str] = None
+    address: Optional[Address] = JStruct[Address]
+
+
+@s(auto_attribs=True)
+class Service:
+    productCode: Optional[str] = None
+    depositDate: Optional[str] = None
+    mailBoxPicking: Optional[bool] = None
+    mailBoxPickingDate: Optional[str] = None
+    vatCode: Optional[int] = None
+    vatPercentage: Optional[int] = None
+    vatAmount: Optional[int] = None
+    transportationAmount: Optional[int] = None
+    totalAmount: Optional[int] = None
+    orderNumber: Optional[str] = None
+    commercialName: Optional[str] = None
+    returnTypeChoice: Optional[int] = None
+    reseauPostal: Optional[str] = None
+
+
+@s(auto_attribs=True)
+class UploadDocument:
+    documentContent: List[str] = []
+
+
+@s(auto_attribs=True)
+class Letter:
+    service: Optional[Service] = JStruct[Service]
+    parcel: Optional[Parcel] = JStruct[Parcel]
+    customsDeclarations: Optional[CustomsDeclarations] = JStruct[CustomsDeclarations]
+    sender: Optional[Sender] = JStruct[Sender]
+    addressee: Optional[Addressee] = JStruct[Addressee]
+    codSenderAddress: Optional[Address] = JStruct[Address]
+    uploadDocument: Optional[UploadDocument] = JStruct[UploadDocument]
+    features: Optional[Features] = JStruct[Features]
+
+
+@s(auto_attribs=True)
+class OutputFormat:
+    x: Optional[int] = None
+    y: Optional[int] = None
+    outputPrintingType: Optional[str] = None
+    dematerialized: Optional[bool] = None
+    returnType: Optional[str] = None
+    printCODDocument: Optional[bool] = None
+
+
+@s(auto_attribs=True)
+class LabelRequest:
+    contractNumber: Optional[str] = None
+    password: Optional[str] = None
+    outputFormat: Optional[OutputFormat] = JStruct[OutputFormat]
+    letter: Optional[Letter] = JStruct[Letter]
+    fields: Optional[Fields] = JStruct[Fields]

karrio/schemas/colissimo/label_response.py

@@ -0,0 +1,26 @@
+from attr import s
+from typing import Optional, Any, List
+from jstruct import JList, JStruct
+
+
+@s(auto_attribs=True)
+class LabelV2Response:
+    parcelNumber: Optional[str] = None
+    parcelNumberPartner: Optional[str] = None
+    pdfUrl: Any = None
+    fields: Any = None
+
+
+@s(auto_attribs=True)
+class Message:
+    id: Optional[int] = None
+    type: Optional[str] = None
+    messageContent: Optional[str] = None
+    replacementValues: List[Any] = []
+
+
+@s(auto_attribs=True)
+class LabelResponse:
+    messages: List[Message] = JList[Message]
+    labelXmlV2Reponse: Any = None
+    labelV2Response: Optional[LabelV2Response] = JStruct[LabelV2Response]

karrio/schemas/colissimo/tracking_request.py

@@ -0,0 +1,7 @@
+from attr import s
+from typing import Optional
+
+
+@s(auto_attribs=True)
+class TrackingRequest:
+    noSuivi: Optional[str] = None

karrio/schemas/colissimo/tracking_response.py

@@ -0,0 +1,61 @@
+from attr import s
+from typing import Optional, List
+from jstruct import JStruct, JList
+
+
+@s(auto_attribs=True)
+class DeliveryChoice:
+    deliveryChoice: Optional[int] = None
+
+
+@s(auto_attribs=True)
+class ContextData:
+    deliveryChoice: Optional[DeliveryChoice] = JStruct[DeliveryChoice]
+    originCountry: Optional[str] = None
+    arrivalCountry: Optional[str] = None
+
+
+@s(auto_attribs=True)
+class Event:
+    code: Optional[str] = None
+    label: Optional[str] = None
+    date: Optional[str] = None
+
+
+@s(auto_attribs=True)
+class Timeline:
+    shortLabel: Optional[str] = None
+    longLabel: Optional[str] = None
+    id: Optional[int] = None
+    country: Optional[str] = None
+    status: Optional[bool] = None
+    type: Optional[int] = None
+    date: Optional[str] = None
+
+
+@s(auto_attribs=True)
+class Shipment:
+    idShip: Optional[str] = None
+    holder: Optional[int] = None
+    product: Optional[str] = None
+    isFinal: Optional[bool] = None
+    deliveryDate: Optional[str] = None
+    entryDate: Optional[str] = None
+    timeline: List[Timeline] = JList[Timeline]
+    event: List[Event] = JList[Event]
+    contextData: Optional[ContextData] = JStruct[ContextData]
+    estimDate: Optional[str] = None
+    url: Optional[str] = None
+
+
+@s(auto_attribs=True)
+class Response:
+    lang: Optional[str] = None
+    scope: Optional[str] = None
+    returnCode: Optional[int] = None
+    shipment: Optional[Shipment] = JStruct[Shipment]
+
+
+@s(auto_attribs=True)
+class TrackingResponse:
+    responses: List[Response] = JList[Response]

karrio_colissimo-2025.5rc1.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: karrio_colissimo
+Version: 2025.5rc1
+Summary: Karrio - Colissimo Shipping Extension
+Author-email: karrio <hello@karrio.io>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/karrioapi/karrio
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: karrio
+
+
+# karrio.colissimo
+
+This package is a Colissimo extension of the [karrio](https://pypi.org/project/karrio) multi carrier shipping SDK.
+
+## Requirements
+
+`Python 3.7+`
+
+## Installation
+
+```bash
+pip install karrio.colissimo
+```
+
+## Usage
+
+```python
+import karrio.sdk as karrio
+from karrio.mappers.colissimo.settings import Settings
+
+
+# Initialize a carrier gateway
+colissimo = karrio.gateway["colissimo"].create(
+    Settings(
+        ...
+    )
+)
+```
+
+Check the [Karrio Mutli-carrier SDK docs](https://docs.karrio.io) for Shipping API requests

karrio_colissimo-2025.5rc1.dist-info/RECORD

@@ -0,0 +1,23 @@
+karrio/mappers/colissimo/__init__.py,sha256=ifjuTREZiGGSrlhTYVKx7UkbRZNqr6m9R_LTA0_jkQ4,155
+karrio/mappers/colissimo/mapper.py,sha256=-TCZysxQ_67Nz48BFM0qCVCBpkSVRoC1qH-nzbPHHog,1599
+karrio/mappers/colissimo/proxy.py,sha256=B7jkoqRBBUy3ZIFTjpra40dSqw9O2B9QmzBQm9x6mx8,1532
+karrio/mappers/colissimo/settings.py,sha256=-NqBwwBDqYWlHoxCRHpIBn3GFwlGgHgtgrDNTN8hd00,1011
+karrio/plugins/colissimo/__init__.py,sha256=tMZGuJQqNTQe8HULxGBm18Xgd_pjpSbIQUycEWtYktE,868
+karrio/providers/colissimo/__init__.py,sha256=zGCjtpOeH6IB2BtmFChbuMGFRPcEwxLshRf4AgjPEec,260
+karrio/providers/colissimo/error.py,sha256=U53tPupLsDcO9Jdbk9niz0PIgCE36hv7LqlfiUJzdwY,1506
+karrio/providers/colissimo/tracking.py,sha256=4_r5F4jgC8j-be4Sx5RXSGuWbpO36pH_TAcYmUyBn-w,2747
+karrio/providers/colissimo/units.py,sha256=oBKh9h_87TD3uwQUWNgM8FfDv0KuhSGRnXWFLQZRUPI,6317
+karrio/providers/colissimo/utils.py,sha256=rWfvBXJ53QS6nSC8FetWZ1SmN3JiwUApvROdwcrZtL4,1555
+karrio/providers/colissimo/shipment/__init__.py,sha256=wNMIG1QNPaIopEfjD05wLqUjmRhYj4T05kFONkivFzA,110
+karrio/providers/colissimo/shipment/create.py,sha256=eD0jAD9hHLGy_YCEf3ELoAwq_PZtKumUoSBhciBrDto,12117
+karrio/schemas/colissimo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+karrio/schemas/colissimo/error_response.py,sha256=iBYZjvqI6JKwQCfZBObNNfIBG9iUu9Pf-ZgcTicsrd8,330
+karrio/schemas/colissimo/label_request.py,sha256=pSMOWHrz8ulakt3-HaN86oY6j9bSjIMfla2zQ9sZ1sc,5338
+karrio/schemas/colissimo/label_response.py,sha256=3g2cwUNTalKVCUmvbpHhGlPdKMIey8eam6xjhfTP9Wo,647
+karrio/schemas/colissimo/tracking_request.py,sha256=K0S51-ktf4rfXNGKdj-basUAmLALwH8emY_VC_vmpnY,128
+karrio/schemas/colissimo/tracking_response.py,sha256=U3W2TbdT5ld_ZlZIMXRY62ScCEZ2nsFdcQPTFFNudl0,1525
+karrio_colissimo-2025.5rc1.dist-info/METADATA,sha256=DOuYP6F130txZtuhVq8jszQ_vE75djHT8MYH9QppqGk,1008
+karrio_colissimo-2025.5rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+karrio_colissimo-2025.5rc1.dist-info/entry_points.txt,sha256=5D8gMo5ptusxiT7anI2epCZNsG5N56UXv83pmZvvvjo,63
+karrio_colissimo-2025.5rc1.dist-info/top_level.txt,sha256=FZCY8Nwft8oEGHdl--xku8P3TrnOxu5dETEU_fWpRSM,20
+karrio_colissimo-2025.5rc1.dist-info/RECORD,,

karrio_colissimo-2025.5rc1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

karrio_colissimo-2025.5rc1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[karrio.plugins]
+colissimo = karrio.plugins.colissimo:METADATA

karrio_colissimo-2025.5rc1.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+dist
+karrio
+schemas