karrio-boxknight 2025.5rc1__py3-none-any.whl

karrio/mappers/boxknight/__init__.py

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

karrio/mappers/boxknight/mapper.py

@@ -0,0 +1,50 @@
+"""Karrio BoxKnight client mapper."""
+
+import typing
+import karrio.lib as lib
+import karrio.api.mapper as mapper
+import karrio.core.models as models
+import karrio.providers.boxknight as provider
+import karrio.mappers.boxknight.settings as provider_settings
+
+
+class Mapper(mapper.Mapper):
+    settings: provider_settings.Settings
+
+    def create_rate_request(self, payload: models.RateRequest) -> lib.Serializable:
+        return 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_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_rate_response(
+        self, response: lib.Deserializable
+    ) -> 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
+    ) -> typing.Tuple[models.ShipmentDetails, typing.List[models.Message]]:
+        return provider.parse_shipment_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/boxknight/proxy.py

@@ -0,0 +1,82 @@
+"""Karrio BoxKnight client proxy."""
+
+import typing
+import base64
+import karrio.lib as lib
+import karrio.api.proxy as proxy
+import karrio.mappers.boxknight.settings as provider_settings
+
+
+class Proxy(proxy.Proxy):
+    settings: provider_settings.Settings
+
+    def get_rates(self, request: lib.Serializable) -> lib.Deserializable:
+        response = lib.request(
+            url=f"{self.settings.server_url}/rates",
+            data=request.serialize(),
+            trace=self.trace_as("json"),
+            method="POST",
+            headers={"Authorization": self.settings.auth_token},
+        )
+
+        return lib.Deserializable(response, lib.to_dict)
+
+    def create_shipment(self, request: lib.Serializable) -> lib.Deserializable:
+        payload = request.serialize()
+        result = lib.to_dict(
+            lib.request(
+                url=f"{self.settings.server_url}/orders",
+                data=payload["order"],
+                trace=self.trace_as("json"),
+                method="POST",
+                headers={"Authorization": self.settings.auth_token},
+            )
+        )
+
+        response = (
+            dict(
+                order_id=result["id"],
+                label_type=payload["label_type"],
+                service=payload["order"]["service"],
+                label=lib.request(
+                    url=f"{self.settings.server_url}/labels/{result['id']}?format={payload['label_type']}",
+                    decoder=lambda b: base64.encodebytes(b).decode("utf-8"),
+                    headers={"Authorization": self.settings.auth_token},
+                    trace=self.trace_as("json"),
+                ),
+            )
+            if result.get("error") is None
+            else result
+        )
+
+        return lib.Deserializable(response)
+
+    def cancel_shipment(self, request: lib.Serializable) -> lib.Deserializable:
+        response = lib.request(
+            url=f"{self.settings.server_url}/orders/{request.serialize()['order_id']}",
+            trace=self.trace_as("json"),
+            method="DELETE",
+            headers={"Authorization": self.settings.auth_token},
+        )
+
+        return lib.Deserializable(response, lib.to_dict)
+
+    def get_tracking(self, requests: lib.Serializable) -> lib.Deserializable:
+        track = lambda data: (
+            data["order_id"],
+            lib.request(
+                url=f"{self.settings.server_url}/orders/{data['order_id']}",
+                trace=self.trace_as("json"),
+                method="GET",
+                headers={"Authorization": self.settings.auth_token},
+            ),
+        )
+
+        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/boxknight/settings.py

@@ -0,0 +1,23 @@
+"""Karrio BoxKnight client settings."""
+
+import attr
+import jstruct
+import karrio.lib as lib
+import karrio.providers.boxknight.utils as provider_utils
+
+
+@attr.s(auto_attribs=True)
+class Settings(provider_utils.Settings):
+    """BoxKnight connection settings."""
+
+    # required carrier specific properties
+    username: str
+    password: str
+
+    # generic properties
+    id: str = None
+    test_mode: bool = False
+    carrier_id: str = "boxknight"
+    account_country_code: str = "CA"
+    metadata: dict = {}
+    config: dict = {}

karrio/plugins/boxknight/__init__.py

