karrio-server-manager 2025.5.1__py3-none-any.whl → 2025.5.3__py3-none-any.whl

karrio/server/manager/serializers/shipment.py

@@ -1,3 +1,4 @@
+import uuid
 import typing
 import rest_framework.status as status
 import django.db.transaction as transaction
@@ -129,20 +130,38 @@ class ShipmentSerializer(ShipmentData):
     def create(
         self, validated_data: dict, context: Context, **kwargs
     ) -> models.Shipment:
+        # fmt: off
+        # Apply shipping method if specified (HIGHEST PRIORITY - supersedes service)
+        apply_shipping_method_flag, validated_data = resolve_shipping_method(
+            validated_data, context
+        )
+        options = validated_data.get("options") or {}
+
         service = validated_data.get("service")
         carrier_ids = validated_data.get("carrier_ids") or []
         fetch_rates = validated_data.get("fetch_rates") is not False
         services = [service] if service is not None else validated_data.get("services")
+
+        # Check if we should skip rate fetching for has_alternative_services
+        skip_rate_fetching, resolved_carrier_name, _ = (
+            resolve_alternative_service_carrier(
+                service=service,
+                carrier_ids=carrier_ids,
+                carriers=[],  # Pre-check before loading carriers
+                options=options,
+                context=context,
+            )
+        )
+
         carriers = gateway.Carriers.list(
             context=context,
             carrier_ids=carrier_ids,
-            **({"services": services} if any(services) else {}),
+            **({"carrier_name": resolved_carrier_name} if resolved_carrier_name else {}),
+            **({"services": services} if any(services) and not skip_rate_fetching else {}),
             **{"raise_not_found": True, **DEFAULT_CARRIER_FILTER},
         )
         payment = validated_data.get("payment") or lib.to_dict(
-            datatypes.Payment(
-                currency=(validated_data.get("options") or {}).get("currency")
-            )
+            datatypes.Payment(currency=options.get("currency"))
         )
         rating_data = {
             **validated_data,
@@ -152,11 +171,11 @@ class ShipmentSerializer(ShipmentData):
         messages = validated_data.get("messages") or []
         apply_shipping_rules = lib.identity(
             getattr(conf.settings, "SHIPPING_RULES", False)
-            and (validated_data.get("options") or {}).get("apply_shipping_rules", False)
+            and options.get("apply_shipping_rules", False)
         )
 
-        # Get live rates.
-        if fetch_rates or apply_shipping_rules:
+        # Get live rates (skip if has_alternative_services is enabled)
+        if (fetch_rates or apply_shipping_rules) and not skip_rate_fetching:
             rate_response: datatypes.RateResponse = (
                 RateSerializer.map(data=rating_data, context=context)
                 .save(carriers=carriers)
@@ -165,6 +184,16 @@ class ShipmentSerializer(ShipmentData):
             rates = lib.to_dict(rate_response.rates)
             messages = lib.to_dict(rate_response.messages)
 
+        # Create synthetic rate when skipping rate fetching
+        if skip_rate_fetching:
+            _, _, rates = resolve_alternative_service_carrier(
+                service=service,
+                carrier_ids=carrier_ids,
+                carriers=carriers,
+                options=options,
+                context=context,
+            )
+
         shipment = models.Shipment.objects.create(
             **{
                 **{
@@ -220,14 +249,14 @@ class ShipmentSerializer(ShipmentData):
             context=context,
         )
 
-        # Buy label if preferred service is selected or shipping rules should applied.
-        if (service and fetch_rates) or apply_shipping_rules:
+        # Buy label if preferred service is selected, shipping method applied, shipping rules applied, or skip rate fetching
+        if (service and fetch_rates) or apply_shipping_method_flag or apply_shipping_rules or skip_rate_fetching:
             return buy_shipment_label(
                 shipment,
                 context=context,
                 service=service,
             )
-
+        # fmt: on
         return shipment
 
     @transaction.atomic
@@ -649,16 +678,23 @@ def buy_shipment_label(
         docs={**lib.to_dict(response.docs), **invoice},
     )
 
-    # Update shipment state
+    # Update shipment state - preserve original meta and merge with response meta
+    response_details = ShipmentDetails(response).data
+    merged_meta = {
+        **(shipment.meta or {}),
+        **(response_details.get("meta") or {}),
+        **({"rule_activity": kwargs.get("rule_activity")} if kwargs.get("rule_activity") else {}),
+    }
+
     purchased_shipment = lib.identity(
         ShipmentSerializer.map(
             shipment,
             context=context,
             data={
                 **payload,
-                **ShipmentDetails(response).data,
+                **response_details,
                 **extra,
-                # "meta": {**(response.meta or {}), "rule_activity": kwargs.get("rule_activity", None)},
+                "meta": merged_meta,
             },
         )
         .save()
@@ -896,3 +932,121 @@ def upload_customs_forms(shipment: models.Shipment, document: dict, context=None
         .save(shipment=shipment)
         .instance
     )
+
+
+def resolve_alternative_service_carrier(
+    service: str,
+    carrier_ids: list,
+    carriers: list,
+    options: dict,
+    context: Context,
+) -> typing.Tuple[bool, typing.Optional[str], typing.List[dict]]:
+    """
+    Resolve carrier and create synthetic rate for has_alternative_services flow.
+
+    When has_alternative_services=True and a service is specified, this function:
+    1. Determines if rate fetching should be skipped
+    2. Resolves the carrier from the service name
+    3. Creates a synthetic rate for direct label purchase
+
+    Returns:
+        Tuple of (skip_rate_fetching, resolved_carrier_name, synthetic_rates)
+    """
+    has_alternative_services = options.get("has_alternative_services", False)
+    skip_rate_fetching = service is not None and has_alternative_services
+
+    if not skip_rate_fetching:
+        return False, None, []
+
+    # Resolve carrier from service when no explicit carrier_ids provided
+    resolved_carrier_name = None
+    if not any(carrier_ids):
+        resolved_carrier_name = utils._get_carrier_for_service(service, context=context)
+        if resolved_carrier_name is None:
+            raise exceptions.APIException(
+                f"Could not resolve carrier for service '{service}'",
+                code="validation_error",
+                status_code=status.HTTP_400_BAD_REQUEST,
+            )
+
+    if len(carriers) == 0:
+        return skip_rate_fetching, resolved_carrier_name, []
+
+    # Find carrier connection matching the service's carrier
+    carrier_name = resolved_carrier_name or utils._get_carrier_for_service(
+        service, context=context
+    )
+    carrier = lib.identity(
+        next(
+            (c for c in carriers if c.carrier_name == carrier_name),
+            carriers[0] if carrier_name is None else None,
+        )
+    )
+
+    if carrier is None:
+        raise exceptions.APIException(
+            f"No carrier connection found for service '{service}'",
+            code="validation_error",
+            status_code=status.HTTP_400_BAD_REQUEST,
+        )
+
+    # Create synthetic rate for direct label purchase
+    synthetic_rates = [
+        {
+            "id": f"rat_{uuid.uuid4().hex}",
+            "carrier_id": carrier.carrier_id,
+            "carrier_name": carrier.carrier_name,
+            "service": service,
+            "currency": options.get("currency") or "USD",
+            "total_charge": 0,
+            "meta": {
+                "carrier_connection_id": carrier.pk,
+                "has_alternative_services": True,
+                "rate_provider": carrier.carrier_name,
+                "service_name": service.upper().replace("_", " "),
+            },
+            "test_mode": context.test_mode,
+        }
+    ]
+
+    return skip_rate_fetching, resolved_carrier_name, synthetic_rates
+
+
+def resolve_shipping_method(
+    validated_data: dict,
+    context: Context,
+) -> typing.Tuple[bool, dict]:
+    """
+    Resolve and apply shipping method configuration if specified.
+
+    When options.shipping_method is provided, this function:
+    1. Validates the SHIPPING_METHODS feature is enabled
+    2. Loads and applies the shipping method configuration
+
+    Returns:
+        Tuple of (apply_shipping_method_flag, modified_validated_data)
+    """
+    if not getattr(conf.settings, "SHIPPING_METHODS", False):
+        options = validated_data.get("options") or {}
+        shipping_method_id = options.get("shipping_method")
+
+        if shipping_method_id is not None:
+            raise exceptions.APIException(
+                "Shipping methods feature is not enabled.",
+                code="feature_disabled",
+                status_code=status.HTTP_400_BAD_REQUEST,
+            )
+
+        return False, validated_data
+
+    options = validated_data.get("options") or {}
+    shipping_method_id = options.get("shipping_method")
+
+    if shipping_method_id is None:
+        return False, validated_data
+
+    modified_data = utils.load_and_apply_shipping_method(
+        validated_data, shipping_method_id, context
+    )
+
+    return True, modified_data

karrio/server/manager/tests/test_errors.py

@@ -16,7 +16,7 @@ class TestNotFoundErrors(APITestCase):
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
         self.assertDictEqual(
             response_data,
-            {"errors": [{"code": "not_found", "message": "Address not found"}]},
+            {"errors": [{"code": "not_found", "message": "Address not found", "level": "warning"}]},
         )
 
     def test_parcel_not_found_returns_resource_name(self):
@@ -30,7 +30,7 @@ class TestNotFoundErrors(APITestCase):
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
         self.assertDictEqual(
             response_data,
-            {"errors": [{"code": "not_found", "message": "Parcel not found"}]},
+            {"errors": [{"code": "not_found", "message": "Parcel not found", "level": "warning"}]},
         )
 
     def test_shipment_not_found_returns_resource_name(self):
@@ -44,7 +44,7 @@ class TestNotFoundErrors(APITestCase):
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
         self.assertDictEqual(
             response_data,
-            {"errors": [{"code": "not_found", "message": "Shipment not found"}]},
+            {"errors": [{"code": "not_found", "message": "Shipment not found", "level": "warning"}]},
         )
 
     def test_customs_not_found_returns_resource_name(self):
@@ -58,7 +58,7 @@ class TestNotFoundErrors(APITestCase):
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
         self.assertDictEqual(
             response_data,
-            {"errors": [{"code": "not_found", "message": "Customs not found"}]},
+            {"errors": [{"code": "not_found", "message": "Customs not found", "level": "warning"}]},
         )
 
 
@@ -76,6 +76,9 @@ class TestValidationErrors(APITestCase):
         self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
         self.assertIn("errors", response_data)
         self.assertTrue(len(response_data["errors"]) > 0)
+        # Validation errors should have level="error"
+        for error in response_data["errors"]:
+            self.assertEqual(error.get("level"), "error")
 
     def test_address_validation_error_format(self):
         url = reverse("karrio.server.manager:address-list")
@@ -86,3 +89,6 @@ class TestValidationErrors(APITestCase):
         self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
         self.assertIn("errors", response_data)
         self.assertTrue(len(response_data["errors"]) > 0)
+        # Validation errors should have level="error"
+        for error in response_data["errors"]:
+            self.assertEqual(error.get("level"), "error")

karrio/server/manager/tests/test_manifests.py

@@ -0,0 +1,83 @@
+import json
+from unittest.mock import patch, ANY
+from django.urls import reverse
+from rest_framework import status
+from karrio.core.models import ManifestDetails as ManifestDetailsModel
+from karrio.server.manager.tests.test_shipments import (
+    TestShipmentFixture,
+    RETURNED_RATES_VALUE,
+    CREATED_SHIPMENT_RESPONSE,
+    SINGLE_CALL_LABEL_DATA,
+)
+
+
+class TestManifestDocumentDownload(TestShipmentFixture):
+    """Test manifest document download POST API."""
+
+    def create_manifest(self):
+        """Create a manifest via API with a purchased shipment."""
+        # First create and purchase a shipment
+        shipment_url = reverse("karrio.server.manager:shipment-list")
+
+        with patch("karrio.server.core.gateway.utils.identity") as mock:
+            mock.side_effect = [RETURNED_RATES_VALUE, CREATED_SHIPMENT_RESPONSE]
+            response = self.client.post(shipment_url, SINGLE_CALL_LABEL_DATA)
+            shipment = json.loads(response.content)
+
+        # Create manifest via API
+        manifest_url = reverse("karrio.server.manager:manifest-list")
+        manifest_data = {
+            "carrier_name": "canadapost",
+            "shipment_ids": [shipment["id"]],
+            "address": {
+                "address_line1": "125 Church St",
+                "city": "Moncton",
+                "country_code": "CA",
+                "postal_code": "E1C4Z8",
+                "state_code": "NB",
+            },
+        }
+
+        with patch("karrio.server.core.gateway.utils.identity") as mock:
+            mock.return_value = MANIFEST_RESPONSE
+            response = self.client.post(manifest_url, manifest_data)
+            return json.loads(response.content)
+
+    def test_download_manifest_document(self):
+        manifest = self.create_manifest()
+
+        url = reverse(
+            "karrio.server.manager:manifest-document-download",
+            kwargs=dict(pk=manifest["id"]),
+        )
+        response = self.client.post(url)
+        response_data = json.loads(response.content)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertDictEqual(response_data, MANIFEST_DOCUMENT_RESPONSE)
+
+    def test_download_manifest_not_found(self):
+        url = reverse(
+            "karrio.server.manager:manifest-document-download",
+            kwargs=dict(pk="manf_non_existent_id"),
+        )
+        response = self.client.post(url)
+
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+
+MANIFEST_RESPONSE = (
+    ManifestDetailsModel(
+        carrier_id="canadapost",
+        carrier_name="canadapost",
+        doc=dict(manifest="JVBERi0xLjQK"),
+    ),
+    [],
+)
+
+MANIFEST_DOCUMENT_RESPONSE = {
+    "category": "manifest",
+    "format": "PDF",
+    "base64": "JVBERi0xLjQK",
+    "url": ANY,
+}

karrio/server/manager/tests/test_shipments.py

@@ -212,6 +212,144 @@ class TestShipmentPurchase(TestShipmentFixture):
             ).exists()
         )
 
+    def test_purchase_shipment_with_has_alternative_services(self):
+        """
+        Test that when has_alternative_services is enabled and service is requested
+        but not in rates, the purchase proceeds by delegating service resolution to the carrier.
+        """
+        url = reverse(
+            "karrio.server.manager:shipment-purchase",
+            kwargs=dict(pk=self.shipment.pk),
+        )
+        self.shipment.options = {"has_alternative_services": True}
+        self.shipment.save()
+        data = {"service": "canadapost_expedited_parcel"}
+
+        with patch("karrio.server.core.gateway.utils.identity") as mock:
+            mock.return_value = CREATED_SHIPMENT_RESPONSE
+            response = self.client.post(url, data)
+            response_data = json.loads(response.content)
+
+        self.assertResponseNoErrors(response)  # type: ignore
+        self.assertDictEqual(
+            dict(status=response_data["status"], service=response_data["service"]),
+            dict(status="purchased", service="canadapost_expedited_parcel"),
+        )
+
+
+class TestSingleCallLabelPurchase(APITestCase):
+    """Test single call label purchase via POST to shipment-list with a service specified."""
+
+    def test_single_call_label_purchase(self):
+        """
+        Test that when a shipment is created with a service specified,
+        the label is purchased in a single call after fetching rates.
+        """
+        url = reverse("karrio.server.manager:shipment-list")
+        data = SINGLE_CALL_LABEL_DATA
+
+        with patch("karrio.server.core.gateway.utils.identity") as mock:
+            mock.side_effect = [RETURNED_RATES_VALUE, CREATED_SHIPMENT_RESPONSE]
+            response = self.client.post(url, data)
+            response_data = json.loads(response.content)
+
+        self.assertResponseNoErrors(response)  # type: ignore
+        self.assertDictEqual(
+            {
+                "status": response_data["status"],
+                "carrier_name": response_data["carrier_name"],
+                "service": response_data["service"],
+                "tracking_number": response_data["tracking_number"],
+                "services": response_data["services"],
+                "rates_count": len(response_data["rates"]),
+            },
+            {
+                "status": "purchased",
+                "carrier_name": "canadapost",
+                "service": "canadapost_priority",
+                "tracking_number": "123456789012",
+                "services": ["canadapost_priority"],
+                "rates_count": 1,
+            },
+        )
+
+
+class TestSingleCallWithAlternativeServices(APITestCase):
+    """Test single call label purchase with has_alternative_services flag (skip rate fetching)."""
+
+    def test_single_call_label_purchase_skip_rates(self):
+        """
+        Test that when has_alternative_services=True and service is specified,
+        rate fetching is skipped and label is purchased directly.
+        Carrier is resolved from the service name.
+        """
+        url = reverse("karrio.server.manager:shipment-list")
+        data = SINGLE_CALL_SKIP_RATES_DATA
+
+        with patch("karrio.server.core.gateway.utils.identity") as mock:
+            mock.return_value = CREATED_SHIPMENT_RESPONSE
+            response = self.client.post(url, data)
+            response_data = json.loads(response.content)
+
+            # Verify only 1 call was made (rates were skipped)
+            self.assertEqual(mock.call_count, 1)
+
+        self.assertResponseNoErrors(response)  # type: ignore
+        self.assertDictEqual(
+            {
+                "status": response_data["status"],
+                "carrier_name": response_data["carrier_name"],
+                "service": response_data["service"],
+                "tracking_number": response_data["tracking_number"],
+                "has_alternative_services": response_data["selected_rate"]["meta"].get(
+                    "has_alternative_services"
+                ),
+            },
+            {
+                "status": "purchased",
+                "carrier_name": "canadapost",
+                "service": "canadapost_priority",
+                "tracking_number": "123456789012",
+                "has_alternative_services": True,
+            },
+        )
+
+    def test_single_call_label_purchase_skip_rates_with_carrier_ids(self):
+        """
+        Test that when has_alternative_services=True, service, and carrier_ids are specified,
+        rate fetching is skipped and label is purchased directly.
+        """
+        url = reverse("karrio.server.manager:shipment-list")
+        data = {**SINGLE_CALL_SKIP_RATES_DATA, "carrier_ids": ["canadapost"]}
+
+        with patch("karrio.server.core.gateway.utils.identity") as mock:
+            mock.return_value = CREATED_SHIPMENT_RESPONSE
+            response = self.client.post(url, data)
+            response_data = json.loads(response.content)
+
+            # Verify only 1 call was made (rates were skipped)
+            self.assertEqual(mock.call_count, 1)
+
+        self.assertResponseNoErrors(response)  # type: ignore
+        self.assertDictEqual(
+            {
+                "status": response_data["status"],
+                "carrier_name": response_data["carrier_name"],
+                "service": response_data["service"],
+                "tracking_number": response_data["tracking_number"],
+                "has_alternative_services": response_data["selected_rate"]["meta"].get(
+                    "has_alternative_services"
+                ),
+            },
+            {
+                "status": "purchased",
+                "carrier_name": "canadapost",
+                "service": "canadapost_priority",
+                "tracking_number": "123456789012",
+                "has_alternative_services": True,
+            },
+        )
+
 
 SHIPMENT_DATA = {
     "recipient": {
@@ -260,11 +398,21 @@ SHIPMENT_RATES = {
             "total_charge": 106.71,
             "transit_days": 2,
             "extra_charges": [
-                {"name": "Duty and taxes", "amount": 13.92, "currency": "CAD", "id": ANY},
+                {
+                    "name": "Duty and taxes",
+                    "amount": 13.92,
+                    "currency": "CAD",
+                    "id": ANY,
+                },
                 {"name": "Fuel surcharge", "amount": 2.7, "currency": "CAD", "id": ANY},
                 {"name": "SMB Savings", "amount": -11.74, "currency": "CAD", "id": ANY},
                 {"name": "Discount", "amount": -9.04, "currency": "CAD", "id": ANY},
-                {"name": "Base surcharge", "amount": 101.83, "currency": "CAD", "id": ANY},
+                {
+                    "name": "Base surcharge",
+                    "amount": 101.83,
+                    "currency": "CAD",
+                    "id": ANY,
+                },
             ],
             "meta": {
                 "ext": "canadapost",
@@ -535,7 +683,12 @@ PURCHASED_SHIPMENT = {
                 {"name": "Fuel surcharge", "amount": 2.7, "currency": "CAD", "id": ANY},
                 {"name": "SMB Savings", "amount": -11.74, "currency": "CAD", "id": ANY},
                 {"name": "Discount", "amount": -9.04, "currency": "CAD", "id": ANY},
-                {"name": "Duties and taxes", "amount": 13.92, "currency": "CAD", "id": ANY},
+                {
+                    "name": "Duties and taxes",
+                    "amount": 13.92,
+                    "currency": "CAD",
+                    "id": ANY,
+                },
             ],
             "meta": {
                 "service_name": "CANADAPOST PRIORITY",
@@ -679,11 +832,31 @@ CANCEL_RESPONSE = {
             "total_charge": 106.71,
             "transit_days": 2,
             "extra_charges": [
-                {"name": "Base charge", "amount": 101.83, "currency": "CAD", "id": None},
-                {"name": "Fuel surcharge", "amount": 2.7, "currency": "CAD", "id": None},
-                {"name": "SMB Savings", "amount": -11.74, "currency": "CAD", "id": None},
+                {
+                    "name": "Base charge",
+                    "amount": 101.83,
+                    "currency": "CAD",
+                    "id": None,
+                },
+                {
+                    "name": "Fuel surcharge",
+                    "amount": 2.7,
+                    "currency": "CAD",
+                    "id": None,
+                },
+                {
+                    "name": "SMB Savings",
+                    "amount": -11.74,
+                    "currency": "CAD",
+                    "id": None,
+                },
                 {"name": "Discount", "amount": -9.04, "currency": "CAD", "id": None},
-                {"name": "Duties and taxes", "amount": 13.92, "currency": "CAD", "id": None},
+                {
+                    "name": "Duties and taxes",
+                    "amount": 13.92,
+                    "currency": "CAD",
+                    "id": None,
+                },
             ],
             "meta": {
                 "carrier_connection_id": ANY,
@@ -797,11 +970,31 @@ CANCEL_PURCHASED_RESPONSE = {
             "total_charge": 106.71,
             "transit_days": 2,
             "extra_charges": [
-                {"name": "Base charge", "amount": 101.83, "currency": "CAD", "id": None},
-                {"name": "Fuel surcharge", "amount": 2.7, "currency": "CAD", "id": None},
-                {"name": "SMB Savings", "amount": -11.74, "currency": "CAD", "id": None},
+                {
+                    "name": "Base charge",
+                    "amount": 101.83,
+                    "currency": "CAD",
+                    "id": None,
+                },
+                {
+                    "name": "Fuel surcharge",
+                    "amount": 2.7,
+                    "currency": "CAD",
+                    "id": None,
+                },
+                {
+                    "name": "SMB Savings",
+                    "amount": -11.74,
+                    "currency": "CAD",
+                    "id": None,
+                },
                 {"name": "Discount", "amount": -9.04, "currency": "CAD", "id": None},
-                {"name": "Duties and taxes", "amount": 13.92, "currency": "CAD", "id": None},
+                {
+                    "name": "Duties and taxes",
+                    "amount": 13.92,
+                    "currency": "CAD",
+                    "id": None,
+                },
             ],
             "meta": {
                 "carrier_connection_id": ANY,
@@ -832,194 +1025,175 @@ CANCEL_PURCHASED_RESPONSE = {
     "invoice_url": None,
 }
 
-
-class TestShipmentPurchaseWithAlternativeServices(TestShipmentFixture):
-    def setUp(self) -> None:
-        super().setUp()
-        carrier = providers.Carrier.objects.get(carrier_id="canadapost")
-        # Rates have "canadapost_regular_parcel" but we'll request "canadapost_priority"
-        self.shipment.rates = [
-            {
-                "id": "rat_alt_service_test",
-                "carrier_id": "canadapost",
-                "carrier_name": "canadapost",
-                "currency": "CAD",
-                "estimated_delivery": None,
-                "extra_charges": [
-                    {"amount": 50.00, "currency": "CAD", "name": "Base charge"},
-                ],
-                "service": "canadapost_regular_parcel",
-                "total_charge": 50.00,
-                "transit_days": 5,
-                "test_mode": True,
-                "meta": {
-                    "rate_provider": "canadapost",
-                    "service_name": "CANADAPOST REGULAR PARCEL",
-                    "carrier_connection_id": carrier.pk,
-                },
-            }
-        ]
-        self.shipment.options = {"has_alternative_services": True}
-        self.shipment.save()
-
-    def test_purchase_with_alternative_service(self):
-        """
-        Test that when canadapost_priority is requested but only canadapost_regular_parcel
-        is in rates, the purchase proceeds with has_alternative_services=True,
-        delegating service resolution to the carrier.
-        """
-        url = reverse(
-            "karrio.server.manager:shipment-purchase",
-            kwargs=dict(pk=self.shipment.pk),
-        )
-        data = {"service": "canadapost_priority"}
-
-        with patch("karrio.server.core.gateway.utils.identity") as mock:
-            mock.return_value = CREATED_SHIPMENT_RESPONSE
-            response = self.client.post(url, data)
-            response_data = json.loads(response.content)
-
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertDictEqual(response_data, ALTERNATIVE_SERVICE_PURCHASED_SHIPMENT)
-
-
-ALTERNATIVE_SERVICE_PURCHASED_SHIPMENT = {
-    "id": ANY,
-    "object_type": "shipment",
-    "tracking_url": "/v1/trackers/canadapost/123456789012",
-    "shipper": {
-        "id": ANY,
-        "postal_code": "E1C4Z8",
-        "city": "Moncton",
-        "federal_tax_id": None,
-        "state_tax_id": None,
+SINGLE_CALL_LABEL_DATA = {
+    "recipient": {
+        "address_line1": "125 Church St",
         "person_name": "John Poop",
         "company_name": "A corp.",
-        "country_code": "CA",
-        "email": None,
         "phone_number": "514 000 0000",
-        "state_code": "NB",
-        "street_number": None,
+        "city": "Moncton",
+        "country_code": "CA",
+        "postal_code": "E1C4Z8",
         "residential": False,
-        "address_line1": "125 Church St",
-        "address_line2": None,
-        "validate_location": False,
-        "object_type": "address",
-        "validation": None,
+        "state_code": "NB",
     },
-    "recipient": {
-        "id": ANY,
-        "postal_code": "V6M2V9",
-        "city": "Vancouver",
-        "federal_tax_id": None,
-        "state_tax_id": None,
+    "shipper": {
+        "address_line1": "5840 Oak St",
         "person_name": "Jane Doe",
         "company_name": "B corp.",
-        "country_code": "CA",
-        "email": None,
         "phone_number": "514 000 9999",
-        "state_code": "BC",
-        "street_number": None,
+        "city": "Vancouver",
+        "country_code": "CA",
+        "postal_code": "V6M2V9",
         "residential": False,
-        "address_line1": "5840 Oak St",
-        "address_line2": None,
-        "validate_location": False,
-        "object_type": "address",
-        "validation": None,
+        "state_code": "BC",
     },
     "parcels": [
         {
-            "id": ANY,
-            "weight": 1.0,
-            "width": None,
-            "height": None,
-            "length": None,
-            "packaging_type": None,
-            "package_preset": "canadapost_corrugated_small_box",
-            "description": None,
-            "content": None,
-            "is_document": False,
+            "weight": 1,
             "weight_unit": "KG",
-            "dimension_unit": None,
-            "items": [],
-            "freight_class": None,
-            "reference_number": ANY,
-            "object_type": "parcel",
-            "options": {},
+            "package_preset": "canadapost_corrugated_small_box",
         }
     ],
-    "services": [],
-    "options": {"has_alternative_services": True, "shipping_date": ANY, "shipment_date": ANY},
-    "payment": {"paid_by": "sender", "currency": "CAD", "account_number": None},
-    "return_address": None,
-    "billing_address": None,
-    "customs": None,
-    "rates": [
+    "payment": {"currency": "CAD", "paid_by": "sender"},
+    "service": "canadapost_priority",
+    "carrier_ids": ["canadapost"],
+    "options": {"insurance": 100},
+}
+
+SINGLE_CALL_SKIP_RATES_DATA = {
+    # Note: No carrier_ids provided - carrier is resolved from service name
+    "recipient": {
+        "address_line1": "125 Church St",
+        "person_name": "John Poop",
+        "company_name": "A corp.",
+        "phone_number": "514 000 0000",
+        "city": "Moncton",
+        "country_code": "CA",
+        "postal_code": "E1C4Z8",
+        "residential": False,
+        "state_code": "NB",
+    },
+    "shipper": {
+        "address_line1": "5840 Oak St",
+        "person_name": "Jane Doe",
+        "company_name": "B corp.",
+        "phone_number": "514 000 9999",
+        "city": "Vancouver",
+        "country_code": "CA",
+        "postal_code": "V6M2V9",
+        "residential": False,
+        "state_code": "BC",
+    },
+    "parcels": [
         {
-            "id": ANY,
-            "object_type": "rate",
-            "carrier_name": "canadapost",
-            "carrier_id": "canadapost",
-            "currency": "CAD",
-            "estimated_delivery": ANY,
-            "service": "canadapost_regular_parcel",
-            "total_charge": 50.00,
-            "transit_days": 5,
-            "extra_charges": [
-                {"name": "Base charge", "amount": 50.00, "currency": "CAD", "id": None},
-            ],
-            "meta": {
-                "service_name": "CANADAPOST REGULAR PARCEL",
-                "rate_provider": "canadapost",
-                "carrier_connection_id": ANY,
-            },
-            "test_mode": True,
+            "weight": 1,
+            "weight_unit": "KG",
+            "package_preset": "canadapost_corrugated_small_box",
         }
     ],
-    "reference": None,
-    "label_type": "PDF",
-    "carrier_ids": [],
-    "tracker_id": ANY,
-    "created_at": ANY,
-    "metadata": {},
-    "messages": [],
-    "status": "purchased",
-    "carrier_name": "canadapost",
-    "carrier_id": "canadapost",
-    "tracking_number": "123456789012",
-    "shipment_identifier": "123456789012",
-    "selected_rate": {
-        "id": ANY,
-        "object_type": "rate",
-        "carrier_name": "canadapost",
-        "carrier_id": "canadapost",
-        "currency": "CAD",
-        "estimated_delivery": ANY,
-        "service": "canadapost_priority",
-        "total_charge": 50.00,
-        "transit_days": 5,
-        "extra_charges": [
-            {"name": "Base charge", "amount": 50.00, "currency": "CAD", "id": None},
-        ],
-        "meta": {
-            "ext": "canadapost",
-            "carrier": "canadapost",
-            "service_name": "CANADAPOST REGULAR PARCEL",
-            "rate_provider": "canadapost",
-            "carrier_connection_id": ANY,
-            "has_alternative_services": True,
-        },
-        "test_mode": True,
-    },
-    "meta": {
-        "ext": "canadapost",
-        "carrier": "canadapost",
-        "rate_provider": "canadapost",
-        "service_name": "CANADAPOST PRIORITY",
-    },
+    "payment": {"currency": "CAD", "paid_by": "sender"},
     "service": "canadapost_priority",
-    "selected_rate_id": ANY,
-    "test_mode": True,
-    "label_url": ANY,
-    "invoice_url": None,
+    "options": {"has_alternative_services": True},
+}
+
+
+class TestShipmentDocumentDownload(APITestCase):
+    """Test shipment document download POST API."""
+
+    def create_purchased_shipment(self):
+        """Create and purchase a shipment via API."""
+        url = reverse("karrio.server.manager:shipment-list")
+
+        with patch("karrio.server.core.gateway.utils.identity") as mock:
+            mock.side_effect = [RETURNED_RATES_VALUE, CREATED_SHIPMENT_RESPONSE]
+            response = self.client.post(url, SINGLE_CALL_LABEL_DATA)
+            return json.loads(response.content)
+
+    def test_download_label_document(self):
+        shipment = self.create_purchased_shipment()
+
+        url = reverse(
+            "karrio.server.manager:shipment-document-download",
+            kwargs=dict(pk=shipment["id"], doc="label"),
+        )
+        response = self.client.post(url)
+        response_data = json.loads(response.content)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertDictEqual(
+            response_data,
+            LABEL_DOCUMENT_RESPONSE,
+        )
+
+    def test_download_document_not_found(self):
+        # Create a draft shipment (no label)
+        url = reverse("karrio.server.manager:shipment-list")
+
+        with patch("karrio.server.core.gateway.utils.identity") as mock:
+            mock.return_value = RETURNED_RATES_VALUE
+            response = self.client.post(url, SHIPMENT_DATA)
+            shipment = json.loads(response.content)
+
+        url = reverse(
+            "karrio.server.manager:shipment-document-download",
+            kwargs=dict(pk=shipment["id"], doc="label"),
+        )
+        response = self.client.post(url)
+
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+    def test_download_invalid_document_type(self):
+        shipment = self.create_purchased_shipment()
+
+        url = reverse(
+            "karrio.server.manager:shipment-document-download",
+            kwargs=dict(pk=shipment["id"], doc="invalid"),
+        )
+        response = self.client.post(url)
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_download_shipment_not_found(self):
+        url = reverse(
+            "karrio.server.manager:shipment-document-download",
+            kwargs=dict(pk="shp_non_existent_id", doc="label"),
+        )
+        response = self.client.post(url)
+
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+
+class TestShipmentCancelIdempotent(APITestCase):
+    """Test shipment cancel idempotency."""
+
+    def test_cancel_already_cancelled_shipment_returns_202(self):
+        # Create a shipment via API
+        url = reverse("karrio.server.manager:shipment-list")
+
+        with patch("karrio.server.core.gateway.utils.identity") as mock:
+            mock.return_value = RETURNED_RATES_VALUE
+            response = self.client.post(url, SHIPMENT_DATA)
+            shipment = json.loads(response.content)
+
+        # Cancel the shipment first time
+        cancel_url = reverse(
+            "karrio.server.manager:shipment-cancel",
+            kwargs=dict(pk=shipment["id"]),
+        )
+        self.client.post(cancel_url)
+
+        # Cancel again - should return 202
+        response = self.client.post(cancel_url)
+        response_data = json.loads(response.content)
+
+        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
+        self.assertEqual(response_data["status"], "cancelled")
+
+
+LABEL_DOCUMENT_RESPONSE = {
+    "category": "label",
+    "format": "PDF",
+    "base64": "==apodifjoefr",
+    "url": ANY,
 }

karrio/server/manager/views/manifests.py

@@ -17,6 +17,7 @@ import karrio.server.core.filters as filters
 import karrio.server.manager.models as models
 import karrio.server.manager.router as router
 import karrio.server.manager.serializers as serializers
+from karrio.server.core.serializers import ShippingDocument
 
 ENDPOINT_ID = "$$$$&&"  # This endpoint id is used to make operation ids unique make sure not to duplicate
 Manifests = serializers.PaginatedResult("ManifestList", serializers.Manifest)
@@ -115,7 +116,14 @@ class ManifestDoc(django_downloadview.VirtualDownloadView):
 
         query_params = req.GET.dict()
 
-        self.manifest = models.Manifest.objects.get(pk=pk, manifest__isnull=False)
+        self.manifest = models.Manifest.objects.filter(pk=pk, manifest__isnull=False).first()
+
+        if self.manifest is None:
+            return response.Response(
+                {"errors": [{"message": f"Manifest '{pk}' not found or has no document"}]},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
         self.document = getattr(self.manifest, doc, None)
         self.name = f"{doc}_{self.manifest.id}.{format}"
 
@@ -134,6 +142,47 @@ class ManifestDoc(django_downloadview.VirtualDownloadView):
         return base.ContentFile(buffer.getvalue(), name=self.name)
 
 
+class ManifestDocumentDownload(api.APIView):
+
+    @openapi.extend_schema(
+        tags=["Manifests"],
+        operation_id=f"{ENDPOINT_ID}document",
+        extensions={"x-operationId": "retrieveManifestDocument"},
+        summary="Retrieve a manifest document",
+        request=None,
+        responses={
+            200: ShippingDocument(),
+            404: serializers.ErrorResponse(),
+            500: serializers.ErrorResponse(),
+        },
+    )
+    def post(self, req: request.Request, pk: str):
+        """
+        Retrieve a manifest document as base64 encoded content.
+        """
+        manifest = models.Manifest.access_by(req).filter(pk=pk, manifest__isnull=False).first()
+
+        if manifest is None:
+            return response.Response(
+                {"errors": [{"message": f"Manifest '{pk}' not found or has no document"}]},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Build the GET URL for the document
+        doc_url = f"/v1/manifests/{pk}/manifest.pdf"
+
+        return response.Response(
+            ShippingDocument(
+                {
+                    "category": "manifest",
+                    "format": "PDF",
+                    "base64": manifest.manifest,
+                    "url": doc_url,
+                }
+            ).data
+        )
+
+
 router.router.urls.append(
     urls.path(
         "manifests",
@@ -148,9 +197,16 @@ router.router.urls.append(
         name="manifest-details",
     )
 )
+router.router.urls.append(
+    urls.path(
+        "manifests/<str:pk>/document",
+        ManifestDocumentDownload.as_view(),
+        name="manifest-document-download",
+    )
+)
 router.router.urls.append(
     urls.re_path(
-        r"^manifests/(?P<pk>\w+)/(?P<doc>[a-z0-9]+).(?P<format>[a-z0-9]+)",
+        r"^manifests/(?P<pk>\w+)/(?P<doc>[a-z0-9]+)\.(?P<format>[a-z0-9]+)",
         ManifestDoc.as_view(),
         name="manifest-docs",
     )

karrio/server/manager/views/shipments.py

@@ -25,6 +25,7 @@ from karrio.server.manager.serializers import (
     ErrorMessages,
     Shipment,
     ShipmentData,
+    ShipmentStatus,
     buy_shipment_label,
     can_mutate_shipment,
     ShipmentSerializer,
@@ -32,6 +33,7 @@ from karrio.server.manager.serializers import (
     ShipmentUpdateData,
     ShipmentPurchaseData,
     ShipmentCancelSerializer,
+    ShippingDocument,
 )
 
 ENDPOINT_ID = "$$$$$"  # This endpoint id is used to make operation ids unique make sure not to duplicate
@@ -165,6 +167,7 @@ class ShipmentCancel(APIView):
         request=None,
         responses={
             200: Shipment(),
+            202: Shipment(),
             404: ErrorResponse(),
             400: ErrorResponse(),
             409: ErrorResponse(),
@@ -177,6 +180,11 @@ class ShipmentCancel(APIView):
         Void a shipment with the associated label.
         """
         shipment = models.Shipment.access_by(request).get(pk=pk)
+
+        # Return 202 if already cancelled (idempotent)
+        if shipment.status == ShipmentStatus.cancelled.value:
+            return Response(Shipment(shipment).data, status=status.HTTP_202_ACCEPTED)
+
         can_mutate_shipment(shipment, delete=True)
 
         update = ShipmentCancelSerializer.map(shipment, context=request).save().instance
@@ -275,7 +283,14 @@ class ShipmentDocs(VirtualDownloadView):
 
         query_params = request.GET.dict()
 
-        self.shipment = models.Shipment.objects.get(pk=pk, label__isnull=False)
+        self.shipment = models.Shipment.objects.filter(pk=pk, label__isnull=False).first()
+
+        if self.shipment is None:
+            return Response(
+                {"errors": [{"message": f"Shipment '{pk}' not found or has no label"}]},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
         self.document = getattr(self.shipment, doc, None)
         self.name = f"{doc}_{self.shipment.tracking_number}.{format}"
 
@@ -314,6 +329,64 @@ class ShipmentDocs(VirtualDownloadView):
         return ContentFile(buffer.getvalue(), name=self.name)
 
 
+class ShipmentDocumentDownload(APIView):
+    throttle_scope = "carrier_request"
+
+    @openapi.extend_schema(
+        tags=["Shipments"],
+        operation_id=f"{ENDPOINT_ID}document",
+        extensions={"x-operationId": "retrieveShipmentDocument"},
+        summary="Retrieve a shipment document",
+        request=None,
+        responses={
+            200: ShippingDocument(),
+            404: ErrorResponse(),
+            500: ErrorResponse(),
+        },
+    )
+    def post(self, request: Request, pk: str, doc: str = "label"):
+        """
+        Retrieve a shipment document (label or invoice) as base64 encoded content.
+        """
+        if doc not in ["label", "invoice"]:
+            return Response(
+                {"errors": [{"message": f"Invalid document type: {doc}"}]},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Build filter based on document type
+        filter_kwargs = {"pk": pk, f"{doc}__isnull": False}
+        shipment = models.Shipment.access_by(request).filter(**filter_kwargs).first()
+
+        if shipment is None:
+            return Response(
+                {"errors": [{"message": f"Shipment '{pk}' not found or has no {doc}"}]},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        document = getattr(shipment, doc)
+
+        # Determine format based on label_type for label, always PDF for invoice
+        if doc == "label":
+            doc_format = shipment.label_type or "PDF"
+        else:
+            doc_format = "PDF"
+
+        # Build the GET URL for the document
+        doc_url = f"/v1/shipments/{pk}/{doc}.{doc_format.lower()}"
+
+        return Response(
+            ShippingDocument(
+                {
+                    "category": doc,
+                    "format": doc_format,
+                    "base64": document,
+                    "url": doc_url,
+                }
+            ).data
+        )
+
+
 router.urls.append(path("shipments", ShipmentList.as_view(), name="shipment-list"))
 router.urls.append(
     path("shipments/<str:pk>", ShipmentDetails.as_view(), name="shipment-details")
@@ -331,9 +404,16 @@ router.urls.append(
         name="shipment-purchase",
     )
 )
+router.urls.append(
+    path(
+        "shipments/<str:pk>/documents/<str:doc>",
+        ShipmentDocumentDownload.as_view(),
+        name="shipment-document-download",
+    )
+)
 router.urls.append(
     re_path(
-        r"^shipments/(?P<pk>\w+)/(?P<doc>[a-z0-9]+).(?P<format>[a-z0-9]+)",
+        r"^shipments/(?P<pk>\w+)/(?P<doc>[a-z0-9]+)\.(?P<format>[a-z0-9]+)",
         ShipmentDocs.as_view(),
         name="shipment-docs",
     )

{karrio_server_manager-2025.5.1.dist-info → karrio_server_manager-2025.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karrio_server_manager
-Version: 2025.5.1
+Version: 2025.5.3
 Summary: Multi-carrier shipping API Shipments manager module
 Author-email: karrio <hello@karrio.io>
 License-Expression: LGPL-3.0

{karrio_server_manager-2025.5.1.dist-info → karrio_server_manager-2025.5.3.dist-info}/RECORD

@@ -82,26 +82,27 @@ karrio/server/manager/serializers/manifest.py,sha256=mSneCk_7HMXpi64_7hggWvkR7Ma
 karrio/server/manager/serializers/parcel.py,sha256=733Bg26lVbEkoWtAVM5Qt2IRBS2QDuVxhG40Hiqh3bw,2621
 karrio/server/manager/serializers/pickup.py,sha256=sX0VmcQxGkXn3IEosMuFwdXh4HhdkPcuBOp79O8PoDQ,9233
 karrio/server/manager/serializers/rate.py,sha256=7vYK_v8iWEDnswqYHG2Lir16_UhHTOxW5rdC6lw3lzA,652
-karrio/server/manager/serializers/shipment.py,sha256=gkDFTDaKXA8Iz3yjS6fxRi46AzZPw40RhJEOlnBZy6o,31143
+karrio/server/manager/serializers/shipment.py,sha256=8joRuh_F6V6NwFXWekdhsn0eCSvubAAjUbgwbujns6Y,36674
 karrio/server/manager/serializers/tracking.py,sha256=ixrAjIiZQsvSt4y0qtisGkt6TFOJ3ORNkJAQVt6YQrA,12483
 karrio/server/manager/tests/__init__.py,sha256=Y1UNteEE60vWdUAkjbldu_r_-h4u0He8-UoiBgTjKcU,391
 karrio/server/manager/tests/test_addresses.py,sha256=pNkZC_yJyb29ZlEOtOAs4blcEYiOarw0zhZIZC5uj1w,3111
 karrio/server/manager/tests/test_custom_infos.py,sha256=iv2cLdZVoVWFZK_mDUEnrZssncAnQcn87Rn2sAk8UQI,2731
-karrio/server/manager/tests/test_errors.py,sha256=QYsGLUtwMvrHeX1XSCpdteTKbug7-y1-Xgvbl96aN9g,3220
+karrio/server/manager/tests/test_errors.py,sha256=x2-mSsXknHkE4V7TajEu8d3rpqV38T_xyAaYJU7xcGQ,3616
+karrio/server/manager/tests/test_manifests.py,sha256=X35ZTXTFEM4Gxdjz598yiNNkOOKZGpILjHWRC0oM5U4,2764
 karrio/server/manager/tests/test_parcels.py,sha256=lVLBOsHzXgXQvYjHIUy5oiPvrMfxYpueVvvhtuhstWk,2559
 karrio/server/manager/tests/test_pickups.py,sha256=8jxddwTnBvBM9FOyWxW9TtZ-GOVYUje7HQ2EZjsbtD8,10681
-karrio/server/manager/tests/test_shipments.py,sha256=N1eVH-n0BTANmzehKL0cp917goskU5X8l_ftXzcVSmw,33349
+karrio/server/manager/tests/test_shipments.py,sha256=wvF_ZBK3QDI1id51bVh9FARuLQR18jkxP7n9tub7loo,39455
 karrio/server/manager/tests/test_trackers.py,sha256=KvmWkplokNDZ0dzB16mFl0WcMJ0OYp_ErZeWJPGW_NA,7151
 karrio/server/manager/views/__init__.py,sha256=kDFUaORRQ3Xh0ZPm-Jk88Ss8dgGYM57iUFXb9TPMzh0,401
 karrio/server/manager/views/addresses.py,sha256=7YCAs2ZYgd1icYwMcGGWfX7A7vZEL4BEAbU4eIxhiMY,4620
 karrio/server/manager/views/customs.py,sha256=-ZreiKyJ1xeLeNVG53nMfRQFeURduWr1QkDItdLPnE8,4875
 karrio/server/manager/views/documents.py,sha256=znW54qJ_k7WInIut5FBZFDT93CioozXTOYFKRSUTBhA,4005
-karrio/server/manager/views/manifests.py,sha256=_Dd83YxVJOgWhAhD745Kr4tcLWnKaU1dxnT5xB8opvk,5227
+karrio/server/manager/views/manifests.py,sha256=bk-8XoGLVqgjDfpTZbTKjXW7r8DYNDp2ce2xGG73sbI,7012
 karrio/server/manager/views/parcels.py,sha256=hZY45rg6SrTWfQqyJ38MGKSor1yqgPUEVHtu16aG37g,4594
 karrio/server/manager/views/pickups.py,sha256=gmpxz9ot1OR-BP1qh-0MXU3kUJi1ht_74hfaLJzJ42w,5503
-karrio/server/manager/views/shipments.py,sha256=TqLpBH5Jf-rI3enJwvNptRwGzfo7co9R1VSP_oqhB3o,10419
+karrio/server/manager/views/shipments.py,sha256=YCP0A8U-wFFwMgEfMZ3egWb4PwJ-aPLijILjwtH7aHo,12998
 karrio/server/manager/views/trackers.py,sha256=3oGn2qDpHgk8GZvuz-Cb93Fc0j_h_HbXQR692Zhfiok,12363
-karrio_server_manager-2025.5.1.dist-info/METADATA,sha256=7G3zIzLe_6ux6VkjCj1ub1xQc4b9Cz-uiyzwvBpSDDs,730
-karrio_server_manager-2025.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-karrio_server_manager-2025.5.1.dist-info/top_level.txt,sha256=D1D7x8R3cTfjF_15mfiO7wCQ5QMtuM4x8GaPr7z5i78,12
-karrio_server_manager-2025.5.1.dist-info/RECORD,,
+karrio_server_manager-2025.5.3.dist-info/METADATA,sha256=LpqgZqS3merjsArSi0Hz_yZKBjNSksZ40YXNMhe5IVY,730
+karrio_server_manager-2025.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+karrio_server_manager-2025.5.3.dist-info/top_level.txt,sha256=D1D7x8R3cTfjF_15mfiO7wCQ5QMtuM4x8GaPr7z5i78,12
+karrio_server_manager-2025.5.3.dist-info/RECORD,,