producteca 2.0.14__py3-none-any.whl → 2.0.16__py3-none-any.whl

producteca/products/tests/test_products.py

@@ -13,6 +13,33 @@ class TestProduct(unittest.TestCase):
             code="TEST001",
             category="Test"
         )
+        self.product_to_create_payload = {
+            "sku": "9817234",
+            "code": "871234",
+            "name": "Hola test",
+            "buyingPrice": 0,
+            "deals": [
+                {
+                "campaign": "string",
+                "regularPrice": 0,
+                "dealPrice": 0
+                }
+            ],
+                "prices": [
+                {
+                "amount": 10,
+                "currency": "Local",
+                "priceList": "Default"
+                }
+            ],
+                "stocks": [
+                    {
+                    "quantity": 2,
+                    "availableQuantity": 2,
+                    "warehouse": "Default"
+                    }
+                ],
+            }
 
     @patch('requests.post')
     def test_create_product_success(self, mock_post):
@@ -22,7 +49,7 @@ class TestProduct(unittest.TestCase):
         mock_response.json.return_value = self.test_product.model_dump()
         mock_post.return_value = mock_response
 
-        response = self.client.Product(**self.test_product.model_dump()).create()
+        response = self.client.Product(**self.test_product.model_dump()).synchronize(self.product_to_create_payload)
         
         self.assertEqual(response.sku, "TEST001")
 
@@ -34,17 +61,17 @@ class TestProduct(unittest.TestCase):
         mock_post.return_value = mock_response
 
         with self.assertRaises(Exception):
-            self.client.Product.create()
+            self.client.Product.synchronize(self.product_to_create_payload)
 
     @patch('requests.post')
     def test_update_product_success(self, mock_post):
-        # Mock successful update
+        payload = self.product_to_create_payload
         mock_response = Mock()
         mock_response.status_code = 200
         mock_response.json.return_value = self.test_product.model_dump()
         mock_post.return_value = mock_response
 
-        response = self.client.Product(**self.test_product.model_dump()).update()
+        response = self.client.Product(**self.test_product.model_dump()).synchronize(payload)
         
         self.assertEqual(response.name, "Test Product")
 
@@ -65,28 +92,86 @@ class TestProduct(unittest.TestCase):
         # Mock get bundle response
         mock_response = Mock()
         mock_response.status_code = 200
-        test_prod = self.test_product.model_dump()
-        test_prod.update({"sku": "TEST001", "bundles": []})
+        test_prod = {
+                "results": [
+                    {
+                    "companyId": 0,
+                    "productId": 0,
+                    "variations": [
+                        {
+                        "variationId": 0,
+                        "components": [
+                            {
+                            "quantity": 0,
+                            "variationId": 0,
+                            "productId": 0
+                            }
+                        ]
+                        }
+                    ],
+                    "id": "string"
+                    }
+                ],
+                "count": 0
+                }
         mock_response.json.return_value = test_prod
         mock_get.return_value = mock_response
 
         product = self.client.Product.get_bundle(1)
         
-        self.assertEqual(product.sku, "TEST001")
+        self.assertEqual(product.count, 0)
 
     @patch('requests.get')
     def test_get_ml_integration(self, mock_get):
         # Mock ML integration response
         mock_response = Mock()
         mock_response.status_code = 200
-        test_prod = self.test_product.model_dump()
-        test_prod.update({"sku": "TEST001", "integrations": []})
-        mock_response.json.return_value = test_prod
+        meli_product = {
+            "hasCustomShippingCosts": True,
+            "productId": 0,
+            "shipping": {
+                "localPickup": True,
+                "mode": "string",
+                "freeShipping": True,
+                "freeShippingCost": 0,
+                "mandatoryFreeShipping": True,
+                "freeShippingMethod": "string"
+            },
+            "mShopsShipping": {
+                "enabled": True
+            },
+            "addFreeShippingCostToPrice": True,
+            "category": {
+                "meliId": "string",
+                "acceptsMercadoenvios": True,
+                "suggest": True,
+                "fixed": True
+            },
+            "attributeCompletion": {
+                "productIdentifierStatus": "Complete",
+                "dataSheetStatus": "Complete",
+                "status": "Complete",
+                "count": 0,
+                "total": 0
+            },
+            "catalogProducts": [
+                "string"
+            ],
+            "warranty": "string",
+            "domain": "string",
+            "listingTypeId": "GoldSpecial",
+            "catalogProductsStatus": "Unlinked",
+            "tags": [
+                "string"
+            ]
+            }
+        
+        mock_response.json.return_value = meli_product
         mock_get.return_value = mock_response
 
         product = self.client.Product.get_ml_integration(1)
         