@@ -0,0 +1,22 @@
+import karrio.core.metadata as metadata
+import karrio.mappers.boxknight as mappers
+import karrio.providers.boxknight.units as units
+
+
+METADATA = metadata.PluginMetadata(
+    status="beta",
+    id="boxknight",
+    label="BoxKnight",
+    # Integrations
+    Mapper=mappers.Mapper,
+    Proxy=mappers.Proxy,
+    Settings=mappers.Settings,
+    # Data Units
+    is_hub=False,
+    services=units.ShippingService,
+    options=units.ShippingOption,
+    # New fields
+    website="https://www.boxknight.com/",
+    documentation="https://www.docs.boxknight.com/",
+    description="Specializes in same-day delivery at affordable prices for e-commerce retailers. Our mission is to get packages to your customers when they are actually home and as quickly as possible.",
+)

karrio/providers/boxknight/__init__.py

@@ -0,0 +1,13 @@
+
+from karrio.providers.boxknight.utils import Settings
+from karrio.providers.boxknight.rate import parse_rate_response, rate_request
+from karrio.providers.boxknight.shipment import (
+    parse_shipment_cancel_response,
+    parse_shipment_response,
+    shipment_cancel_request,
+    shipment_request,
+)
+from karrio.providers.boxknight.tracking import (
+    parse_tracking_response,
+    tracking_request,
+)

karrio/providers/boxknight/error.py

@@ -0,0 +1,29 @@
+import karrio.schemas.boxknight.error as boxknight
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+import karrio.providers.boxknight.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(boxknight.Error, res)
+        for res in responses
+        if res.get("error") is not None
+    ]
+
+    return [
+        models.Message(
+            carrier_id=settings.carrier_id,
+            carrier_name=settings.carrier_name,
+            code=None,
+            message=error.error,
+            details={**kwargs},
+        )
+        for error in errors
+    ]

karrio/providers/boxknight/rate.py

