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

producteca/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+
+from .client import ProductecaClient

producteca/abstract/abstract_dataclass.py

@@ -8,4 +8,16 @@ from typing import Optional
 class BaseService[T](ABC):
     config: ConfigProducteca
     endpoint: str
-    _record: Optional[T] = None
+    _record: Optional[T] = None
+    
+    def __repr__(self):
+        return repr(self._record)
+
+    def to_dict(self):
+        return self._record.model_dump(by_alias=True)
+
+    def to_json(self):
+        return self._record.model_dump_json(by_alias=True)
+
+    def __getattr__(self, key):
+        return getattr(self._record, key)

producteca/client.py

@@ -1,6 +1,7 @@
 from producteca.config.config import ConfigProducteca
 from producteca.products.products import ProductService
 from producteca.sales_orders.sales_orders import SaleOrderService
+
 import os
 
 
@@ -20,3 +21,4 @@ class ProductecaClient:
     @property
     def SalesOrder(self):
         return SaleOrderService(self.config)
+

producteca/payments/tests/test_payments.py

@@ -35,7 +35,15 @@ class TestPayments(unittest.TestCase):
         payment = Payment(**self.payment_data)
         
         # Test create method
-        result = self.client.SalesOrder(id=self.sale_order_id).add_payment(payment)
+        result = self.client.SalesOrder(id=self.sale_order_id, invoiceIntegration={
+                'id': 1,
+                'integrationId': 'test-integration',
+                'app': 1,
+                'createdAt': '2023-01-01',
+                'decreaseStock': True,
+                "documentUrl": "https://aallala.copm",
+                "xmlUrl": "https://aallala.copm",
+            }).add_payment(payment.model_dump(by_alias=True))
         
         # Assertions
         mock_post.assert_called_once()
@@ -55,7 +63,15 @@ class TestPayments(unittest.TestCase):
         payment = Payment(**self.payment_data)
         
         # Test update method
-        result = self.client.SalesOrder(id=self.sale_order_id).update_payment(self.payment_id, payment)
+        result = self.client.SalesOrder(id=self.sale_order_id, invoiceIntegration={
+                'id': 1,
+                'integrationId': 'test-integration',
+                'app': 1,
+                'createdAt': '2023-01-01',
+                'decreaseStock': True,
+                "documentUrl": "https://aallala.copm",
+                "xmlUrl": "https://aallala.copm",
+            }).update_payment(self.payment_id, payment.model_dump(by_alias=True))
         
         # Assertions
         mock_put.assert_called_once()

producteca/products/products.py

@@ -1,5 +1,5 @@
 from typing import List, Optional, Union
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, ValidationError
 from dataclasses import dataclass
 from producteca.abstract.abstract_dataclass import BaseService
 from producteca.products.search_products import SearchProduct, SearchProductParams
@@ -88,23 +88,71 @@ class MeliCategory(BaseModel):
     fixed: Optional[bool] = None
 
 
+class BundleComponent(BaseModel):
+    quantity: int
+    variation_id: int = Field(alias='variationId')
+    product_id: int = Field(alias='productId')
+
+
+class BundleVariation(BaseModel):
+    variation_id: int = Field(alias='variationId')
+    components: List[BundleComponent]
+
+
+class BundleResult(BaseModel):
+    company_id: int = Field(alias='companyId')
+    product_id: int = Field(alias='productId')
+    variations: List[BundleVariation]
+    id: str
+
+
+class BundleResponse(BaseModel):
+    results: List[BundleResult]
+    count: int
+
+
 class Product(BaseModel):
+    integrations: Optional[List[Integration]] = None
+    variations: Optional[List[Variation]] = None
+    is_simple: Optional[bool] = Field(default=None, alias='isSimple')
+    has_variations: Optional[bool] = Field(default=None, alias='hasVariations') 
+    thumbnail: Optional[str] = None
+    category: Optional[str] = None
+    notes: Optional[str] = None
+    prices: Optional[List[Price]] = None
+    buying_price: Optional[float] = Field(default=None, alias='buyingPrice')
+    is_archived: Optional[bool] = Field(default=None, alias='isArchived')
+    dimensions: Optional[Dimensions] = None
+    attributes: Optional[List[Attribute]] = None
+    metadata: Optional[List[str]] = None
+    is_original: Optional[bool] = Field(default=None, alias='isOriginal')
+    name: str
+    code: Optional[str] = None
     sku: Optional[str] = None
