karrio-geodis 2025.5rc1__py3-none-any.whl

karrio/mappers/geodis/__init__.py

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

karrio/mappers/geodis/mapper.py

@@ -0,0 +1,51 @@
+"""Karrio GEODIS client mapper."""
+
+import typing
+import karrio.lib as lib
+import karrio.api.mapper as mapper
+import karrio.core.models as models
+import karrio.providers.geodis as provider
+import karrio.mappers.geodis.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 create_cancel_shipment_request(
+        self, payload: models.ShipmentCancelRequest
+    ) -> lib.Serializable:
+        return provider.shipment_cancel_request(payload, self.settings)
+
+    def parse_rate_response(
+        self, response: lib.Deserializable
+    ) -> typing.Tuple[typing.List[models.RateDetails], typing.List[models.Message]]:
+        return universal_provider.parse_rate_response(response, self.settings)
+
+    def parse_shipment_response(
+        self, response: lib.Deserializable
+    ) -> typing.Tuple[models.ShipmentDetails, typing.List[models.Message]]:
+        return provider.parse_shipment_response(response, self.settings)
+
+    def parse_cancel_shipment_response(
+        self, response: lib.Deserializable
+    ) -> typing.Tuple[models.ConfirmationDetails, typing.List[models.Message]]:
+        return provider.parse_shipment_cancel_response(response, self.settings)
+
+    def parse_tracking_response(
+        self, response: lib.Deserializable
+    ) -> typing.Tuple[typing.List[models.TrackingDetails], typing.List[models.Message]]:
+        return provider.parse_tracking_response(response, self.settings)

karrio/mappers/geodis/proxy.py

@@ -0,0 +1,76 @@
+"""Karrio GEODIS client proxy."""
+
+import json
+import typing
+import karrio.lib as lib
+import karrio.api.proxy as proxy
+import karrio.mappers.geodis.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]:
+        service = "api/wsclient/enregistrement-envois"
+        data = request.serialize()
+
+        response = lib.request(
+            url=f"{self.settings.server_url}/{service}",
+            data=json.dumps(data, separators=(",", ":")),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={
+                "Accept": "*/*",
+                "Content-Type": "application/json",
+                "X-GEODIS-Service": self.settings.get_token(service, data),
+            },
+        )
+
+        return lib.Deserializable(response, lib.to_dict, request.ctx)
+
+    def cancel_shipment(self, request: lib.Serializable) -> lib.Deserializable[str]:
+        service = "api/wsclient/suppression-envois"
+        data = request.serialize()
+
+        response = lib.request(
+            url=f"{self.settings.server_url}/{service}",
+            data=json.dumps(data, separators=(",", ":")),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={
+                "Accept": "*/*",
+                "Content-Type": "application/json",
+                "X-GEODIS-Service": self.settings.get_token(service, data),
+            },
+        )
+
+        return lib.Deserializable(response, lib.to_dict)
+
+    def get_tracking(self, requests: lib.Serializable) -> lib.Deserializable:
+        service = "api/zoomclient/recherche-envoi"
+        track = lambda data: (
+            data["noSuivi"],
+            lib.request(
+                url=f"{self.settings.server_url}/{service}",
+                trace=self.trace_as("json"),
+                method="POST",
+                data=json.dumps(data, separators=(",", ":")),
+                headers={
+                    "Content-Type": "application/json",
+                    "X-GEODIS-Service": self.settings.get_token(service, data),
+                },
+            ),
+        )
+
+        responses: typing.List[typing.Tuple[str, str]] = lib.run_asynchronously(
+            track, requests.serialize()
+        )
+
+        return lib.Deserializable(
+            responses,
+            lambda response: [(key, lib.to_dict(res)) for key, res in response],
+        )

karrio/mappers/geodis/settings.py