@@ -0,0 +1,91 @@
+import karrio.schemas.boxknight.rate_request as boxknight
+import karrio.schemas.boxknight.rate_response as rating
+import typing
+import karrio.lib as lib
+import karrio.core.units as units
+import karrio.core.models as models
+import karrio.core.errors as errors
+import karrio.providers.boxknight.error as error
+import karrio.providers.boxknight.utils as provider_utils
+import karrio.providers.boxknight.units as provider_units
+
+
+def parse_rate_response(
+    _response: lib.Deserializable[typing.Union[dict, typing.List[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)
+    rates = [
+        _extract_details(rate, settings)
+        for rate in response
+        if isinstance(response, list)
+    ]
+
+    return rates, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+) -> models.RateDetails:
+    rate = lib.to_object(rating.Rate, data)
+    service = provider_units.ShippingService.map(rate.service)
+    transit_days = (
+        lib.to_date(rate.estimateTo, "%Y-%m-%d")
+        - lib.to_date(rate.estimateFrom, "%Y-%m-%d")
+    ).days
+
+    return models.RateDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        service=service.name_or_key,
+        total_charge=lib.to_money(rate.price),
+        currency=units.Currency.CAD.name,
+        transit_days=transit_days if transit_days > 0 else 1,
+        meta=dict(service_name=rate.name),
+    )
+
+
+def rate_request(
+    payload: models.RateRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+    if (
+        payload.shipper.country_code is not None
+        and payload.shipper.country_code != units.Country.CA.name
+    ):
+        raise errors.OriginNotServicedError(payload.shipper.country_code)
+
+    if (
+        payload.recipient.country_code is not None
+        and payload.recipient.country_code != units.Country.CA.name
+    ):
+        raise errors.DestinationNotServicedError(payload.recipient.country_code)
+
+    packages = lib.to_packages(payload.parcels)
+
+    request = boxknight.RateRequest(
+        postalCode=payload.recipient.postal_code,
+        originPostalCode=payload.shipper.postal_code,
+        packages=[
+            boxknight.Package(
+                refNumber=package.parcel.reference_number or str(idx),
+                weightOptions=boxknight.WeightOptions(
+                    weight=package.weight.value,
+                    unit=package.weight_unit.value.lower(),
+                ),
+                sizeOptions=boxknight.SizeOptions(
+                    length=package.length.value,
+                    width=package.width.value,
+                    height=package.height.value,
+                    unit=provider_units.DimensionUnit.map(
+                        package.dimension_unit.name
+                    ).value,
+                ),
+            )
+            for idx, package in enumerate(packages, start=1)
+        ],
+    )
+
+    return lib.Serializable(request, lib.to_dict)

karrio/providers/boxknight/shipment/__init__.py

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

karrio/providers/boxknight/shipment/cancel.py

@@ -0,0 +1,37 @@
+import typing
+import karrio.lib as lib
+import karrio.core.models as models
+import karrio.providers.boxknight.error as error
+import karrio.providers.boxknight.utils as provider_utils
+import karrio.providers.boxknight.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("error") is None
+
+    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 = dict(order_id=payload.shipment_identifier)
+
+    return lib.Serializable(request)

karrio/providers/boxknight/shipment/create.py

@@ -0,0 +1,134 @@
+import karrio.schemas.boxknight.order_request as boxknight
+import typing
+import karrio.lib as lib
+import karrio.core.units as units
+import karrio.core.models as models
+import karrio.core.errors as errors
+import karrio.providers.boxknight.error as error
+import karrio.providers.boxknight.utils as provider_utils
+import karrio.providers.boxknight.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) if response.get("error") is None else None
+    )
+
+    return shipment, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+) -> models.ShipmentDetails:
+    return models.ShipmentDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        tracking_number=data["order_id"],
+        shipment_identifier=data["order_id"],
+        label_type=data["label_type"],
+        docs=models.Documents(label=data["label"]),
+        meta=dict(service_name=data.get("service")),
+    )
+
+
+def shipment_request(
+    payload: models.ShipmentRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+    if (
+        payload.shipper.country_code is not None
+        and payload.shipper.country_code != units.Country.CA.name
+    ):
+        raise errors.OriginNotServicedError(payload.shipper.country_code)
+
+    if (
+        payload.recipient.country_code is not None
+        and payload.recipient.country_code != units.Country.CA.name
+    ):
+        raise errors.DestinationNotServicedError(payload.recipient.country_code)
+
+    shipper = lib.to_address(payload.shipper)
+    recipient = lib.to_address(payload.recipient)
+    packages = lib.to_packages(payload.parcels)
+    service = provider_units.ShippingService.map(payload.service).value_or_key
+    options = lib.to_shipping_options(
+        payload.options,
+        package_options=packages.options,
+        initializer=provider_units.shipping_options_initializer,
+    )
+
+    request = dict(
+        order=boxknight.OrderRequest(
+            recipient=(
+                boxknight.Recipient(
+                    name=recipient.contact,
+                    phone=recipient.phone_number,
+                    notes=None,
+                    email=recipient.email,
+                )
+                if any([recipient.contact, recipient.phone_number, recipient.email])
+                else None
+            ),
+            recipientAddress=boxknight.Address(
+                street=recipient.address_line1,
+                unit=recipient.address_line2,
+                city=recipient.city,
+                province=units.CountryState.CA.value[recipient.state_code].value,
+                country=units.Country.CA.value,
+                postalCode=recipient.postal_code,
+                isBusinessAddress=recipient.residential is False,
+            ),
+            originAddress=boxknight.Address(
+                street=shipper.address_line1,
+                unit=shipper.address_line2,
+                city=shipper.city,
+                province=units.CountryState.CA.value[shipper.state_code].value,
+                country=units.Country.CA.value,
+                postalCode=shipper.postal_code,
+                isBusinessAddress=shipper.residential is False,
+            ),
+            packageCount=len(packages),
+            service=service,
+            notes=options.boxknight_notes.state,
+            refNumber=payload.reference,
+            merchantDisplayName=(
+                shipper.company_name or options.boxknight_merchant_display_name.state
+            ),
+            signatureRequired=options.boxknight_signature_required.state,
+            packages=[
+                boxknight.Package(
+                    refNumber=package.parcel.reference_number or str(idx),
+                    weightOptions=boxknight.WeightOptions(
+                        weight=package.weight.value,
+                        unit=package.weight_unit.value.lower(),
+                    ),
+                    sizeOptions=boxknight.SizeOptions(
+                        length=package.length.value,
+                        width=package.width.value,
+                        height=package.height.value,
+                        unit=provider_units.DimensionUnit.map(
+                            package.dimension_unit.value
+                        ).value,
+                    ),
+                )
+                for idx, package in enumerate(packages, start=1)
+            ],
+        ),
+        label_type=units.LabelType.map(
+            payload.label_type or "PDF"
+        ).value_or_key.lower(),
+    )
+
+    return lib.Serializable(
+        request,
+        lambda _: {
+            "order": lib.to_dict(_["order"]),
+            "label_type": _["label_type"],
+        },
+    )

karrio/providers/boxknight/tracking.py

@@ -0,0 +1,83 @@
+import datetime
+import karrio.schemas.boxknight.tracking_response as boxknight
+import typing
+import karrio.lib as lib
+import karrio.core.units as units
+import karrio.core.models as models
+import karrio.providers.boxknight.error as error
+import karrio.providers.boxknight.utils as provider_utils
+import karrio.providers.boxknight.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(res, settings, tracking_number=number)
+            for number, res in responses
+            if res.get("error") is not None
+        ],
+        start=[],
+    )
+    tracking_details = [
+        _extract_details(res, settings)
+        for _, res in responses
+        if res.get("error") is None
+    ]
+
+    return tracking_details, messages
+
+
+def _extract_details(
+    data: dict,
+    settings: provider_utils.Settings,
+) -> models.TrackingDetails:
+    order = lib.to_object(boxknight.TrackingResponse, data)
+    delivered = order.orderStatus == "DELIVERY_COMPLETED"
+
+    return models.TrackingDetails(
+        carrier_id=settings.carrier_id,
+        carrier_name=settings.carrier_name,
+        tracking_number=order.id,
+        events=[
+            models.TrackingEvent(
+                description=order.orderStatus,
+                code=order.orderStatus,
+                date=lib.fdate(datetime.datetime.now(), "%Y-%m-%dT%H:%M:%S.%fZ"),
+                time=lib.flocaltime(datetime.datetime.now(), "%Y-%m-%dT%H:%M:%S.%fZ"),
+            )
+        ],
+        delivered=delivered,
+        meta=dict(reference=order.refNumber),
+        info=models.TrackingInfo(
+            carrier_tracking_link=settings.tracking_url.format(order.id),
+            customer_name=getattr(order.recipient, "name", None),
+            shipment_package_count=order.packageCount,
+            shipment_service=order.service,
+            shipment_origin_postal_code=getattr(
+                order.originAddress, "postalCode", None
+            ),
+            shipment_origin_country=units.Country.map(
+                getattr(order.originAddress, "country", None)
+            ).name,
+            shipment_destination_postal_code=getattr(
+                order.recipientAddress, "postalCode", None
+            ),
+            shipment_destination_country=units.Country.map(
+                getattr(order.recipientAddress, "country", None)
+            ).name,
+            shipping_date=lib.fdate(order.createdAt, "%Y-%m-%dT%H:%M:%S.%fZ"),
+        ),
+    )
+
+
+def tracking_request(
+    payload: models.TrackingRequest,
+    settings: provider_utils.Settings,
+) -> lib.Serializable:
+    request = [dict(order_id=number) for number in payload.tracking_numbers]
+
+    return lib.Serializable(request)