-    variation_id: Optional[int] = None
+    brand: Optional[str] = None
+    id: Optional[int] = None
+
+
+class ProductVariationBase(BaseModel):
+    sku: str
+    variation_id: Optional[int] = Field(default=None, alias='variationId')
     code: Optional[str] = None
-    name: Optional[str] = None
     barcode: Optional[str] = None
-    attributes: Optional[List[Attribute]] = None
-    tags: Optional[List[str]] = None
-    buying_price: Optional[float] = None
-    dimensions: Optional[Dimensions] = None
-    category: Optional[Union[str, MeliCategory]]
-    brand: Optional[str] = None
-    notes: Optional[str] = None
-    deals: Optional[List[Deal]] = None
-    stocks: Optional[List[Stock]] = None
-    prices: Optional[List[Price]] = None
-    pictures: Optional[List[Picture]] = None
+    attributes: List[Attribute] = []
+    tags: Optional[List[str]] = []
+    buying_price: Optional[float] = Field(0, alias='buyingPrice')
+    dimensions: Optional[Dimensions] = Field(default_factory=Dimensions)
+    brand: Optional[str] = ''
+    notes: Optional[str] = ''
+    deals: Optional[List[Deal]] = []
+    stocks: List[Stock]
+    prices: Optional[List[Price]] = []
+    pictures: Optional[List[Picture]] = []
+
+
+class ProductVariation(ProductVariationBase):
+    category: Optional[str] = Field(default=None)
+    name: str
 
 
 class Shipping(BaseModel):
@@ -128,13 +176,14 @@ class AttributeCompletion(BaseModel):
     total: Optional[int] = None
 
 
-class MeliProduct(Product):
+class MeliProduct(BaseModel):
     product_id: Optional[int] = Field(default=None, alias='productId')
+    tags: Optional[List[str]] = Field(default=None)
     has_custom_shipping_costs: Optional[bool] = Field(default=None, alias='hasCustomShippingCosts')
     shipping: Optional[Shipping] = None
     mshops_shipping: Optional[MShopsShipping] = Field(default=None, alias='mShopsShipping')
     add_free_shipping_cost_to_price: Optional[bool] = Field(default=None, alias='addFreeShippingCostToPrice')
-    category: Optional[Union[str, MeliCategory]]  # will never be str, but needs compat with super class
+    category: MeliCategory
     attribute_completion: Optional[AttributeCompletion] = Field(default=None, alias='attributeCompletion')
     catalog_products: Optional[List[str]] = Field(default=None, alias='catalogProducts')
     warranty: Optional[str] = None
@@ -143,65 +192,138 @@ class MeliProduct(Product):
     catalog_products_status: Optional[str] = Field(default=None, alias='catalogProductsStatus')
 
 
+class ErrorMessage(BaseModel):
+    en: str
+    es: str
+    pt: str
+
+
+class ErrorReason(BaseModel):
+    code: str
+    error: str
+    message: ErrorMessage
+    data: Optional[dict] = None
+
+
+class ResolvedValue(BaseModel):
+    updated: bool
+
+
+class ResolvedError(BaseModel):
+    resolved: Optional[bool] = None
+    reason: Optional[ErrorReason] = None
+    value: Optional[ResolvedValue] = None
+    statusCode: Optional[int] = None
+
+
+class ErrorContext(BaseModel):
+    _ns_name: str
+    id: int
+    requestId: str
+    tokenAppId: str
+    appId: str
+    bearer: str
+    eventId: str
+
+
+class SynchronizeResponse(BaseModel):
+    product: Optional[ResolvedError] = None
+    variation: Optional[ResolvedError] = None
+    deals: Optional[ResolvedError] = None
+    bundles: Optional[ResolvedError] = None
+    taxes: Optional[ResolvedError] = None
+    meliProductListingIntegrations: Optional[ResolvedError] = None
+    tags: Optional[ResolvedError] = None
+    productIntegrations: Optional[ResolvedError] = None
+    statusCode: Optional[int] = None
+    error_context: Optional[ErrorContext] = Field(None, alias='error@context')
+
+
+class ListedSynchronizeResponse(BaseModel):
+    results: List[SynchronizeResponse]
+
+
 @dataclass
 class ProductService(BaseService[Product]):
-    endpoint: str = Field(default='products', exclude=True)
+    endpoint: str = 'products'
     create_if_it_doesnt_exist: bool = Field(default=False, exclude=True)
 
     def __call__(self, **payload):
         self._record = Product(**payload)
         return self
 