-        self.assertEqual(product.sku, "TEST001")
+        self.assertEqual(product.listing_type_id, "GoldSpecial")
 
 
 if __name__ == '__main__':

producteca/products/tests/test_search_products.py

@@ -34,8 +34,8 @@ class TestSearchProduct(unittest.TestCase):
             "results": [{
                 "@search.score": 1.0,
                 "id": 123,
-                "product_id": 456,
-                "company_id": 789,
+                "productId": 456,
+                "companyId": 789,
                 "name": "Test Product",
                 "code": "TEST-001",
                 "skus": ["SKU001"],
@@ -47,18 +47,18 @@ class TestSearchProduct(unittest.TestCase):
                     "quantity": 10,
                     "reserved": 0
                 }],
-                "warehouses_with_stock": ["Main"],
-                "total_stock": 10,
-                "has_pictures": True,
-                "buying_price": 100.0,
+                "warehousesWithStock": ["Main"],
+                "totalStock": 10,
+                "hasPictures": True,
+                "buyingPrice": 100.0,
                 "prices": [{
-                    "price_list_id": 1,
-                    "price_list": "Default",
+                    "priceListId": 1,
+                    "priceList": "Default",
                     "amount": 200.0,
                     "currency": "USD"
                 }],
-                "integration_ids": ["INT001"],
-                "integration_apps": ["APP1"],
+                "integrationIds": ["INT001"],
+                "integrationApps": ["APP1"],
                 "integrations": [],
                 "campaigns": [],
                 "app": None,

producteca/sales_orders/sales_orders.py

@@ -11,56 +11,56 @@ _logger = logging.getLogger(__name__)
 
 
 class SaleOrderLocation(BaseModel):
-    streetName: Optional[str] = None
-    streetNumber: Optional[str] = None
-    addressNotes: Optional[str] = None
+    street_name: Optional[str] = Field(None, alias="streetName")
+    street_number: Optional[str] = Field(None, alias="streetNumber") 
+    address_notes: Optional[str] = Field(None, alias="addressNotes")
     state: Optional[str] = None
     city: Optional[str] = None
     neighborhood: Optional[str] = None
-    zipCode: Optional[str] = None
+    zip_code: Optional[str] = Field(None, alias="zipCode")
 
 
 class SaleOrderBillingInfo(BaseModel):
-    docType: Optional[str] = None
-    docNumber: Optional[str] = None
-    streetName: Optional[str] = None
-    streetNumber: Optional[str] = None
+    doc_type: Optional[str] = Field(None, alias="docType")
+    doc_number: Optional[str] = Field(None, alias="docNumber")
+    street_name: Optional[str] = Field(None, alias="streetName")
+    street_number: Optional[str] = Field(None, alias="streetNumber")
     comment: Optional[str] = None
-    zipCode: Optional[str] = None
+    zip_code: Optional[str] = Field(None, alias="zipCode")
     city: Optional[str] = None
     state: Optional[str] = None
-    stateRegistration: Optional[str] = None
-    taxPayerType: Optional[str] = None
-    firstName: Optional[str] = None
-    lastName: Optional[str] = None
-    businessName: Optional[str] = None
+    state_registration: Optional[str] = Field(None, alias="stateRegistration")
+    tax_payer_type: Optional[str] = Field(None, alias="taxPayerType")
+    first_name: Optional[str] = Field(None, alias="firstName")
+    last_name: Optional[str] = Field(None, alias="lastName")
+    business_name: Optional[str] = Field(None, alias="businessName")
 
 
 class SaleOrderProfile(BaseModel):
     app: int
-    integrationId: str
+    integration_id: str = Field(alias="integrationId")
     nickname: Optional[str] = None
 
 
 class SaleOrderContact(BaseModel):
     id: int
     name: str
-    contactPerson: Optional[str] = None
+    contact_person: Optional[str] = Field(None, alias="contactPerson")
     mail: Optional[str] = None