@@ -0,0 +1,36 @@
+"""Karrio GEODIS client settings."""
+
+import attr
+import typing
+import jstruct
+import karrio.core.models as models
+import karrio.providers.geodis.utils as provider_utils
+import karrio.providers.geodis.units as provider_units
+
+
+@attr.s(auto_attribs=True)
+class Settings(provider_utils.Settings):
+    """GEODIS connection settings."""
+
+    # required carrier specific properties
+    api_key: str
+    identifier: str
+    code_client: str = None
+    language: provider_utils.LanguageEnum = "fr"  # type: ignore
+
+    # generic properties
+    id: str = None
+    test_mode: bool = False
+    carrier_id: str = "geodis"
+    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/geodis/__init__.py

@@ -0,0 +1,20 @@
+import karrio.core.metadata as metadata
+import karrio.mappers.geodis as mappers
+import karrio.providers.geodis.units as units
+
+
+METADATA = metadata.PluginMetadata(
+    status="beta",
+    id="geodis",
+    label="GEODIS",
+    # Integrations
+    Mapper=mappers.Mapper,
+    Proxy=mappers.Proxy,
+    Settings=mappers.Settings,
+    # Data Units
+    is_hub=False,
+    options=units.ShippingOption,
+    services=units.ShippingService,
+    connection_configs=units.ConnectionConfig,
+    service_levels=units.DEFAULT_SERVICES,
+)

karrio/providers/geodis/__init__.py

@@ -0,0 +1,11 @@
+from karrio.providers.geodis.utils import Settings
+from karrio.providers.geodis.shipment import (
+    parse_shipment_cancel_response,
+    parse_shipment_response,
+    shipment_cancel_request,
+    shipment_request,
+)
+from karrio.providers.geodis.tracking import (
+    parse_tracking_response,
+    tracking_request,
+)

karrio/providers/geodis/error.py

@@ -0,0 +1,29 @@
+import karrio.schemas.geodis.error_response as geodis
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+import karrio.providers.geodis.utils as provider_utils
+
+
+def parse_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(geodis.ErrorResponseType, res)
+        for res in responses
+        if res.get("ok") is False
+    ]
+
+    return [
+        models.Message(
+            carrier_id=settings.carrier_id,
+            carrier_name=settings.carrier_name,
+            code=error.codeErreur,
+            message=error.texteErreur,
+            details={**kwargs},
+        )
+        for error in errors
+    ]

karrio/providers/geodis/shipment/__init__.py

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

karrio/providers/geodis/shipment/cancel.py

@@ -0,0 +1,39 @@
+import karrio.schemas.geodis.cancel_request as geodis
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+import karrio.providers.geodis.error as error
+import karrio.providers.geodis.utils as provider_utils
+import karrio.providers.geodis.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(response, settings)
+    success = response.get("ok") is True
+
+    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:
+    request = geodis.CancelRequestType(listNosSuivis=[payload.shipment_identifier])
+
+    return lib.Serializable(request, lib.to_dict)

karrio/providers/geodis/shipment/create.py