-    def create(self):
+    def synchronize(self, payload) -> Union[Product, SynchronizeResponse]:
+
         endpoint_url = self.config.get_endpoint(f'{self.endpoint}/synchronize')
         headers = self.config.headers.copy()
         headers.update({"createifitdoesntexist": str(self.create_if_it_doesnt_exist).lower()})
-        data = self._record.model_dump_json(by_alias=True, exclude_none=True)
-        response = requests.post(endpoint_url, data=data, headers=headers)
-        if response.status_code == 204:
-            raise Exception("Product does not exist and the request cant create if it does not exist")
-        return Product(**response.json())
+        product_variation = ProductVariation(**payload)
+        if not product_variation.code and not product_variation.sku:
+            raise Exception("Sku or code should be provided to update the product")
+        data = product_variation.model_dump(by_alias=True, exclude_none=True)
+        response = requests.post(endpoint_url, json=data, headers=headers)
+        response_data = response.json()
+        try:
+            return Product(**response_data)
+        except ValidationError:
+            pass
+        if isinstance(response_data, list):
+            res = ListedSynchronizeResponse(results=response_data)
+            if any([r.error_context for r in res.results]):
+                raise Exception(f"Errored while updating {res.results[0].error_context} {res.model_dump_json()}")
+            else:
+                return res.results[0]
+        else:
+            try:
+                sync_resp = SynchronizeResponse(**response_data)
+                if sync_resp.error_context:
+                    raise Exception(f"Errored while updating {sync_resp.error_context} - {sync_resp.model_dump_json()}")
+                else:
+                    return sync_resp
+            except ValidationError:
+                try:
+                    error_res = ErrorReason(**response_data)
+                    raise Exception(f"Errored with the following message {error_res.message} - {error_res.model_dump_json()}")
+                except ValidationError:
+                    pass
 
-    def update(self):
-        # TODO: Change name to synchronize
-        endpoint_url = self.config.get_endpoint(f'{self.endpoint}/synchronize')
-        headers = self.config.headers.copy()
-        data = self._record.model_dump_json(by_alias=True, exclude_none=True)
-        if not self._record.code and not self._record.sku:
-            raise "Sku or code should be provided to update the product"
-        response = requests.post(endpoint_url, data=data, headers=headers)
+        if not response.ok:
+            raise Exception(f"Error getting product {product_variation.sku} - {product_variation.code}\n {response.text}")
         if response.status_code == 204:
-            raise Exception("Product does not exist and the request cant create if it does not exist")
-        return Product(**response.json())
+            raise Exception("Status code is 204, meaning nothing was updated or created")
+        raise Exception(f"Unhandled error, check response {response.text}")
 
-    def get(self, product_id: int) -> "Product":
+    def get(self, product_id: int) -> "ProductService":
         endpoint_url = self.config.get_endpoint(f'{self.endpoint}/{product_id}')
         headers = self.config.headers
         response = requests.get(endpoint_url, headers=headers)
         if not response.ok:
             raise Exception(f"Error getting product {product_id}\n {response.text}")
         response_data = response.json()
-        return Product(**response_data)
+        return self(**response_data)
 
-    def get_bundle(self, product_id: int) -> "Product":
+    def get_bundle(self, product_id: int) -> BundleResponse:
         endpoint_url = self.config.get_endpoint(f'{self.endpoint}/{product_id}/bundles')
         headers = self.config.headers
         response = requests.get(endpoint_url, headers=headers)
         if not response.ok:
             raise Exception(f"Error getting bundle {product_id}\n {response.text}")
-        return Product(**response.json())
+        return BundleResponse(**response.json())
 
-    def get_ml_integration(self, product_id: int) -> "MeliProduct":
+    def get_ml_integration(self, product_id: int) -> MeliProduct:
         endpoint_url = self.config.get_endpoint(f'{self.endpoint}/{product_id}/listingintegration')
         headers = self.config.headers
         response = requests.get(endpoint_url, headers=headers)
         if not response.ok:
             raise Exception(f"Error getting ml integration {product_id}\n {response.text}")
-        return MeliProduct(**response.json())
+        response_data = response.json()
+        return MeliProduct(**response_data)
 
     def search(self, params: SearchProductParams) -> SearchProduct:
         endpoint: str = f'search/{self.endpoint}'
         headers = self.config.headers
         url = self.config.get_endpoint(endpoint)
         response = requests.get(url, headers=headers, params=params.model_dump(by_alias=True, exclude_none=True))
+        if not response.ok:
+            raise Exception(f"error in searching products {response.text}")
         return SearchProduct(**response.json())