karrio/providers/boxknight/units.py

@@ -0,0 +1,65 @@
+import karrio.lib as lib
+import karrio.core.units as units
+
+
+class DimensionUnit(lib.StrEnum):
+    CM = "cm"
+    IN = "inch"
+
+
+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 ShippingService(lib.StrEnum):
+    """Carrier specific services"""
+
+    boxknight_sameday = "SAMEDAY"
+    boxknight_nextday = "NEXTDAY"
+    boxknight_scheduled = "SCHEDULED"
+
+
+class ShippingOption(lib.Enum):
+    """Carrier specific options"""
+
+    boxknight_signature_required = lib.OptionEnum("signatureRequired", bool)
+    boxknight_merchant_display_name = lib.OptionEnum("merchantDisplayName")
+    boxknight_notes = lib.OptionEnum("notes")
+
+    signature_required = boxknight_signature_required
+
+
+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):
+    on_hold = ["CREATED", "GEOCODED"]
+    delivered = ["DELIVERY_COMPLETED"]
+    in_transit = ["DELIVERY_ASSIGNED", "PICKUP_EN_ROUTE"]
+    delivery_delayed = ["delivery_delayed"]
+    out_for_delivery = ["PICKUP_COMPLETED", "DELIVERY_EN_ROUTE"]

karrio/providers/boxknight/utils.py