@@ -0,0 +1,202 @@
+import karrio.schemas.geodis.shipping_request as geodis
+import karrio.schemas.geodis.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.geodis.error as error
+import karrio.providers.geodis.utils as provider_utils
+import karrio.providers.geodis.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)
+        if response.get("ok") is False
+        else []
+    )
+    shipment = (
+        _extract_details(response, settings, _response.ctx)
+        if response.get("ok")
+        else None
+    )
+
+    return shipment, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+    ctx: dict,
+) -> models.ShipmentDetails:
+    shipment = lib.to_object(
+        shipping.ShippingResponseType, data
+    ).contenu.listRetoursEnvois[0]
+    label = shipment.docEtiquette.contenu
+
+    return models.ShipmentDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        tracking_number=shipment.noSuivi,
+        shipment_identifier=shipment.noSuivi,
+        label_type=ctx.get("label_type", "PDF"),
+        docs=models.Documents(label=label),
+        meta=dict(
+            carrier_tracking_link=shipment.urlSuiviDestinataire,
+            noRecepisse=shipment.noRecepisse,
+            codeProduit=shipment.codeProduit,
+        ),
+    )
+
+
+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
+    customs = lib.to_customs_info(payload.customs)
+    options = lib.to_shipping_options(
+        payload.options,
+        package_options=packages.options,
+        option_type=provider_units.ShippingOption,
+    )
+    label_type = provider_units.LabelType.map(payload.label_type or "PDF")
+
+    request = geodis.ShippingRequestType(
+        modificationParReference1=None,
+        impressionEtiquette=True,
+        typeImpressionEtiquette=label_type.value or "P",
+        formatEtiquette="1",
+        validationEnvoi=options.geodis_validate_envoi.state,
+        suppressionSiEchecValidation=True,
+        impressionBordereau=False,
+        impressionRecapitulatif=True,
+        listEnvois=[
+            geodis.ListEnvoisType(
+                noRecepisse=options.geodis_no_recepisse.state,
+                noSuivi=None,
+                horsSite=None,
+                codeSa=settings.connection_config.agency_code.state,
+                codeClient=settings.code_client,
+                codeProduit=service,
+                reference1=payload.reference,
+                reference2=None,
+                expediteur=geodis.DestinataireType(
+                    nom=shipper.company_name or shipper.person_name,
+                    adresse1=shipper.address_line1,
+                    adresse2=shipper.address_line2,
+                    codePostal=shipper.postal_code,
+                    ville=shipper.city,
+                    codePays=shipper.country_code,
+                    nomContact=shipper.person_name,
+                    email=shipper.email,
+                    telFixe=shipper.phone_number,
+                    indTelMobile=None,
+                    telMobile=None,
+                    codePorte=shipper.suite,
+                    codeTiers=None,
+                    noEntrepositaireAgree=None,
+                    particulier=shipper.residential,
+                ),
+                dateDepartEnlevement=lib.fdate(options.shipment_date.state),
+                instructionEnlevement=options.geodis_instruction_enlevement.state,
+                destinataire=geodis.DestinataireType(
+                    nom=recipient.company_name or recipient.person_name,
+                    adresse1=recipient.address_line1,
+                    adresse2=recipient.address_line2,
+                    codePostal=recipient.postal_code,
+                    ville=recipient.city,
+                    codePays=recipient.country_code,
+                    nomContact=recipient.person_name,
+                    email=recipient.email,
+                    telFixe=recipient.phone_number,
+                    indTelMobile=None,
+                    telMobile=None,
+                    codePorte=recipient.suite,
+                    codeTiers=None,
+                    noEntrepositaireAgree=None,
+                    particulier=recipient.residential,
+                ),
+                listUmgs=[
+                    geodis.ListUmgType(
+                        palette=(
+                            package.packaging_type == units.PackagingUnit.pallet.name
+                        ),
+                        paletteConsignee=None,
+                        quantite=1,
+                        poids=package.weight.KG,
+                        volume=package.volume.m3,
+                        longueurUnitaire=package.length.CM,
+                        largeurUnitaire=package.width.CM,
+                        hauteurUnitaire=package.height.CM,
+                        referenceColis=package.parcel.reference_number,
+                    )
+                    for package in packages
+                ],
+                natureEnvoi=None,
+                poidsTotal=packages.weight.KG,
+                volumeTotal=packages.volume.m3,
+                largerTotal=None,
+                hauteurTotal=None,
+                longueurTotal=None,
+                uniteTaxation=None,
+                animauxPlumes=None,
+                optionLivraison=next(
+                    (
+                        option.code
+                        for _, option in options.items()
+                        if option.state is True
+                    ),
+                    None,
+                ),
+                codeSaBureauRestant=None,
+                idPointRelais=None,
+                dateLivraison=options.geodis_date_livraison.state,
+                heureLivraison=options.geodis_heure_livraison.state,
+                instructionLivraison=options.geodis_instruction_livraison.state,
+                natureMarchandise=None,
+                valeurDeclaree=None,
+                contreRemboursement=None,
+                codeIncotermConditionLivraison=(
+                    provider_units.Incoterm.map(customs.incoterm).value or "P"
+                ),
+                typeTva=None,
+                sadLivToph=None,
+                sadSwap=None,
+                sadLivEtage=None,
+                sadMiseLieuUtil=None,
+                sadDepotage=None,
+                etage=None,
+                emailNotificationDestinataire=(
+                    options.email_notification_to.state or recipient.email
+                ),
+                smsNotificationDestinataire=shipper.phone_number,
+                emailNotificationExpediteur=shipper.email,
+                emailConfirmationEnlevement=None,
+                emailPriseEnChargeEnlevement=None,
+                poidsQteLimiteeMD=None,
+                dangerEnvQteLimiteeMD=None,
+                nbColisQteExcepteeMD=None,
+                dangerEnvQteExcepteeMD=None,
+                listMatieresDangereuses=[],
+                listVinsSpiritueux=None,
+                nosUmsAEtiqueter=None,
+                listDocumentsEnvoi=[],
+                informationDouane=None,
+            )
+        ],
+    )
+
+    return lib.Serializable(
+        request,
+        lib.to_dict,
+        dict(label_type=label_type.name or "PDF"),
+    )

