karrio 2023.5.1__py3-none-any.whl → 2025.5rc1__py3-none-any.whl

karrio/core/units.py

@@ -1,5 +1,6 @@
 """Karrio universal data types and units definitions"""
 
+from ctypes import util
 import attr
 import typing
 import numbers
@@ -24,20 +25,20 @@ class PackagePreset:
     packaging_type: str = None
 
 
-class LabelType(utils.Enum):
+class LabelType(utils.StrEnum):
     PDF = "PDF"
     ZPL = "ZPL"
     PNG = "PNG"
 
 
-class DocFormat(utils.Enum):
+class DocFormat(utils.StrEnum):
     gif = "GIF"
     jpg = "JPG"
     pdf = "PDF"
     png = "PNG"
 
 
-class PackagingUnit(utils.Enum):
+class PackagingUnit(utils.StrEnum):
     envelope = "Small Envelope"
     pak = "Pak"
     tube = "Tube"
@@ -47,19 +48,19 @@ class PackagingUnit(utils.Enum):
     your_packaging = "Your Packaging"
 
 
-class PaymentType(utils.Enum):
+class PaymentType(utils.StrEnum):
     sender = "SENDER"
     recipient = "RECIPIENT"
     third_party = "THIRD_PARTY"
 
 
-class CreditCardType(utils.Enum):
+class CreditCardType(utils.StrEnum):
     visa = "Visa"
     mastercard = "Mastercard"
     american_express = "AmericanExpress"
 
 
-class CustomsContentType(utils.Enum):
+class CustomsContentType(utils.StrEnum):
     documents = "DOCUMENTS"
     gift = "GIFT"
     sample = "SAMPLE"
@@ -68,13 +69,14 @@ class CustomsContentType(utils.Enum):
     other = "OTHER"
 
 
-class Incoterm(utils.Enum):
+class Incoterm(utils.StrEnum):
     """universal international shipment incoterm (term of trades)"""
 
     CFR = "Cost and Freight"
     CIF = "Cost Insurance and Freight"
     CIP = "Carriage and Insurance Paid"
     CPT = "Carriage Paid To"
+    DAP = "Delivery at Place"
     DAF = "Delivered at Frontier"
     DDP = "Delivery Duty Paid"
     DDU = "Delivery Duty Unpaid"
@@ -86,20 +88,36 @@ class Incoterm(utils.Enum):
     FOB = "Free On Board"
 
 
-class WeightUnit(utils.Enum):
+class WeightUnit(utils.StrEnum):
     """universal weight units"""
 
     KG = "KG"
     LB = "LB"
+    OZ = "OZ"
+    G = "G"
 
 
-class DimensionUnit(utils.Enum):
+class DimensionUnit(utils.StrEnum):
     """universal dimension units"""
 
     CM = "CM"
     IN = "IN"
 
 
+class VolumeUnit(utils.StrEnum):
+    """universal dimension units"""
+
+    l = "l"
+    m3 = "m3"
+    i3 = "i3"
+    ft3 = "ft3"
+    cm3 = "cm3"
+
+    """ mapping from dimension units to volume units """
+    CM = "cm3"
+    IN = "i3"
+
+
 class FreightClass(utils.Enum):
     """universal freight_class units"""
 
@@ -123,7 +141,7 @@ class FreightClass(utils.Enum):
     freight_class_400 = 400
 
 
-class UploadDocumentType(utils.Enum):
+class UploadDocumentType(utils.StrEnum):
     """universal upload document types"""
 
     certificate_of_origin = "certificate_of_origin"
@@ -134,17 +152,23 @@ class UploadDocumentType(utils.Enum):
 
 
 class MeasurementOptionsType(typing.NamedTuple):
+    quant: typing.Optional[float] = None
+
     min_in: typing.Optional[float] = None
     min_cm: typing.Optional[float] = None
     min_lb: typing.Optional[float] = None
     min_kg: typing.Optional[float] = None
     min_oz: typing.Optional[float] = None
+    min_g: typing.Optional[float] = None
     max_in: typing.Optional[float] = None
     max_cm: typing.Optional[float] = None
     max_lb: typing.Optional[float] = None
     max_kg: typing.Optional[float] = None
     max_oz: typing.Optional[float] = None
-    quant: typing.Optional[float] = None
+    max_g: typing.Optional[float] = None
+
+    min_volume: typing.Optional[float] = None
+    max_volume: typing.Optional[float] = None
 
 
 class CarrierCapabilities(utils.Enum):
@@ -153,6 +177,7 @@ class CarrierCapabilities(utils.Enum):
     shipping = "shipping"
     tracking = "tracking"
     paperless = "paperless"
+    manifest = "manifest"
 
     @classmethod
     def get_capabilities(cls):
@@ -172,6 +197,8 @@ class CarrierCapabilities(utils.Enum):
             return "shipping"
         elif "document" in method_name:
             return "paperless"