@@ -0,0 +1,60 @@
+import jstruct
+import karrio.lib as lib
+import karrio.core as core
+import karrio.core.errors as errors
+
+
+class Settings(core.Settings):
+    """BoxKnight connection settings."""
+
+    username: str
+    password: str
+
+    @property
+    def carrier_name(self):
+        return "boxknight"
+
+    @property
+    def server_url(self):
+        return "https://api.boxknight.com/v1"
+
+    @property
+    def tracking_url(self):
+        return "https://www.tracking.boxknight.com/tracking?trackingNo={}"
+
+    @property
+    def auth_token(self):
+        """Retrieve the auth token using the username|passwword pair
+        or collect it from the cache if an unexpired token exist.
+        """
+        cache_key = f"{self.carrier_name}|{self.username}|{self.password}"
+        auth = self.connection_cache.get(cache_key) or {}
+        token = auth.get("token")
+
+        if token is not None:
+            return token
+
+        self.connection_cache.set(cache_key, lambda: authenticate(self))
+        new_auth = self.connection_cache.get(cache_key)
+
+        if any(self.depot or "") is False:
+            self.depot = new_auth["depot"]
+
+        return new_auth["token"]
+
+
+def authenticate(settings: Settings):
+    import karrio.providers.boxknight.error as error
+
+    result = lib.request(
+        url=f"{settings.server_url}/soap/services/LoginService/V2_1",
+        data=dict(username=settings.username, password=settings.password),
+        method="POST",
+    )
+    response = lib.to_dict(result)
+    messages = error.parse_error_response(response, settings)
+
+    if any(messages):
+        raise errors.ParsedMessagesError(messages=messages)
+
+    return dict(token=response["token"])

karrio/schemas/boxknight/error.py

@@ -0,0 +1,8 @@
+import attr
+import jstruct
+import typing
+
+
+@attr.s(auto_attribs=True)
+class Error:
+    error: typing.Optional[str] = None

karrio/schemas/boxknight/order_request.py

@@ -0,0 +1,57 @@
+import attr
+import jstruct
+import typing
+
+
+@attr.s(auto_attribs=True)
+class Address:
+    street: typing.Optional[str] = None
+    unit: typing.Optional[str] = None
+    city: typing.Optional[str] = None
+    province: typing.Optional[str] = None
+    country: typing.Optional[str] = None
+    postalCode: typing.Optional[str] = None
+    isBusinessAddress: typing.Optional[bool] = None
+
+
+@attr.s(auto_attribs=True)
+class SizeOptions:
+    length: typing.Optional[float] = None
+    width: typing.Optional[float] = None
+    height: typing.Optional[float] = None
+    unit: typing.Optional[str] = None
+
+
+@attr.s(auto_attribs=True)
+class WeightOptions:
+    weight: typing.Optional[float] = None
+    unit: typing.Optional[str] = None
+
+
+@attr.s(auto_attribs=True)
+class Package:
+    refNumber: typing.Optional[int] = None
+    weightOptions: typing.Optional[WeightOptions] = jstruct.JStruct[WeightOptions]
+    sizeOptions: typing.Optional[SizeOptions] = jstruct.JStruct[SizeOptions]
+
+
+@attr.s(auto_attribs=True)
+class Recipient:
+    name: typing.Optional[str] = None
+    phone: typing.Optional[str] = None
+    notes: typing.Optional[str] = None
+    email: typing.Optional[str] = None
+
+
+@attr.s(auto_attribs=True)
+class OrderRequest:
+    recipient: typing.Optional[Recipient] = jstruct.JStruct[Recipient]
+    recipientAddress: typing.Optional[Address] = jstruct.JStruct[Address]
+    originAddress: typing.Optional[Address] = jstruct.JStruct[Address]
+    packageCount: typing.Optional[int] = None
+    service: typing.Optional[str] = None
+    notes: typing.Optional[str] = None
+    refNumber: typing.Optional[str] = None
+    merchantDisplayName: typing.Optional[str] = None
+    signatureRequired: typing.Optional[bool] = None
+    packages: typing.Optional[typing.List[Package]] = jstruct.JList[Package]

karrio/schemas/boxknight/rate_request.py

