karrio-teleship 2025.5__py3-none-any.whl → 2025.5rc35__py3-none-any.whl

karrio/mappers/teleship/__init__.py

@@ -1,4 +1,3 @@
 from karrio.mappers.teleship.mapper import Mapper
 from karrio.mappers.teleship.proxy import Proxy
-from karrio.mappers.teleship.settings import Settings
-from karrio.mappers.teleship.hooks import Hooks
+from karrio.mappers.teleship.settings import Settings

karrio/mappers/teleship/mapper.py

@@ -51,64 +51,4 @@ class Mapper(mapper.Mapper):
         self, response: lib.Deserializable[str]
     ) -> typing.Tuple[typing.List[models.TrackingDetails], typing.List[models.Message]]:
         return provider.parse_tracking_response(response, self.settings)
-
-    def create_pickup_request(
-        self, payload: models.PickupRequest
-    ) -> lib.Serializable:
-        return provider.pickup_request(payload, self.settings)
-
-    def create_cancel_pickup_request(
-        self, payload: models.PickupCancelRequest
-    ) -> lib.Serializable:
-        return provider.cancel_pickup_request(payload, self.settings)
-
-    def parse_pickup_response(
-        self, response: lib.Deserializable[str]
-    ) -> typing.Tuple[models.PickupDetails, typing.List[models.Message]]:
-        return provider.parse_pickup_response(response, self.settings)
-
-    def parse_cancel_pickup_response(
-        self, response: lib.Deserializable[str]
-    ) -> typing.Tuple[models.ConfirmationDetails, typing.List[models.Message]]:
-        return provider.parse_cancel_pickup_response(response, self.settings)
-
-    def create_manifest_request(
-        self, payload: models.ManifestRequest
-    ) -> lib.Serializable:
-        return provider.manifest_request(payload, 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)
-
-    def create_duties_calculation_request(
-        self, payload: models.DutiesCalculationRequest
-    ) -> lib.Serializable:
-        return provider.duties_calculation_request(payload, self.settings)
-
-    def parse_duties_calculation_response(
-        self, response: lib.Deserializable[str]
-    ) -> typing.Tuple[models.DutiesCalculationDetails, typing.List[models.Message]]:
-        return provider.parse_duties_calculation_response(response, self.settings)
-
-    def create_webhook_registration_request(
-        self, payload: models.WebhookRegistrationRequest
-    ) -> lib.Serializable:
-        return provider.webhook_registration_request(payload, self.settings)
-
-    def parse_webhook_registration_response(
-        self, response: lib.Deserializable[str]
-    ) -> typing.Tuple[models.WebhookRegistrationDetails, typing.List[models.Message]]:
-        return provider.parse_webhook_registration_response(response, self.settings)
-
-    def create_webhook_deregistration_request(
-        self, payload: models.WebhookDeregistrationRequest
-    ) -> lib.Serializable:
-        return provider.webhook_deregistration_request(payload, self.settings)
-
-    def parse_webhook_deregistration_response(
-        self, response: lib.Deserializable[str]
-    ) -> typing.Tuple[models.ConfirmationDetails, typing.List[models.Message]]:
-        return provider.parse_webhook_deregistration_response(response, self.settings)
     

karrio/mappers/teleship/proxy.py

@@ -1,131 +1,77 @@
 """Karrio Teleship client proxy."""
 
-import datetime
 import karrio.lib as lib
 import karrio.api.proxy as proxy
-import karrio.core.errors as errors
-import karrio.core.models as models
-import karrio.providers.teleship.error as provider_error
 import karrio.mappers.teleship.settings as provider_settings
 
 
 class Proxy(proxy.Proxy):
     settings: provider_settings.Settings
 