producteca/products/search_products.py

@@ -1,17 +1,17 @@
-from typing import List, Optional
+from typing import List, Optional, Union
 from pydantic import BaseModel, Field
 
 
 class FacetValue(BaseModel):
     count: int
-    value: str
-    label: str
+    value: Optional[Union[str, bool]] = None
+    label: Union[str, bool]
 
 
 class Facet(BaseModel):
     key: str
     value: List[FacetValue]
-    is_collection: bool
+    is_collection: Optional[bool] = False
     translate: bool
 
 
@@ -22,23 +22,23 @@ class SearchStocks(BaseModel):
 
 
 class SearchPrices(BaseModel):
-    price_list_id: int
-    price_list: str
+    price_list_id: int = Field(..., alias='priceListId')
+    price_list: str = Field(..., alias='priceList') 
     amount: float
     currency: str
 
 
 class SearchIntegration(BaseModel):
-    app: Optional[int]
-    integration_id: Optional[str]
-    permalink: Optional[str]
-    status: Optional[str]
-    listing_type: Optional[str]
-    safety_stock: Optional[int]
-    synchronize_stock: Optional[bool]
-    is_active: Optional[bool]
-    is_active_or_paused: Optional[bool]
-    id: Optional[int]
+    app: Optional[int] = None
+    integration_id: Optional[str] = Field(None, alias='integrationId')
+    permalink: Optional[str] = None
+    status: Optional[str] = None
+    listing_type: Optional[str] = Field(None, alias='listingType')
+    safety_stock: Optional[int] = Field(None, alias='safetyStock')
+    synchronize_stock: Optional[bool] = Field(None, alias='synchronizeStock')
+    is_active: Optional[bool] = Field(None, alias='isActive')
+    is_active_or_paused: Optional[bool] = Field(None, alias='isActiveOrPaused')
+    id: Optional[int] = None
 
 
 class SearchDeals(BaseModel):
@@ -56,8 +56,8 @@ class SearchDeals(BaseModel):
 class SearchResultItem(BaseModel):
     search_score: float = Field(..., alias='@search.score')
     id: int
-    product_id: int
-    company_id: int
+    product_id: int = Field(..., alias='productId')
+    company_id: int = Field(..., alias='companyId')
     name: str
     code: str
     skus: List[str]
@@ -65,61 +65,61 @@ class SearchResultItem(BaseModel):
     category: str
     thumbnail: str
     stocks: List[SearchStocks]
-    warehouses_with_stock: List[str]
-    total_stock: int
-    has_pictures: bool
-    buying_price: float
+    warehouses_with_stock: List[str] = Field(..., alias='warehousesWithStock')
+    total_stock: int = Field(..., alias='totalStock')
+    has_pictures: bool = Field(..., alias='hasPictures')
+    buying_price: float = Field(..., alias='buyingPrice')
     prices: List[SearchPrices]
-    integration_ids: List[str]
-    integration_apps: List[str]
+    integration_ids: List[str] = Field(..., alias='integrationIds')
+    integration_apps: List[str] = Field(..., alias='integrationApps')
     integrations: List[SearchIntegration]
     campaigns: List[str]