@@ -0,0 +1,31 @@
+import attr
+import jstruct
+import typing
+
+
+@attr.s(auto_attribs=True)
+class SizeOptions:
+    length: typing.Optional[float] = None
+    width: typing.Optional[float] = None
+    height: typing.Optional[float] = None
+    unit: typing.Optional[str] = None
+
+
+@attr.s(auto_attribs=True)
+class WeightOptions:
+    weight: typing.Optional[float] = None
+    unit: typing.Optional[str] = None
+
+
+@attr.s(auto_attribs=True)
+class Package:
+    refNumber: typing.Optional[int] = None
+    weightOptions: typing.Optional[WeightOptions] = jstruct.JStruct[WeightOptions]
+    sizeOptions: typing.Optional[SizeOptions] = jstruct.JStruct[SizeOptions]
+
+
+@attr.s(auto_attribs=True)
+class RateRequest:
+    postalCode: typing.Optional[str] = None
+    originPostalCode: typing.Optional[str] = None
+    packages: typing.Optional[typing.List[Package]] = jstruct.JList[Package]

karrio/schemas/boxknight/rate_response.py

@@ -0,0 +1,19 @@
+import attr
+import jstruct
+import typing
+
+
+@attr.s(auto_attribs=True)
+class Rate:
+    price: typing.Optional[int] = None
+    service: typing.Optional[str] = None
+    name: typing.Optional[str] = None
+    description: typing.Optional[str] = None
+    estimateDay: typing.Optional[str] = None
+    estimateFrom: typing.Optional[str] = None
+    estimateTo: typing.Optional[str] = None
+
+
+@attr.s(auto_attribs=True)
+class RateResponse:
+    rates: typing.Optional[typing.List[Rate]] = jstruct.JList[Rate]

karrio/schemas/boxknight/tracking_response.py

@@ -0,0 +1,53 @@
+import attr
+import jstruct
+import typing
+
+
+@attr.s(auto_attribs=True)
+class Location:
+    lat: typing.Optional[float] = None
+    lng: typing.Optional[float] = None
+
+
+@attr.s(auto_attribs=True)
+class Address:
+    number: typing.Optional[int] = None
+    street: typing.Optional[str] = None
+    city: typing.Optional[str] = None
+    province: typing.Optional[str] = None
+    country: typing.Optional[str] = None
+    postalCode: typing.Optional[str] = None
+    sublocality: typing.Optional[str] = None
+    location: typing.Optional[Location] = jstruct.JStruct[Location]
+
+
+@attr.s(auto_attribs=True)
+class Recipient:
+    name: typing.Optional[str] = None
+    phone: typing.Optional[str] = None
+    notes: typing.Optional[str] = None
+    email: typing.Optional[str] = None
+
+
+@attr.s(auto_attribs=True)
+class TrackingResponse:
+    id: typing.Optional[str] = None
+    createdAt: typing.Optional[str] = None
+    createdBy: typing.Optional[str] = None
+    merchantId: typing.Optional[str] = None
+    orderStatus: typing.Optional[str] = None
+    scanningRequired: typing.Optional[bool] = None
+    validAddress: typing.Optional[bool] = None
+    labelUrl: typing.Optional[str] = None
+    pdfLabelUrl: typing.Optional[str] = None
+    recipient: typing.Optional[Recipient] = jstruct.JStruct[Recipient]
+    recipientAddress: typing.Optional[Address] = jstruct.JStruct[Address]
+    originAddress: typing.Optional[Address] = jstruct.JStruct[Address]
+    packageCount: typing.Optional[int] = None
+    signatureRequired: typing.Optional[bool] = None
+    service: typing.Optional[str] = None
+    notes: typing.Optional[str] = None
+    refNumber: typing.Optional[str] = None
+    completeAfter: typing.Optional[int] = None
+    completeBefore: typing.Optional[int] = None
+    merchantDisplayName: typing.Optional[str] = None