-    def authenticate(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        """Retrieve access token using thread-safe token manager.
-
-        Returns the cached token if available and not expired,
-        otherwise fetches a new token from the OAuth endpoint.
-        """
-        cache_key = f"{self.settings.carrier_name}|{self.settings.client_id}|{self.settings.client_secret}"
-
-        def get_token():
-            response = lib.request(
-                url=f"{self.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",
-                        clientId=self.settings.client_id,
-                        clientSecret=self.settings.client_secret,
-                    )
-                ),
-                decoder=lib.to_dict,
-            )
-
-            messages = provider_error.parse_error_response(response, self.settings)
-
-            if any(messages):
-                raise errors.ParsedMessagesError(messages)
-
-            expiry = datetime.datetime.now() + datetime.timedelta(
-                seconds=float(response.get("expiresIn", 0))
-            )
-
-            return {**response, "expiry": lib.fdatetime(expiry)}
-
-        token = self.settings.connection_cache.thread_safe(
-            refresh_func=get_token,
-            cache_key=cache_key,
-            buffer_minutes=30,
-            token_field="accessToken",
-        )
-
-        return lib.Deserializable(token.get_state())
-
     def get_rates(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        access_token = self.authenticate(request).deserialize()
-
-        responses = lib.run_asynchronously(
-            lambda payload: lib.request(
-                url=f"{self.settings.server_url}/api/rates/quotes",
-                data=lib.to_json(payload),
-                trace=self.trace_as("json"),
-                method="POST",
-                headers={
-                    "Content-Type": "application/json",
-                    "Authorization": f"Bearer {access_token}",
-                },
-            ),
-            request.serialize(),
+        response = lib.request(
+            url=f"{self.settings.server_url}/api/rates/quotes",
+            data=lib.to_json(request.serialize()),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.settings.access_token}",
+                **({
+                    "x-account-id": self.settings.connection_config.account_id.state
+                } if self.settings.connection_config.account_id.state else {}),
+            },
         )
 
-        return lib.Deserializable(
-            responses,
-            lambda __: [lib.to_dict(_) for _ in __],
-        )
+        return lib.Deserializable(response, lib.to_dict)
 
     def create_shipment(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        access_token = self.authenticate(request).deserialize()
-
-        responses = lib.run_asynchronously(
-            lambda payload: lib.request(
-                url=f"{self.settings.server_url}/api/shipments/labels",
-                data=lib.to_json(payload),
-                trace=self.trace_as("json"),
-                method="POST",
-                headers={
-                    "Content-Type": "application/json",
-                    "Authorization": f"Bearer {access_token}",
-                },
-            ),
-            request.serialize(),
+        response = lib.request(
+            url=f"{self.settings.server_url}/api/shipments/labels",
+            data=lib.to_json(request.serialize()),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.settings.access_token}",
+                **({
+                    "x-account-id": self.settings.connection_config.account_id.state
+                } if self.settings.connection_config.account_id.state else {}),
+            },
         )
 
-        return lib.Deserializable(
-            responses,
-            lambda __: [lib.to_dict(_) for _ in __],
-        )
+        return lib.Deserializable(response, lib.to_dict)
 
-    def cancel_shipment(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        access_token = self.authenticate(request).deserialize()
+    def cancel_shipment(
+        self, request: lib.Serializable
+    ) -> lib.Deserializable[str]:
         shipment_id = request.serialize().get("shipmentId")
 
         response = lib.request(
             url=f"{self.settings.server_url}/api/shipments/labels/{shipment_id}/void",
             trace=self.trace_as("json"),
-            method="POST",
+            method="DELETE",
             headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {access_token}",
+                "Authorization": f"Bearer {self.settings.access_token}",
+                **({
+                    "x-account-id": self.settings.connection_config.account_id.state
+                } if self.settings.connection_config.account_id.state else {}),
             },
         )
 
         return lib.Deserializable(response, lib.to_dict)
 
     def get_tracking(self, request: lib.Serializable) -> lib.Deserializable:
-        access_token = self.authenticate(request).deserialize()
-
         def _get_tracking(tracking_number: str):
             return tracking_number, lib.request(
                 url=f"{self.settings.server_url}/api/tracking/{tracking_number}",
                 trace=self.trace_as("json"),
                 method="GET",
                 headers={
-                    "Content-Type": "application/json",
-                    "Authorization": f"Bearer {access_token}",
+                    "Authorization": f"Bearer {self.settings.access_token}",
+                    **({
+                        "x-account-id": self.settings.connection_config.account_id.state
+                    } if self.settings.connection_config.account_id.state else {}),
                 },
             )
 
@@ -138,102 +84,3 @@ class Proxy(proxy.Proxy):
                 (num, lib.to_dict(track)) for num, track in res if any(track.strip())
             ],
         )