+        elif "manifest" in method_name:
+            return "manifest"
 
         return None
 
@@ -241,6 +268,13 @@ class Dimension:
         else:
             return self._compute(self.CM / 100)
 
+    @property
+    def MM(self):
+        if self._unit is None or self._value is None:
+            return None
+        else:
+            return self._compute(self.CM * 10)
+
     def map(self, options: MeasurementOptionsType):
         return Dimension(value=self._value, unit=self._unit, options=options)
 
@@ -249,24 +283,148 @@ class Volume:
     """The volume common processing helper"""
 
     def __init__(
-        self, side1: Dimension = None, side2: Dimension = None, side3: Dimension = None
+        self,
+        side1: Dimension = None,
+        side2: Dimension = None,
+        side3: Dimension = None,
+        value: float = None,
+        unit: typing.Union[VolumeUnit, str] = VolumeUnit.cm3,
+        options: MeasurementOptionsType = MeasurementOptionsType(),
     ):
         self._side1 = side1
         self._side2 = side2
         self._side3 = side3
 
+        self._value = value
+        self._unit = VolumeUnit[unit] if isinstance(unit, str) else unit
+
+        self._quant = 0.01
+        self._min_volume = options.min_volume
+
+    def __getitem__(self, item):
+        return getattr(self, item)
+
+    def _compute(self, value: float):
+        below_min = self._min_volume is not None and value < self._min_volume
+        return utils.NF.decimal(
+            value=(self._min_volume if below_min else value),
+            quant=self._quant,
+        )
+
+    @property
+    def unit(self) -> str:
+        if self._unit is None:
+            return None
+
+        return self._unit.value
+
     @property
     def value(self):
-        if not any([self._side1.value, self._side2.value, self._side3.value]):
+        missing_side_value = not all(
+            [
+                getattr(self._side1, "value", None),
+                getattr(self._side2, "value", None),
+                getattr(self._side3, "value", None),
+            ]
+        )
+        missing_value = self._unit is None or self._value is None
+
+        if missing_side_value and missing_value:
             return None
 
-        return utils.NF.decimal(self._side1.M * self._side2.M * self._side3.M)
+        if not missing_value:
+            return self._value
+
+        return self._compute(self._side1.value * self._side2.value * self._side3.value)
 
     @property
-    def cubic_meter(self):
+    def l(self):
+        if self.value is None:
+            return None
+        if self._unit == VolumeUnit.m3:
+            return self._compute(self.value * 1000)
+        elif self._unit == VolumeUnit.i3:
+            return self._compute(self.value / 61.024)
+        elif self._unit == VolumeUnit.ft3:
+            return self._compute(self.value * 28.317)
+        if self._unit == VolumeUnit.cm3:
+            return self._compute(self.value / 1000)
+        else:
+            return self.value
+
+    @property
+    def m3(self):
+        if self.value is None:
+            return None
+        if self._unit == VolumeUnit.l:
+            return self._compute(self.value / 1000)
+        if self._unit == VolumeUnit.cm3:
+            return self._compute(self.value / 1e6)
+        elif self._unit == VolumeUnit.i3:
+            return self._compute(self.value / 61020)
+        elif self._unit == VolumeUnit.ft3:
+            return self._compute(self.value / 35.315)
+        else:
+            return self.value
+
+    @property
+    def i3(self):
+        if self.value is None:
+            return None
+        if self._unit == VolumeUnit.l:
+            return self._compute(self.value * 61.024)
+        if self._unit == VolumeUnit.m3:
+            return self._compute(self.value * 1000000)
+        elif self._unit == VolumeUnit.cm3:
+            return self._compute(self.value / 16.387)
+        elif self._unit == VolumeUnit.ft3:
+            return self._compute(self.value * 1728)
+        else:
+            return self.value
+
+    @property
+    def ft3(self):
+        if self.value is None:
+            return None
+        if self._unit == VolumeUnit.l:
+            return self._compute(self.value / 28.317)
+        if self._unit == VolumeUnit.m3:
+            return self._compute(self.value * 35.315)
+        elif self._unit == VolumeUnit.i3:
+            return self._compute(self.value / 1728)
+        elif self._unit == VolumeUnit.cm3:
+            return self._compute(self.value / 28320)
+        else:
+            return self.value
+
+    @property
+    def cm3(self):
         if self.value is None:
             return None
-        return utils.NF.decimal(self.value * 250)
+        if self._unit == VolumeUnit.l:
+            return self._compute(self.value * 1000)
+        if self._unit == VolumeUnit.m3:
+            return self._compute(self.value * 1e6)
+        elif self._unit == VolumeUnit.i3:
+            return self._compute(self.value * 16.387)
+        elif self._unit == VolumeUnit.ft3:
+            return self._compute(self.value * 28320)
+        else:
+            return self.value
+
+    @property
+    def cubic_meter(self):
+        return self.m3
+
+    def map(self, options: MeasurementOptionsType):
+        return Volume(
+            side1=self._side1,
+            side2=self._side2,
+            side3=self._side3,
+            value=self._value,
+            unit=self._unit,
+            options=options,
+        )
 
 
 class Girth:
@@ -306,6 +464,7 @@ class Weight:
         self._min_lb = options.min_lb
         self._min_kg = options.min_kg
         self._min_oz = options.min_oz
+        self._min_g = options.min_g
         self._quant = options.quant
 
     def __getitem__(self, item):
@@ -339,6 +498,10 @@ class Weight:
             return self._compute(self._value, self._min_kg)
         elif self._unit == WeightUnit.LB:
             return self._compute(self._value / 2.205, self._min_kg)
+        elif self._unit == WeightUnit.OZ:
+            return self._compute(self._value / 35.274, self._min_kg)
+        elif self._unit == WeightUnit.G:
+            return self._compute(self._value / 1000, self._min_kg)
 
         return None
 
@@ -350,6 +513,10 @@ class Weight:
             return self._compute(self._value, self._min_lb)
         elif self._unit == WeightUnit.KG:
             return self._compute(self._value * 2.205, self._min_lb)
+        elif self._unit == WeightUnit.OZ:
+            return self._compute(self._value / 16, self._min_lb)
+        elif self._unit == WeightUnit.G:
+            return self._compute(self._value / 453.6, self._min_lb)
 
         return None
 
@@ -357,10 +524,29 @@ class Weight:
     def OZ(self) -> typing.Optional[float]:
         if self._unit is None or self._value is None:
             return None
+        elif self._unit == WeightUnit.OZ:
+            return self._compute(self._value, self._min_oz)
         if self._unit == WeightUnit.LB:
             return self._compute(self._value * 16, self._min_oz)
         elif self._unit == WeightUnit.KG:
             return self._compute(self._value * 35.274, self._min_oz)
+        elif self._unit == WeightUnit.G:
+            return self._compute(self._value / 28.35, self._min_oz)
+
+        return None
+
+    @property
+    def G(self) -> typing.Optional[float]:
+        if self._unit is None or self._value is None:
+            return None
+        elif self._unit == WeightUnit.G:
+            return self._compute(self._value, self._min_g)
+        if self._unit == WeightUnit.LB:
+            return self._compute(self._value * 453.6, self._min_g)
+        elif self._unit == WeightUnit.KG:
+            return self._compute(self._value * 1000, self._min_g)
+        elif self._unit == WeightUnit.OZ:
+            return self._compute(self._value * 28.35, self._min_g)
 
         return None
 
@@ -419,6 +605,9 @@ class Products(typing.Iterable[Product]):
         weight_unit: str = None,
     ):
         self._items = [Product(item, weight_unit=weight_unit) for item in items]
+        self._weight_unit = (
+            weight_unit or self._items[0].weight_unit if any(self._items) else None
+        )
 
     def __len__(self) -> int:
         return len(self._items)
@@ -435,7 +624,30 @@ class Products(typing.Iterable[Product]):
 
     @property
     def value_amount(self):
-        return sum((item.value_amount or 0.0 for item in self._items), 0.0)
+        return sum(
+            (
+                item.value_amount * item.quantity
+                for item in self._items
+                if utils.NF.decimal(item.value_amount) is not None
+            ),
+            0.0,
+        )
+
+    @property
+    def weight(self) -> Weight:
+        return Weight(
+            sum([item.weight * item.quantity for item in self._items], 0.0),
+            self._weight_unit,
+        )
+
+    @property
+    def description(self) -> typing.Optional[str]:
+        descriptions = set([item.description for item in self._items])
+        description: typing.Optional[str] = utils.SF.concat_str(
+            *list(descriptions), join=True
+        )  # type:ignore
+
+        return description
 
 
 class Package:
@@ -449,13 +661,16 @@ class Package:
         package_option_type: typing.Type[utils.Enum] = utils.Enum,
         weight_unit: str = None,
         dimension_unit: str = None,
+        shipping_options_initializer: typing.Callable = None,
     ):
         self.parcel: models.Parcel = parcel
         self.preset: PackagePreset = template or PackagePreset()
 