karrio_boxknight-2025.5rc1.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: karrio_boxknight
+Version: 2025.5rc1
+Summary: Karrio - BoxKnight 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.boxknight
+
+This package is a BoxKnight extension of the [karrio](https://pypi.org/project/karrio) multi carrier shipping SDK.
+
+## Requirements
+
+`Python 3.7+`
+
+## Installation
+
+```bash
+pip install karrio.boxknight
+```
+
+## Usage
+
+```python
+import karrio.sdk as karrio
+from karrio.mappers.boxknight.settings import Settings
+
+
+# Initialize a carrier gateway
+boxknight = karrio.gateway["boxknight"].create(
+    Settings(
+        ...
+    )
+)
+```
+
+Check the [Karrio Mutli-carrier SDK docs](https://docs.karrio.io) for Shipping API requests

karrio_boxknight-2025.5rc1.dist-info/RECORD

@@ -0,0 +1,25 @@
+karrio/mappers/boxknight/__init__.py,sha256=SALvjoaukPIeMxCGQIM9aUjjsIz7BY0UUIx5-k9eJxY,155
+karrio/mappers/boxknight/mapper.py,sha256=HFHxpy2VDrzHtV6ZYzqWBKw47eMkXbxv4ia2QJhdGr0,1947
+karrio/mappers/boxknight/proxy.py,sha256=4OHf2vM2hx8u4ri_ZDS0Oc7sIVPv6PhenxxOpVl9UMU,2870
+karrio/mappers/boxknight/settings.py,sha256=Ilqa1vgwpah5o-1M6pt_ftb5WpMG7pO-VLuWMCEGyHY,532
+karrio/plugins/boxknight/__init__.py,sha256=pJmgB7-NH5Gl-bAgBogK0OogPS0BA7nuZeWXWq9dQRs,756
+karrio/providers/boxknight/__init__.py,sha256=0WwIjVf2pRM4uE9NrqZ_PSdzmTTeeGjZfdWdfsh0tSY,404
+karrio/providers/boxknight/error.py,sha256=W6R_Q1fwRw-kW1p9XuLrRitmT4suGB3eW6UNszAViss,819
+karrio/providers/boxknight/rate.py,sha256=Vh3OqiY-IHpf--bffMQuyrtC4VIabl3FENz-rnvrS_Q,3130
+karrio/providers/boxknight/tracking.py,sha256=4KzbOB-VOx6ZItvCface3YL-k2IGJtp1EFtR43NO5No,2982
+karrio/providers/boxknight/units.py,sha256=JIgfBxvYcX-QpSC9G-h762tChA6HGDDV7E2VEUV_RRg,1676
+karrio/providers/boxknight/utils.py,sha256=UCWT4utryNAAajgQXJ2MMv7kNpdwketRJNwr3k83d-w,1667
+karrio/providers/boxknight/shipment/__init__.py,sha256=AKoH2eQcuZuJhyJNh7oGcM5_9qh-pUPrnAa4RBgZDbU,235
+karrio/providers/boxknight/shipment/cancel.py,sha256=Od0CUtJyvcdufb-WAhbJ6emWPFS61mCXZX5eMV5CA68,1118
+karrio/providers/boxknight/shipment/create.py,sha256=QwJIWb7rQLzZwSHAvE9LdmZPw5FSriVzuPve6GbNw_Y,5001
+karrio/schemas/boxknight/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+karrio/schemas/boxknight/error.py,sha256=P2l807AVgrtoxDoLWJcshp0gmO3giul7j_CecNpVk3Q,122
+karrio/schemas/boxknight/order_request.py,sha256=YKoMUvxPTtQVO5vRb1Oa5afu-wLD3ktkMA2AgsMts9g,1785
+karrio/schemas/boxknight/rate_request.py,sha256=rdmfzMK-2zpuQzu8gahHUHo0gfM2R60uL6C17ijVtQo,848
+karrio/schemas/boxknight/rate_response.py,sha256=mYg7ThzQ7qzD9bp2_PVmVT996lbUsC2UAeVT8hH7hBU,497
+karrio/schemas/boxknight/tracking_response.py,sha256=f3r-edDsF1_AFZjJ11PSv8eM0b-YVdTIZWar-Ta045s,1801
+karrio_boxknight-2025.5rc1.dist-info/METADATA,sha256=o5nmgmAFQlzm24jKazpxANnuWhaXphLRm-hOaM0vz7E,1008
+karrio_boxknight-2025.5rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+karrio_boxknight-2025.5rc1.dist-info/entry_points.txt,sha256=YnqTcqXFHHm7AAutRMn78415tSbWLShqgQKNgsl6Ows,63
+karrio_boxknight-2025.5rc1.dist-info/top_level.txt,sha256=FZCY8Nwft8oEGHdl--xku8P3TrnOxu5dETEU_fWpRSM,20
+karrio_boxknight-2025.5rc1.dist-info/RECORD,,

karrio_boxknight-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_boxknight-2025.5rc1.dist-info/entry_points.txt

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

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

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