-    phoneNumber: Optional[str] = None
-    taxId: Optional[str] = None
+    phone_number: Optional[str] = Field(None, alias="phoneNumber")
+    tax_id: Optional[str] = Field(None, alias="taxId")
     location: Optional[SaleOrderLocation] = None
     notes: Optional[str] = None
     type: Optional[str] = None
-    priceList: Optional[str] = None
-    priceListId: Optional[str] = None
+    price_list: Optional[str] = Field(None, alias="priceList")
+    price_list_id: Optional[str] = Field(None, alias="priceListId")
     profile: Optional[SaleOrderProfile] = None
-    billingInfo: Optional[SaleOrderBillingInfo] = None
+    billing_info: Optional[SaleOrderBillingInfo] = Field(None, alias="billingInfo")
 
 
 class SaleOrderIntegrationId(BaseModel):
-    alternateId: Optional[str] = None
-    integrationId: str
+    alternate_id: Optional[str] = Field(None, alias="alternateId")
+    integration_id: str = Field(alias="integrationId")
     app: int
 
 
@@ -70,11 +70,11 @@ class SaleOrderVariationPicture(BaseModel):
 
 
 class SaleOrderVariationStock(BaseModel):
-    warehouseId: Optional[int] = None
+    warehouse_id: Optional[int] = Field(None, alias="warehouseId")
     warehouse: str
     quantity: int
     reserved: int
-    lastModified: Optional[str] = None
+    last_modified: Optional[str] = Field(None, alias="lastModified")
     available: int
 
 
@@ -84,13 +84,13 @@ class SaleOrderVariationAttribute(BaseModel):
 
 
 class SaleOrderVariation(BaseModel):
-    supplierCode: Optional[str] = None
+    supplier_code: Optional[str] = Field(None, alias="supplierCode")
     pictures: Optional[List[SaleOrderVariationPicture]] = None
     stocks: Optional[List[SaleOrderVariationStock]] = None
-    integrationId: Optional[int] = None
-    attributesHash: Optional[str] = None
-    primaryColor: Optional[str] = None
-    secondaryColor: Optional[str] = None
+    integration_id: Optional[int] = Field(None, alias="integrationId")
+    attributes_hash: Optional[str] = Field(None, alias="attributesHash")
+    primary_color: Optional[str] = Field(None, alias="primaryColor")
+    secondary_color: Optional[str] = Field(None, alias="secondaryColor")
     size: Optional[str] = None
     thumbnail: Optional[str] = None
     attributes: Optional[List[SaleOrderVariationAttribute]] = None
@@ -113,11 +113,11 @@ class SaleOrderConversation(BaseModel):
 
 class SaleOrderLine(BaseModel):
     price: float
-    originalPrice: Optional[float] = None
-    transactionFee: Optional[float] = None
+    original_price: Optional[float] = Field(None, alias="originalPrice")
+    transaction_fee: Optional[float] = Field(None, alias="transactionFee")
     product: SaleOrderProduct
     variation: SaleOrderVariation
-    orderVariationIntegrationId: Optional[str] = None
+    order_variation_integration_id: Optional[str] = Field(None, alias="orderVariationIntegrationId")
     quantity: int
     conversation: Optional[SaleOrderConversation] = None
     reserved: Optional[int] = None
@@ -125,38 +125,38 @@ class SaleOrderLine(BaseModel):
 
 
 class SaleOrderCard(BaseModel):
-    paymentNetwork: Optional[str] = None
-    firstSixDigits: Optional[int] = None
-    lastFourDigits: Optional[int] = None
-    cardholderIdentificationNumber: Optional[str] = None
-    cardholderIdentificationType: Optional[str] = None
-    cardholderName: Optional[str] = None
+    payment_network: Optional[str] = Field(None, alias="paymentNetwork")
+    first_six_digits: Optional[int] = Field(None, alias="firstSixDigits")
+    last_four_digits: Optional[int] = Field(None, alias="lastFourDigits")
+    cardholder_identification_number: Optional[str] = Field(None, alias="cardholderIdentificationNumber")
+    cardholder_identification_type: Optional[str] = Field(None, alias="cardholderIdentificationType")
+    cardholder_name: Optional[str] = Field(None, alias="cardholderName")
 
 
 class SaleOrderPaymentIntegration(BaseModel):