-    app: Optional[int]
-    status: Optional[str]
-    synchronize_stock: Optional[bool]
-    listing_type: Optional[str]
-    price_amount: Optional[float]
-    price_currency: Optional[str]
-    category_id: Optional[str]
-    category_base_id: Optional[str]
-    category_l1: Optional[str]
-    category_l2: Optional[str]
-    category_l3: Optional[str]
-    category_l4: Optional[str]
-    category_l5: Optional[str]
-    category_l6: Optional[str]
-    has_category: Optional[bool]
-    category_fixed: Optional[bool]
-    accepts_mercadoenvios: Optional[bool]
-    shipping_mode: Optional[str]
-    local_pickup: Optional[bool]
-    mandatory_free_shipping: Optional[bool]
-    free_shipping: Optional[bool]
-    free_shipping_cost: Optional[float]
-    template: Optional[str]
-    youtube_id: Optional[str]
-    warranty: Optional[str]
-    permalink: Optional[str]
-    domain: Optional[str]
-    attribute_completion_status: Optional[str]
-    attribute_completion_count: Optional[int]
-    attribute_completion_total: Optional[int]
-    deals: Optional[SearchDeals]
-    campaign_status: Optional[List[str]]
-    size_chart: Optional[str]
-    channel_status: Optional[List[str]]
-    channel_category_l1: Optional[List[str]]
-    channel_category_l2: Optional[List[str]]
-    channel_category_l3: Optional[List[str]]
-    channel_category_id: Optional[List[str]]
-    channel_synchronizes_stock: Optional[List[str]]
-    channel_has_category: Optional[List[str]]
-    catalog_products_status: Optional[List[str]]
-    metadata: Optional[List[str]]
-    integration_tags: Optional[List[str]]
-    variations_integration_ids: Optional[List[str]]
-    channel_pictures_templates: Optional[List[str]]
-    channel_pictures_templates_apps: Optional[List[str]]
+    app: Optional[int] = None
+    status: Optional[str] = None
+    synchronize_stock: Optional[bool] = Field(None, alias='synchronizeStock')
+    listing_type: Optional[str] = Field(None, alias='listingType')
+    price_amount: Optional[float] = Field(None, alias='priceAmount')
+    price_currency: Optional[str] = Field(None, alias='priceCurrency')
+    category_id: Optional[str] = Field(None, alias='categoryId')
+    category_base_id: Optional[str] = Field(None, alias='categoryBaseId')
+    category_l1: Optional[str] = Field(None, alias='categoryL1')
+    category_l2: Optional[str] = Field(None, alias='categoryL2')
+    category_l3: Optional[str] = Field(None, alias='categoryL3')
+    category_l4: Optional[str] = Field(None, alias='categoryL4')
+    category_l5: Optional[str] = Field(None, alias='categoryL5')
+    category_l6: Optional[str] = Field(None, alias='categoryL6')
+    has_category: Optional[bool] = Field(None, alias='hasCategory')
+    category_fixed: Optional[bool] = Field(None, alias='categoryFixed')
+    accepts_mercadoenvios: Optional[bool] = Field(None, alias='acceptsMercadoenvios')
+    shipping_mode: Optional[str] = Field(None, alias='shippingMode')
+    local_pickup: Optional[bool] = Field(None, alias='localPickup')
+    mandatory_free_shipping: Optional[bool] = Field(None, alias='mandatoryFreeShipping')
+    free_shipping: Optional[bool] = Field(None, alias='freeShipping')
+    free_shipping_cost: Optional[float] = Field(None, alias='freeShippingCost')
+    template: Optional[str] = None
+    youtube_id: Optional[str] = Field(None, alias='youtubeId')
+    warranty: Optional[str] = None
+    permalink: Optional[str] = None
+    domain: Optional[str] = None
+    attribute_completion_status: Optional[str] = Field(None, alias='attributeCompletionStatus')
+    attribute_completion_count: Optional[int] = Field(None, alias='attributeCompletionCount')
+    attribute_completion_total: Optional[int] = Field(None, alias='attributeCompletionTotal')
+    deals: Optional[SearchDeals] = None
+    campaign_status: Optional[List[str]] = Field(None, alias='campaignStatus')
+    size_chart: Optional[str] = Field(None, alias='sizeChart')
+    channel_status: Optional[List[str]] = Field(None, alias='channelStatus')
+    channel_category_l1: Optional[List[str]] = Field(None, alias='channelCategoryL1')
+    channel_category_l2: Optional[List[str]] = Field(None, alias='channelCategoryL2')
+    channel_category_l3: Optional[List[str]] = Field(None, alias='channelCategoryL3')
+    channel_category_id: Optional[List[str]] = Field(None, alias='channelCategoryId')
+    channel_synchronizes_stock: Optional[List[str]] = Field(None, alias='channelSynchronizesStock')
+    channel_has_category: Optional[List[str]] = Field(None, alias='channelHasCategory')
+    catalog_products_status: Optional[List[str]] = Field(None, alias='catalogProductsStatus')
+    metadata: Optional[List[str]] = None
+    integration_tags: Optional[List[str]] = Field(None, alias='integrationTags')
+    variations_integration_ids: Optional[List[str]] = Field(None, alias='variationsIntegrationIds')
+    channel_pictures_templates: Optional[List[str]] = Field(None, alias='channelPicturesTemplates')
+    channel_pictures_templates_apps: Optional[List[str]] = Field(None, alias='channelPicturesTemplatesApps')
 
 
 class SearchProduct(BaseModel):
@@ -132,8 +132,5 @@ class SearchProductParams(BaseModel):
     top: Optional[int]
     skip: Optional[int]
     filter: Optional[str] = Field(default=None, alias='$filter')
-    search: Optional[str]
+    search: Optional[str] = Field(default=None)
     sales_channel: Optional[str] = Field(default='2', alias='salesChannel')
-
-
-