karrio/providers/geodis/tracking.py

@@ -0,0 +1,96 @@
+import karrio.schemas.geodis.tracking_request as geodis
+import karrio.schemas.geodis.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.geodis.error as error
+import karrio.providers.geodis.utils as provider_utils
+import karrio.providers.geodis.units as provider_units
+
+
+def parse_tracking_response(
+    _responses: lib.Deserializable[typing.List[typing.Tuple[str, dict]]],
+    settings: provider_utils.Settings,
+) -> typing.Tuple[typing.List[models.TrackingDetails], typing.List[models.Message]]:
+    responses = _responses.deserialize()
+
+    messages: typing.List[models.Message] = sum(
+        [
+            error.parse_error_response(response, settings, tracking_number=_)
+            for _, response in responses
+        ],
+        start=[],
+    )
+    tracking_details = [
+        _extract_details(details, settings)
+        for _, details in responses
+        if details.get("ok") is True
+    ]
+
+    return tracking_details, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+) -> models.TrackingDetails:
+    contenu = lib.to_object(tracking.TrackingResponseType, data).contenu
+    delivered = any(contenu.libelleLivraison or "")
+    status = (
+        units.TrackingStatus.delivered.name
+        if delivered
+        else units.TrackingStatus.in_transit.name
+    )
+
+    return models.TrackingDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        tracking_number=contenu.noSuivi,
+        events=[
+            models.TrackingEvent(
+                date=lib.fdate(event.dateSuivi),
+                description=event.libelleSuivi,
+                code=event.codeSituationJustification,
+                time=lib.flocaltime(event.heureSuivi),
+                location=event.libelleCentre,
+            )
+            for event in contenu.listSuivis
+        ],
+        estimated_delivery=lib.fdate(contenu.dateLivraisonPrevue),
+        status=status,
+        delivered=delivered,
+        info=models.TrackingInfo(
+            carrier_tracking_link=contenu.urlSuiviDestinataire,
+            shipment_service=contenu.prestationCommerciale.libelle,
+            expected_delivery=lib.fdate(contenu.dateLivraisonPrevue),
+            shipment_package_count=contenu.nbColis,
+            package_weight=contenu.poids,
+            customer_name=contenu.destinataire.nom,
+            shipment_origin_country=contenu.expediteur.pays.libelle,
+            shipment_origin_postal_code=contenu.expediteur.codePostal,
+            shipment_destination_country=contenu.destinataire.pays.libelle,
+            shipment_destination_postal_code=contenu.destinataire.codePostal,
+            shipping_date=lib.fdate(contenu.dateDepart),
+        ),
+        meta=dict(
+            reference1=contenu.reference1,
+            reference2=contenu.reference2,
+            refEdides=contenu.refEdides,
+            refUniExp=contenu.refUniExp,
+            codeClient=contenu.codeClient,
+            noRecepisse=contenu.noRecepisse,
+        ),
+    )
+
+
+def tracking_request(
+    payload: models.TrackingRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+    request = [
+        geodis.TrackingRequestType(noSuivi=tracking_number)
+        for tracking_number in payload.tracking_numbers
+    ]
+
+    return lib.Serializable(request, lib.to_dict)