-    integrationId: str
+    integration_id: str = Field(alias="integrationId")
     app: int
 
 
 class SaleOrderPayment(BaseModel):
     date: Optional[str] = None
     amount: float
-    couponAmount: Optional[float] = None
+    coupon_amount: Optional[float] = Field(None, alias="couponAmount")
     status: Optional[str] = None
     method: Optional[str] = None
     integration: Optional[SaleOrderPaymentIntegration] = None
-    transactionFee: Optional[float] = None
+    transaction_fee: Optional[float] = Field(None, alias="transactionFee")
     installments: Optional[int] = None
     card: Optional[SaleOrderCard] = None
     notes: Optional[str] = None
-    authorizationCode: Optional[str] = None
-    hasCancelableStatus: Optional[bool] = None
+    authorization_code: Optional[str] = Field(None, alias="authorizationCode")
+    has_cancelable_status: Optional[bool] = Field(None, alias="hasCancelableStatus")
     id: Optional[int] = None
 
 
 class SaleOrderShipmentMethod(BaseModel):
-    trackingNumber: Optional[str] = None
-    trackingUrl: Optional[str] = None
+    tracking_number: Optional[str] = Field(None, alias="trackingNumber")
+    tracking_url: Optional[str] = Field(None, alias="trackingUrl")
     courier: Optional[str] = None
     mode: Optional[str] = None
     cost: Optional[float] = None
@@ -173,7 +173,7 @@ class SaleOrderShipmentProduct(BaseModel):
 
 class SaleOrderShipmentIntegration(BaseModel):
     app: int
-    integrationId: str
+    integration_id: str = Field(alias="integrationId")
     status: str
     id: int
 
@@ -187,70 +187,101 @@ class SaleOrderShipment(BaseModel):
     id: int
 
 
-class SaleOrderInvoiceIntegration(BaseModel):
-    id: Optional[int] = None
-    integrationId: Optional[str] = None
-    app: Optional[int] = None
-    createdAt: Optional[str] = None
-    documentUrl: Optional[str] = None
-    xmlUrl: Optional[str] = None
-    decreaseStock: Optional[bool] = None
+class SaleOrderInvoiceIntegrationAbstract(BaseModel):
+    id: int
+    integration_id: str = Field(alias="integrationId")
+    app: int
+    created_at: str = Field(alias="createdAt")
+    decrease_stock: bool = Field(alias="decreaseStock")
+
+
+class SaleOrderInvoiceIntegration(SaleOrderInvoiceIntegrationAbstract):
+    document_url: Optional[str] = Field(None, alias="documentUrl")
+    xml_url: Optional[str] = Field(None, alias="xmlUrl")
+
+
+class SaleOrderInvoiceIntegrationPut(SaleOrderInvoiceIntegrationAbstract):
+    document_url: str = Field(alias="documentUrl")
+    xml_url: str = Field(alias="xmlUrl")
 
 
 class SaleOrder(BaseModel):
     tags: Optional[List[str]] = None
     integrations: Optional[List[SaleOrderIntegrationId]] = None
-    invoiceIntegration: Optional[SaleOrderInvoiceIntegration] = None
+    invoice_integration: SaleOrderInvoiceIntegration = Field(alias="invoiceIntegration")
     channel: Optional[str] = None
-    piiExpired: Optional[bool] = None
+    pii_expired: Optional[bool] = Field(None, alias="piiExpired")
     contact: Optional[SaleOrderContact] = None
     lines: Optional[List[SaleOrderLine]] = None
     warehouse: Optional[str] = None
-    warehouseId: Optional[int] = None
-    warehouseIntegration: Optional[str] = None
-    pickUpStore: Optional[str] = None
+    warehouse_id: Optional[int] = Field(None, alias="warehouseId")
+    warehouse_integration: Optional[str] = Field(None, alias="warehouseIntegration")
+    pick_up_store: Optional[str] = Field(None, alias="pickUpStore")
     payments: Optional[List[SaleOrderPayment]] = None
     shipments: Optional[List[SaleOrderShipment]] = None
     amount: Optional[float] = None