-        self._options: "ShippingOptions" = ShippingOptions(
-            {**parcel.options, **getattr(options, "content", {})},
-            package_option_type,
+        _options = {**parcel.options, **getattr(options, "content", {})}
+        self._options: "ShippingOptions" = (
+            shipping_options_initializer(_options)
+            if shipping_options_initializer is not None
+            else ShippingOptions(_options, package_option_type)
         )
         self._dimension_unit = (
             dimension_unit or self.parcel.dimension_unit or self.preset.dimension_unit
@@ -523,7 +738,9 @@ class Package:
 
     @property
     def volume(self) -> Volume:
-        return Volume(self.width, self.length, self.height)
+        return Volume(
+            self.width, self.length, self.height, unit=self.dimension_unit.value
+        )
 
     @property
     def thickness(self) -> Dimension:
@@ -561,6 +778,17 @@ class Package:
 
         return Products(_items, self.weight_unit.value)
 
+    @property
+    def total_value(self) -> typing.Optional[float]:
+        if not any(self.parcel.items or []):
+            return None
+
+        return self.items.value_amount
+
+    @property
+    def reference_number(self) -> typing.Optional[str]:
+        return self.parcel.reference_number
+
 
 class Packages(typing.Iterable[Package]):
     """The parcel collection common processing helper"""
@@ -573,6 +801,7 @@ class Packages(typing.Iterable[Package]):
         max_weight: Weight = None,
         options: "ShippingOptions" = None,
         package_option_type: typing.Type[utils.Enum] = utils.Enum,
+        shipping_options_initializer: typing.Callable = None,
     ):
         self._compatible_units = self._compute_compatible_units(parcels, presets)
         self._options = options or ShippingOptions({}, package_option_type)
@@ -584,12 +813,14 @@ class Packages(typing.Iterable[Package]):
                 package_option_type=package_option_type,
                 weight_unit=self._compatible_units[0].value,
                 dimension_unit=self._compatible_units[1].value,
+                shipping_options_initializer=shipping_options_initializer,
             )
             for parcel in parcels
         ]
         self._required = required
         self._max_weight = max_weight
         self._package_option_type = package_option_type
+        self._shipping_options_initializer = shipping_options_initializer
 
         self.validate()
 
@@ -649,6 +880,24 @@ class Packages(typing.Iterable[Package]):
 
         return Weight(unit=unit, value=value)
 
+    @property
+    def volume(self) -> Volume:
+        if not any([pkg.volume.value for pkg in self._items]):
+            return Volume(value=None)
+
+        _, _dimension_unit = self._compatible_units
+        _volume_unit = VolumeUnit[_dimension_unit.name]
+        _total_volume = sum(
+            [
+                pkg.volume[_volume_unit.name]
+                for pkg in self._items
+                if pkg.volume is not None
+            ],
+            0.0,
+        )
+
+        return Volume(value=_total_volume, unit=_volume_unit)
+
     @property
     def package_type(self) -> str:
         return (
@@ -670,6 +919,15 @@ class Packages(typing.Iterable[Package]):
 
         return description
 
+    @property
+    def content(self) -> typing.Optional[str]:
+        contents = set([item.parcel.content for item in self._items])
+        content: typing.Optional[str] = utils.SF.concat_str(
+            *list(contents), join=True
+        )  # type:ignore
+
+        return content
+
     @property
     def options(self) -> "ShippingOptions":
         def merge_options(acc, pkg) -> dict:
@@ -699,6 +957,9 @@ class Packages(typing.Iterable[Package]):
             self._options.content,
         )
 
+        if self._shipping_options_initializer is not None:
+            return self._shipping_options_initializer(options)
+
         return ShippingOptions(options, self._package_option_type)
 
     @property
@@ -721,6 +982,15 @@ class Packages(typing.Iterable[Package]):
 
         return Products(_items, _weight_unit.value)
 
+    @property
+    def total_value(self) -> typing.Optional[float]:
+        if not any([_.total_value for _ in self._items]):
+            return None
+
+        return sum(
+            [pkg.total_value for pkg in self._items if pkg.total_value is not None], 0.0
+        )
+
     def validate(self, required: typing.List[str] = None, max_weight: Weight = None):
         required = required or self._required
         max_weight = max_weight or self._max_weight
@@ -760,6 +1030,7 @@ class Packages(typing.Iterable[Package]):
         max_weight: Weight = None,
         options: "ShippingOptions" = None,
         package_option_type: typing.Type[utils.Enum] = utils.Enum,
+        shipping_options_initializer: typing.Callable = None,
     ) -> typing.Union[typing.List[Package], "Packages"]:
         return typing.cast(
             typing.Union[typing.List[Package], Packages],
@@ -770,6 +1041,7 @@ class Packages(typing.Iterable[Package]):
                 max_weight,
                 options,
                 package_option_type,
+                shipping_options_initializer,
             ),
         )
 
@@ -796,6 +1068,7 @@ class Options:
                 _key = key
                 option_values[key] = _val
 