-
-    def schedule_pickup(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        access_token = self.authenticate(request).deserialize()
-
-        response = lib.request(
-            url=f"{self.settings.server_url}/api/pickups",
-            data=lib.to_json(request.serialize()),
-            trace=self.trace_as("json"),
-            method="POST",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {access_token}",
-            },
-        )
-
-        return lib.Deserializable(response, lib.to_dict)
-
-    def cancel_pickup(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        access_token = self.authenticate(request).deserialize()
-        pickup_id = request.serialize().get("pickupId")
-
-        response = lib.request(
-            url=f"{self.settings.server_url}/api/pickups/{pickup_id}/cancel",
-            trace=self.trace_as("json"),
-            method="POST",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {access_token}",
-            },
-        )
-
-        return lib.Deserializable(response, lib.to_dict)
-
-    def create_manifest(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        access_token = self.authenticate(request).deserialize()
-
-        response = lib.request(
-            url=f"{self.settings.server_url}/api/manifests",
-            data=lib.to_json(request.serialize()),
-            trace=self.trace_as("json"),
-            method="POST",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {access_token}",
-            },
-        )
-
-        return lib.Deserializable(response, lib.to_dict)
-
-    def calculate_duties(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        access_token = self.authenticate(request).deserialize()
-
-        response = lib.request(
-            url=f"{self.settings.server_url}/api/trade-engine/duties-taxes",
-            data=lib.to_json(request.serialize()),
-            trace=self.trace_as("json"),
-            method="POST",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {access_token}",
-            },
-        )
-
-        return lib.Deserializable(response, lib.to_dict)
-
-    def register_webhook(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        access_token = self.authenticate(request).deserialize()
-
-        response = lib.request(
-            url=f"{self.settings.server_url}/api/webhooks",
-            data=lib.to_json(request.serialize()),
-            trace=self.trace_as("json"),
-            method="POST",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {access_token}",
-            },
-        )
-
-        return lib.Deserializable(response, lib.to_dict)
-
-    def deregister_webhook(self, request: lib.Serializable) -> lib.Deserializable[str]:
-        access_token = self.authenticate(request).deserialize()
-        webhook_id = request.serialize().get("webhookId")
-
-        response = lib.request(
-            url=f"{self.settings.server_url}/api/webhooks/{webhook_id}",
-            trace=self.trace_as("json"),
-            method="DELETE",
-            headers={
-                "Authorization": f"Bearer {access_token}",
-            },
-        )
-
-        # DELETE returns 204 No Content on success - handle empty response
-        return lib.Deserializable(
-            response,
-            lambda r: lib.to_dict(r) if r and r.strip() else {},
-        )

karrio/plugins/teleship/__init__.py

@@ -3,7 +3,6 @@ from karrio.core.metadata import PluginMetadata
 from karrio.mappers.teleship.mapper import Mapper
 from karrio.mappers.teleship.proxy import Proxy
 from karrio.mappers.teleship.settings import Settings
-from karrio.mappers.teleship.hooks import Hooks
 import karrio.providers.teleship.units as units
 import karrio.providers.teleship.utils as utils
 
@@ -19,13 +18,11 @@ METADATA = PluginMetadata(
     Mapper=Mapper,
     Proxy=Proxy,
     Settings=Settings,
-    Hooks=Hooks,
     # Data Units
     is_hub=False,
     options=units.ShippingOption,
     services=units.ShippingService,
-    connection_configs=units.ConnectionConfig,
-    system_config=units.SYSTEM_CONFIG,
+    connection_configs=utils.ConnectionConfig,
     # Extra info
     website="https://www.teleship.com",
     documentation="https://developers.teleship.com",

karrio/providers/teleship/__init__.py

@@ -13,29 +13,4 @@ from karrio.providers.teleship.shipment import (
 from karrio.providers.teleship.tracking import (
     parse_tracking_response,
     tracking_request,
-)
-from karrio.providers.teleship.pickup import (
-    pickup_request,
-    parse_pickup_response,
-    cancel_pickup_request,
-    parse_cancel_pickup_response,
-)
-from karrio.providers.teleship.manifest import (
-    manifest_request,
-    parse_manifest_response,
-)
-from karrio.providers.teleship.duties import (
-    duties_calculation_request,
-    parse_duties_calculation_response,
-)
-from karrio.providers.teleship.webhook import (
-    webhook_registration_request,
-    parse_webhook_registration_response,
-    webhook_deregistration_request,
-    parse_webhook_deregistration_response,
-)
-from karrio.providers.teleship.hooks import (
-    on_webhook_event,
-    on_oauth_authorize,
-    on_oauth_callback,
 )