-    shippingCost: Optional[float] = None
-    financialCost: Optional[float] = None
-    paidApproved: Optional[float] = None
-    paymentStatus: Optional[str] = None
-    deliveryStatus: Optional[str] = None
-    paymentFulfillmentStatus: Optional[str] = None
-    deliveryFulfillmentStatus: Optional[str] = None
-    deliveryMethod: Optional[str] = None
-    paymentTerm: Optional[str] = None
+    shipping_cost: Optional[float] = Field(None, alias="shippingCost")
+    financial_cost: Optional[float] = Field(None, alias="financialCost")
+    paid_approved: Optional[float] = Field(None, alias="paidApproved")
+    payment_status: Optional[str] = Field(None, alias="paymentStatus")
+    delivery_status: Optional[str] = Field(None, alias="deliveryStatus")
+    payment_fulfillment_status: Optional[str] = Field(None, alias="paymentFulfillmentStatus")
+    delivery_fulfillment_status: Optional[str] = Field(None, alias="deliveryFulfillmentStatus")
+    delivery_method: Optional[str] = Field(None, alias="deliveryMethod")
+    payment_term: Optional[str] = Field(None, alias="paymentTerm")
     currency: Optional[str] = None
-    customId: Optional[str] = None
-    isOpen: Optional[bool] = None
-    isCanceled: Optional[bool] = None
-    cartId: Optional[str] = None
+    custom_id: Optional[str] = Field(None, alias="customId")
+    is_open: Optional[bool] = Field(None, alias="isOpen")
+    is_canceled: Optional[bool] = Field(None, alias="isCanceled")
+    cart_id: Optional[str] = Field(None, alias="cartId")
     draft: Optional[bool] = None
-    promiseDeliveryDate: Optional[str] = None
-    promiseDispatchDate: Optional[str] = None
-    hasAnyShipments: Optional[bool] = None
-    hasAnyPayments: Optional[bool] = None
+    promise_delivery_date: Optional[str] = Field(None, alias="promiseDeliveryDate")
+    promise_dispatch_date: Optional[str] = Field(None, alias="promiseDispatchDate")
+    has_any_shipments: Optional[bool] = Field(None, alias="hasAnyShipments")
+    has_any_payments: Optional[bool] = Field(None, alias="hasAnyPayments")
     date: Optional[str] = None
     notes: Optional[str] = None
     id: int
 
 
+class SaleOrderSynchronize(BaseModel):
+    id: int
+    invoice_integration: SaleOrderInvoiceIntegration = Field(alias="invoiceIntegration")
+    notes: Optional[str] = None
+    tags: Optional[List[str]] = None
+
+
+class UpdateStatus(BaseModel):
+    updated: bool = False
+
+
+class SaleOrderSyncResponse(BaseModel):
+    basic: UpdateStatus = Field(default_factory=UpdateStatus)
+    contact: UpdateStatus = Field(default_factory=UpdateStatus)
+    shipments: UpdateStatus = Field(default_factory=UpdateStatus) 
+    payments: UpdateStatus = Field(default_factory=UpdateStatus)
+    invoice_integration: UpdateStatus = Field(alias="invoiceIntegration", default_factory=UpdateStatus)
+
+
 @dataclass
 class SaleOrderService(BaseService[SaleOrder]):
-    endpoint: str = Field(default='salesorders', exclude=True)
+    endpoint: str = 'salesorders'
 
     def __call__(self, **payload):
         self._record = SaleOrder(**payload)
         return self
 
-    def get(self, sale_order_id: int) -> "SaleOrder":
+    def __repr__(self):
+        return repr(self._record)
+    
+    def get(self, sale_order_id: int) -> "SaleOrderService":
         endpoint = f'{self.endpoint}/{sale_order_id}'
         url = self.config.get_endpoint(endpoint)
         response = requests.get(url, headers=self.config.headers)
         if not response.ok:
             raise Exception("Order could not be fetched")
-        return SaleOrder(**response.json())
+        response_data = response.json()
+        return self(**response_data)
 
     def get_shipping_labels(self):
         if not self._record:
@@ -278,25 +309,32 @@ class SaleOrderService(BaseService[SaleOrder]):
         url = self.config.get_endpoint(endpoint)
         response = requests.post(url, headers=self.config.headers)
         if not response.ok:
-            raise Exception("Order could not be closed")
+            raise Exception("Order could not be cancelled")
 
-    def synchronize(self, payload: "SaleOrder") -> "SaleOrder":
+    def synchronize(self) -> "SaleOrderService":
+        if not self._record:
+            raise Exception("You need to add a record by calling the resource and adding info")
         endpoint = f'{self.endpoint}/synchronize'
         url = self.config.get_endpoint(endpoint)