+        self._raw_options = options
         self._options = option_values
         self._option_list = self._filter(
             option_values, (items_filter or utils.identity)
@@ -837,20 +1110,34 @@ class ShippingOption(utils.Enum):
     """universal shipment options (special services)"""
 
     currency = utils.OptionEnum("currency")
+    is_return = utils.OptionEnum("is_return", bool)
     insurance = utils.OptionEnum("insurance", float)
     cash_on_delivery = utils.OptionEnum("COD", float)
     shipment_note = utils.OptionEnum("shipment_note")
-    shipment_date = utils.OptionEnum("shipment_date")
     dangerous_good = utils.OptionEnum("dangerous_good", bool)
     declared_value = utils.OptionEnum("declared_value", float)
     paperless_trade = utils.OptionEnum("paperless_trade", bool)
-    hold_at_location = utils.OptionEnum("hold_at_location", bool)
-    sms_notification = utils.OptionEnum("email_notification", bool)
+    sms_notification = utils.OptionEnum("sms_notification", bool)
     email_notification = utils.OptionEnum("email_notification", bool)
     email_notification_to = utils.OptionEnum("email_notification_to")
     signature_confirmation = utils.OptionEnum("signature_confirmation", bool)
+    saturday_delivery = utils.OptionEnum("saturday_delivery", bool)
+    sunday_delivery = utils.OptionEnum("sunday_delivery", bool)
     doc_files = utils.OptionEnum("doc_files", utils.DP.to_dict)
     doc_references = utils.OptionEnum("doc_references", utils.DP.to_dict)
+    hold_at_location = utils.OptionEnum("hold_at_location", bool)
+    hold_at_location_address = utils.OptionEnum(
+        "hold_at_location_address",
+        functools.partial(utils.DP.to_object, models.Address),
+    )
+    shipper_instructions = utils.OptionEnum("shipper_instructions")
+    recipient_instructions = utils.OptionEnum("recipient_instructions")
+
+    """TODO: dreprecate these"""
+    shipment_date = utils.OptionEnum("shipment_date")
+
+    """TODO: standardize to these"""
+    shipping_date = utils.OptionEnum("shipping_date")  # format: %Y-%m-%dT%H:%M
 
 
 class ShippingOptions(Options):
@@ -896,8 +1183,22 @@ class ShippingOptions(Options):
 
     @property
     def shipment_date(self) -> utils.OptionEnum:
+        # Check if shipment_date is not defined and fallback to shipping_date
+        if not self[ShippingOption.shipment_date.name].state:
+            return utils.OptionEnum(
+                "shipment_date",
+                str,
+                utils.DF.fdate(
+                    self._raw_options.get("shipping_date"), "%Y-%m-%dT%H:%M"
+                ),
+            )
+
         return self[ShippingOption.shipment_date.name]
 
+    @property
+    def shipping_date(self) -> utils.OptionEnum:
+        return self[ShippingOption.shipping_date.name]
+
     @property
     def signature_confirmation(self) -> utils.OptionEnum:
         return self[ShippingOption.signature_confirmation.name]
@@ -922,19 +1223,63 @@ class ShippingOptions(Options):
     def shipment_note(self) -> utils.OptionEnum:
         return self[ShippingOption.shipment_note.name]
 
+    @property
+    def shipper_instructions(self) -> utils.OptionEnum:
+        return self[ShippingOption.shipper_instructions.name]
+
+    @property
+    def recipient_instructions(self) -> utils.OptionEnum:
+        return self[ShippingOption.recipient_instructions.name]
+
 
 class CustomsOption(utils.Enum):
     """common shipment customs identifiers"""
 
     aes = utils.OptionEnum("aes")
+    ioss = utils.OptionEnum("ioss")
     eel_pfc = utils.OptionEnum("eel_pfc")
-    nip_number = utils.OptionEnum("eori_number")
+    nip_number = utils.OptionEnum("nip_number")
     eori_number = utils.OptionEnum("eori_number")
     license_number = utils.OptionEnum("license_number")
     certificate_number = utils.OptionEnum("certificate_number")
     vat_registration_number = utils.OptionEnum("vat_registration_number")
 
 
+class CustomsOptions(Options):
+    """The options common processing helper"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs, base_option_type=CustomsOption)
+
+    @property
+    def aes(self) -> utils.OptionEnum:
+        return self[CustomsOption.aes.name]
+
+    @property
+    def eel_pfc(self) -> utils.OptionEnum:
+        return self[CustomsOption.eel_pfc.name]
+
+    @property
+    def nip_number(self) -> utils.OptionEnum:
+        return self[CustomsOption.nip_number.name]
+
+    @property
+    def eori_number(self) -> utils.OptionEnum:
+        return self[CustomsOption.eori_number.name]
+
+    @property
+    def license_number(self) -> utils.OptionEnum:
+        return self[CustomsOption.license_number.name]
+
+    @property
+    def certificate_number(self) -> utils.OptionEnum:
+        return self[CustomsOption.certificate_number.name]
+
+    @property
+    def vat_registration_number(self) -> utils.OptionEnum:
+        return self[CustomsOption.vat_registration_number.name]
+
+
 class CustomsInfo(models.Customs):
     """The customs info processing helper"""
 
@@ -948,10 +1293,9 @@ class CustomsInfo(models.Customs):
         recipient: typing.Optional[models.Address] = None,
     ):
         _customs = customs or default_to
-        options = Options(
+        options = CustomsOptions(
             getattr(_customs, "options", None) or {},
             option_type=option_type,
-            base_option_type=CustomsOption,
         )
 
         self._customs = _customs
@@ -974,7 +1318,7 @@ class CustomsInfo(models.Customs):
         return self._customs is not None
 
     @property
-    def duty(self) -> typing.Optional[models.Duty]:  # type:ignore
+    def duty(self) -> models.Duty:  # type:ignore
         return getattr(self._customs, "duty", None) or models.Duty()
 
     @property
@@ -1116,7 +1460,7 @@ class ComputedAddress(models.Address):
 
     @property
     def country_name(self):
-        return Country[self.address.country_code].value
+        return Country.map(self.address.country_code).value
 
     @property
     def address_line(self) -> str:
@@ -1151,7 +1495,6 @@ class ComputedAddress(models.Address):
                 join=True,
             ),
         )
-        return self.address.address_line1.replace(self.street_number, "").strip()
 
     @property
     def tax_id(self) -> typing.Optional[str]:
@@ -1184,6 +1527,20 @@ class ComputedAddress(models.Address):
             self.address, "company_name", None
         )
 
+    @property
+    def first_name(self) -> typing.Optional[str]:
+        if self.address.person_name is None:
+            return None
+
+        return self.address.person_name.split(" ")[0]
+
+    @property
+    def last_name(self) -> typing.Optional[str]:
+        if self.address.person_name is None:
+            return None
+
+        return self.address.person_name.split(" ")[-1]
+
     def _compute_address_line(self, join: bool = True) -> typing.Optional[str]:
         if any(
             [
@@ -1202,7 +1559,7 @@ class ComputedAddress(models.Address):
     def _compute_street_number(self):
         _value = getattr(self.address, "street_number", None)
 
-        if _value is None:
+        if _value is None and self.address:
             words = self.address.address_line1.split(" ")
 
             if any(_.isdigit() for _ in words[0]):
@@ -1231,16 +1588,20 @@ class ComputedDocumentFile(models.DocumentFile):
 
 
 class TrackingStatus(utils.Enum):
+    pending = ["pending"]
     on_hold = ["on_hold"]
+    cancelled = ["cancelled"]
     delivered = ["delivered"]
     in_transit = ["in_transit"]
     delivery_failed = ["delivery_failed"]
     delivery_delayed = ["delivery_delayed"]
     out_for_delivery = ["out_for_delivery"]
     ready_for_pickup = ["ready_for_pickup"]
+    return_to_sender = ["return_to_sender"]
+    unknown = ["unknown"]
 
 
-def create_enum(name, values):
+def create_enum(name, values) -> utils.Enum:
     return utils.Enum(name, values)  # type: ignore
 
 
@@ -1393,6 +1754,7 @@ class Currency(utils.Enum):
 
 
 class Country(utils.Enum):
+    AC = "Ascension Island"
     AD = "Andorra"
     AE = "United Arab Emirates"
     AF = "Afghanistan"
@@ -1627,9 +1989,17 @@ class Country(utils.Enum):
     ZA = "South Africa"
     ZM = "Zambia"
     ZW = "Zimbabwe"
+    # Adding missing country codes
+    EH = "Western Sahara"
+    IM = "Isle of Man"
+    BL = "Saint Barthelemy"
+    MF = "Saint Martin"
+    SX = "Sint Maarten"
+    XK = "Kosovo"
 
 
 class CountryCurrency(utils.Enum):
+    AC = "USD"
     AD = "EUR"
     AE = "AED"
     AF = "USD"
@@ -2357,3 +2727,240 @@ class EUCountry(utils.Enum):
     SK = "Slovakia"
     ES = "Spain"
     SE = "Sweden"
+
+
+class CountryCode(utils.Enum):
+    AD = "AND"  # Andorra
+    AE = "ARE"  # United Arab Emirates
+    AF = "AFG"  # Afghanistan
+    AG = "ATG"  # Antigua
+    AI = "AIA"  # Anguilla
+    AL = "ALB"  # Albania
+    AM = "ARM"  # Armenia
+    AN = "ANT"  # Netherlands Antilles
+    AO = "AGO"  # Angola
+    AR = "ARG"  # Argentina
+    AS = "ASM"  # American Samoa
+    AT = "AUT"  # Austria
+    AU = "AUS"  # Australia
+    AW = "ABW"  # Aruba
+    AZ = "AZE"  # Azerbaijan
+    BA = "BIH"  # Bosnia And Herzegovina
+    BB = "BRB"  # Barbados
+    BD = "BGD"  # Bangladesh
+    BE = "BEL"  # Belgium
+    BF = "BFA"  # Burkina Faso
+    BG = "BGR"  # Bulgaria
+    BH = "BHR"  # Bahrain
+    BI = "BDI"  # Burundi
+    BJ = "BEN"  # Benin
+    BM = "BMU"  # Bermuda
+    BN = "BRN"  # Brunei
+    BO = "BOL"  # Bolivia
+    BR = "BRA"  # Brazil
+    BS = "BHS"  # Bahamas
+    BT = "BTN"  # Bhutan
+    BW = "BWA"  # Botswana
+    BY = "BLR"  # Belarus
+    BZ = "BLZ"  # Belize
+    CA = "CAN"  # Canada
+    CD = "COD"  # Congo, Democratic Republic of the
+    CF = "CAF"  # Central African Republic
+    CG = "COG"  # Congo
+    CH = "CHE"  # Switzerland
+    CI = "CIV"  # Cote D Ivoire
+    CK = "COK"  # Cook Islands
+    CL = "CHL"  # Chile
+    CM = "CMR"  # Cameroon
+    CN = "CHN"  # China
+    CO = "COL"  # Colombia
+    CR = "CRI"  # Costa Rica
+    CU = "CUB"  # Cuba
+    CV = "CPV"  # Cape Verde
+    CY = "CYP"  # Cyprus
+    CZ = "CZE"  # Czech Republic
+    DE = "DEU"  # Germany
+    DJ = "DJI"  # Djibouti
+    DK = "DNK"  # Denmark
+    DM = "DMA"  # Dominica
+    DO = "DOM"  # Dominican Republic
+    DZ = "DZA"  # Algeria
+    EC = "ECU"  # Ecuador
+    EE = "EST"  # Estonia
+    EG = "EGY"  # Egypt
+    ER = "ERI"  # Eritrea
+    ES = "ESP"  # Spain
+    ET = "ETH"  # Ethiopia
+    FI = "FIN"  # Finland
+    FJ = "FJI"  # Fiji
+    FK = "FLK"  # Falkland Islands
+    FM = "FSM"  # Micronesia, Federated States Of
+    FO = "FRO"  # Faroe Islands
+    FR = "FRA"  # France
+    GA = "GAB"  # Gabon
+    GB = "GBR"  # United Kingdom
+    GD = "GRD"  # Grenada
+    GE = "GEO"  # Georgia
+    GF = "GUF"  # French Guyana
+    GG = "GGY"  # Guernsey
+    GH = "GHA"  # Ghana
+    GI = "GIB"  # Gibraltar
+    GL = "GRL"  # Greenland
+    GM = "GMB"  # Gambia
+    GN = "GIN"  # Guinea Republic
+    GP = "GLP"  # Guadeloupe
+    GQ = "GNQ"  # Guinea-equatorial
+    GR = "GRC"  # Greece
+    GT = "GTM"  # Guatemala
+    GU = "GUM"  # Guam
+    GW = "GNB"  # Guinea-bissau
+    GY = "GUY"  # Guyana (british)
+    HK = "HKG"  # Hong Kong
+    HN = "HND"  # Honduras
+    HR = "HRV"  # Croatia
+    HT = "HTI"  # Haiti
+    HU = "HUN"  # Hungary
+    IC = "ICA"  # Canary Islands
+    ID = "IDN"  # Indonesia
+    IE = "IRL"  # Ireland
+    IL = "ISR"  # Israel
+    IN = "IND"  # India
+    IQ = "IRQ"  # Iraq
+    IR = "IRN"  # Iran
+    IS = "ISL"  # Iceland
+    IT = "ITA"  # Italy
+    JE = "JEY"  # Jersey
+    JM = "JAM"  # Jamaica
+    JO = "JOR"  # Jordan
+    JP = "JPN"  # Japan
+    KE = "KEN"  # Kenya
+    KG = "KGZ"  # Kyrgyzstan
+    KH = "KHM"  # Cambodia
+    KI = "KIR"  # Kiribati
+    KM = "COM"  # Comoros
+    KN = "KNA"  # St. Kitts
+    KP = "PRK"  # Korea, The D.p.r Of (north K.)
+    KR = "KOR"  # Korea, Republic of (South Korea)
+    KV = "XKX"  # Kosovo
+    KW = "KWT"  # Kuwait
+    KY = "CYM"  # Cayman Islands
+    KZ = "KAZ"  # Kazakhstan
+    LA = "LAO"  # Lao Peoples Democratic Republic
+    LB = "LBN"  # Lebanon
+    LC = "LCA"  # St. Lucia
+    LI = "LIE"  # Liechtenstein
+    LK = "LKA"  # Sri Lanka
+    LR = "LBR"  # Liberia
+    LS = "LSO"  # Lesotho
+    LT = "LTU"  # Lithuania
+    LU = "LUX"  # Luxembourg
+    LV = "LVA"  # Latvia
+    LY = "LBY"  # Libya
+    MA = "MAR"  # Morocco
+    MC = "MCO"  # Monaco
+    MD = "MDA"  # Moldova
+    ME = "MNE"  # Montenegro
+    MG = "MDG"  # Madagascar
+    MH = "MHL"  # Marshall Islands
+    MK = "MKD"  # Macedonia
+    ML = "MLI"  # Mali
+    MM = "MMR"  # Myanmar
+    MN = "MNG"  # Mongolia
+    MO = "MAC"  # Macau
+    MP = "MNP"  # Nothern Mariana Islands, Commonwealth of
+    MQ = "MTQ"  # Martinique
+    MR = "MRT"  # Mauritania
+    MS = "MSR"  # Montserrat
+    MT = "MLT"  # Malta
+    MU = "MUS"  # Mauritius
+    MV = "MDV"  # Maldives
+    MW = "MWI"  # Malawi
+    MX = "MEX"  # Mexico
+    MY = "MYS"  # Malaysia
+    MZ = "MOZ"  # Mozambique
+    NA = "NAM"  # Namibia
+    NC = "NCL"  # New Caledonia
+    NE = "NER"  # Niger
+    NG = "NGA"  # Nigeria
+    NI = "NIC"  # Nicaragua
+    NL = "NLD"  # Netherlands
+    NO = "NOR"  # Norway
+    NP = "NPL"  # Nepal
+    NR = "NRU"  # Nauru
+    NU = "NIU"  # Niue
+    NZ = "NZL"  # New Zealand
+    OM = "OMN"  # Oman
+    PA = "PAN"  # Panama
+    PE = "PER"  # Peru
+    PF = "PYF"  # Tahiti
+    PG = "PNG"  # Papua New Guinea
+    PH = "PHL"  # Philippines
+    PK = "PAK"  # Pakistan
+    PL = "POL"  # Poland
+    PR = "PRI"  # Puerto Rico
+    PT = "PRT"  # Portugal
+    PW = "PLW"  # Palau
+    PY = "PRY"  # Paraguay
+    QA = "QAT"  # Qatar
+    RE = "REU"  # Reunion
+    RO = "ROU"  # Romania
+    RS = "SRB"  # Serbia
+    RU = "RUS"  # Russia
+    RW = "RWA"  # Rwanda
+    SA = "SAU"  # Saudi Arabia
+    SB = "SLB"  # Solomon Islands
+    SC = "SYC"  # Seychelles
+    SD = "SDN"  # Sudan
+    SE = "SWE"  # Sweden
+    SG = "SGP"  # Singapore
+    SH = "SHN"  # Saint Helena
+    SI = "SVN"  # Slovenia
+    SK = "SVK"  # Slovakia
+    SL = "SLE"  # Sierra Leone
+    SM = "SMR"  # San Marino
+    SN = "SEN"  # Senegal
+    SO = "SOM"  # Somalia
+    SR = "SUR"  # Suriname
+    SS = "SSD"  # South Sudan
+    ST = "STP"  # Sao Tome And Principe
+    SV = "SLV"  # El Salvador
+    SY = "SYR"  # Syria
+    SZ = "SWZ"  # Swaziland
+    TC = "TCA"  # Turks And Caicos Islands
+    TD = "TCD"  # Chad
+    TG = "TGO"  # Togo
+    TH = "THA"  # Thailand
+    TJ = "TJK"  # Tajikistan
+    TL = "TLS"  # Timor Leste
+    TN = "TUN"  # Tunisia
+    TO = "TON"  # Tonga
+    TR = "TUR"  # Turkey
+    TT = "TTO"  # Trinidad And Tobago
+    TV = "TUV"  # Tuvalu
+    TW = "TWN"  # Taiwan
+    TZ = "TZA"  # Tanzania
+    UA = "UKR"  # Ukraine
+    UG = "UGA"  # Uganda
+    US = "USA"  # United States
+    UY = "URY"  # Uruguay
+    UZ = "UZB"  # Uzbekistan
+    VA = "VAT"  # Vatican City
+    VC = "VCT"  # St. Vincent
+    VE = "VEN"  # Venezuela
+    VG = "VGB"  # British Virgin Islands
+    VI = "VIR"  # U.S. Virgin Islands
+    VN = "VNM"  # Vietnam
+    VU = "VUT"  # Vanuatu
+    WS = "WSM"  # Samoa
+    XB = "BES"  # Bonaire
+    XC = "CUW"  # Curacao
+    XE = "EUX"  # St. Eustatius
+    XM = "SXM"  # St. Maarten
+    XN = "KNA"  # Nevis
+    XS = "SOM"  # Somaliland, Rep Of (north Somalia)
+    XY = "BLM"  # St. Barthelemy
+    YE = "YEM"  # Yemen
+    YT = "MYT"  # Mayotte
+    ZA = "ZAF"  # South Africa
+    ZM = "ZMB"  # Zambia
+    ZW = "ZWE"  # Zimbabwe