-        response = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        # TODO: Check what can we sync, and what can we not sync
+        sync_body = SaleOrderSynchronize(**self._record.model_dump(by_alias=True))
+        response = requests.post(url, json=sync_body.model_dump(by_alias=True), headers=self.config.headers)
         if not response.ok:
-            raise Exception(f"Synchronize error {response.text}")
-        return SaleOrder(**response.json())
+            raise Exception(f"Synchronize error {response.status_code} {response.text}")
+        sync_res = SaleOrderSyncResponse(**response.json()) # noqa
+        return self
 
     def invoice_integration(self):
         if not self._record:
             raise Exception("You need to add a record id")
         endpoint = f'{self.endpoint}/{self._record.id}/invoiceIntegration'
         url = self.config.get_endpoint(endpoint)
-        response = requests.put(url, headers=self.config.headers, data=self._record.model_dump_json(exclude_none=True))
+        response = requests.put(url, headers=self.config.headers,
+                                json={"id": self._record.id,
+                                      "invoiceIntegration": SaleOrderInvoiceIntegrationPut(**self._record.invoice_integration.model_dump(by_alias=True)).model_dump()})
         if not response.ok:
             raise Exception(f"Error on resposne {response.text}")
-        return SaleOrder(**response.json())
+        return response.ok
 
     def search(self, params: SearchSalesOrderParams):
         endpoint: str = f"search/{self.endpoint}"
@@ -308,41 +346,46 @@ class SaleOrderService(BaseService[SaleOrder]):
             headers=headers,
         )
         if not response.ok:
-            raise Exception(f"Error on resposne {response.text}")
-        return SearchSalesOrder(**response.json())
+            raise Exception(f"Error on resposne {response.status_code} - {response.text}")
+        response_data = response.json()
+        return SearchSalesOrder(**response_data)
 
-    def add_payment(self, payload: "Payment") -> "Payment":
+    def add_payment(self, payload) -> Payment:
         if not self._record:
             raise Exception("You need to add a record id")
+        payment = Payment(**payload)
         url = self.config.get_endpoint(f"{self.endpoint}/{self._record.id}/payments")
-        res = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        res = requests.post(url, json=payment.model_dump(by_alias=True, exclude_none=True), headers=self.config.headers)
         if not res.ok:
             raise Exception(f"Error on resposne {res.text}")
         return Payment(**res.json())
 
-    def update_payment(self, payment_id: int, payload: "Payment") -> "Payment":
+    def update_payment(self, payment_id: int, payload) -> "Payment":
         if not self._record:
             raise Exception("You need to add a record id")
+        payment = Payment(**payload)
         url = self.config.get_endpoint(f"{self.endpoint}/{self._record.id}/payments/{payment_id}")
-        res = requests.put(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        res = requests.put(url, json=payment.model_dump(by_alias=True, exclude_none=True), headers=self.config.headers)
         if not res.ok:
             raise Exception(f"Error on payment update {res.text}")
         return Payment(**res.json())
 
-    def add_shipment(self, payload: "Shipment") -> "Shipment":
+    def add_shipment(self, payload) -> "Shipment":
         if not self._record:
             raise Exception("You need to add a record id")
+        shipment = Shipment(**payload)
         url = self.config.get_endpoint(f"{self.endpoint}/{self._record.id}/shipments")
-        res = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        res = requests.post(url, json=shipment.model_dump(by_alias=True, exclude_none=True), headers=self.config.headers)
         if not res.ok:
             raise Exception(f"Error on shipment add {res.text}")
         return Shipment(**res.json())
 
-    def update_shipment(self, shipment_id: str, payload: "Shipment") -> "Shipment":
+    def update_shipment(self, shipment_id: str, payload) -> "Shipment":
         if not self._record:
             raise Exception("You need to add a record id")
+        shipment = Shipment(**payload)
         url = self.config.get_endpoint(f"{self.endpoint}/{self._record.id}/shipments/{shipment_id}")
-        res = requests.put(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        res = requests.put(url, json=shipment.model_dump(by_alias=True, exclude_none=True), headers=self.config.headers)
         if not res.ok:
             raise Exception(f"Error on shipment update {res.text}")
         return Shipment(**res.json())