producteca 1.0.14__py3-none-any.whl → 2.0.57__py3-none-any.whl

producteca/__init__.py

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

producteca/abstract/abstract_dataclass.py

@@ -1,23 +1,25 @@
-from pydantic import BaseModel, PrivateAttr
-from abc import ABC, abstractmethod
-from ..config.config import ConfigProducteca, APIConfig
+from abc import ABC
+from ..config.config import ConfigProducteca
+from ..utils import clean_model_dump
+from dataclasses import dataclass
+from typing import Optional, Any
 
 
-class AbstractProductecaModel(BaseModel, ABC):
-    _config: APIConfig = PrivateAttr()
+@dataclass
+class BaseService(ABC):
+    config: ConfigProducteca
+    endpoint: str
+    _record: Optional[Any] = None
+    
+    def __repr__(self):
+        return repr(self._record)
 
-    @property
-    @abstractmethod
-    def endpoint(self) -> str:
-        pass
+    def to_dict(self):
+        return clean_model_dump(self._record)
 
-    def dict(self, *args, **kwargs):
-        return super().dict(*args, exclude_none=True, **kwargs)
+    def to_json(self):
+        import json
+        return json.dumps(clean_model_dump(self._record))
 
-
-class AbstractProductecaV1Model(AbstractProductecaModel):
-    _config: ConfigProducteca = PrivateAttr()
-
-    @property
-    def endpoint_url(self) -> str:
-        return self._config.get_endpoint(self.endpoint)
+    def __getattr__(self, key):
+        return getattr(self._record, key)

producteca/client.py

@@ -1,37 +1,24 @@
 from producteca.config.config import ConfigProducteca
-from producteca.products.products import Product
-from producteca.sales_orders.sales_orders import SalesOrder
-from producteca.search.search import Search
-from producteca.shipments.shipment import Shipment
-from producteca.payments.payments import Payment
+from producteca.products.products import ProductService
+from producteca.sales_orders.sales_orders import SaleOrderService
+
 import os
 
 
 class ProductecaClient:
 
-    def __init__(self, token: str = os.environ['PRODUCTECA_TOKEN'], api_key: str = os.environ['PRODUCTECA_API_KEY']):
+    def __init__(self, token: str = os.environ.get('PRODUCTECA_TOKEN', ''), api_key: str = os.environ.get('PRODUCTECA_API_KEY', '')):
         if not token:
             raise ValueError('PRODUCTECA_TOKEN environment variable not set')
         if not api_key:
             raise ValueError('PRODUCTECA_API_KEY environment variable not set')
         self.config = ConfigProducteca(token=token, api_key=api_key)
-        
-    @property
-    def Product(self):
-        return lambda *args: Product(config=self.config, *args)
-
-    @property 
-    def SalesOrder(self):
-        return lambda *args: SalesOrder(config=self.config, *args)
 
     @property
-    def Search(self):
-        return lambda *args: Search(config=self.config, *args)
+    def Product(self):
+        return ProductService(self.config)
 
     @property
-    def Shipment(self):
-        return lambda *args: Shipment(config=self.config, *args)
+    def SalesOrder(self):
+        return SaleOrderService(self.config)
 
-    @property
-    def Payment(self):
-        return lambda *args: Payment(config=self.config, *args)

producteca/config/__init__.py

@@ -1 +0,0 @@
-from .config import ConfigProducteca

producteca/payments/payments.py

@@ -1,7 +1,5 @@
 from pydantic import BaseModel
 from typing import Optional
-import requests
-from ..config.config import ConfigProducteca
 
 
 class PaymentCard(BaseModel):
@@ -22,24 +20,14 @@ class Payment(BaseModel):
     date: str
     amount: float
     couponAmount: Optional[float] = None
-    status: str
-    method: str
+    status: Optional[str] = None
+    method: Optional[str] = None
     integration: Optional[PaymentIntegration] = None
     transactionFee: Optional[float] = None
     installments: Optional[int] = None
     card: Optional[PaymentCard] = None
     notes: Optional[str] = None
-    hasCancelableStatus: bool
+    hasCancelableStatus: Optional[bool] = None
     id: Optional[int] = None
 
-    @classmethod
-    def create(cls, config: ConfigProducteca, sale_order_id: int, payload: "Payment") -> "Payment":
-        url = config.get_endpoint(f"salesorders/{sale_order_id}/payments")
-        res = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=config.headers)
-        return cls(**res.json())
-
-    @classmethod
-    def update(cls, config: ConfigProducteca, sale_order_id: int, payment_id: int, payload: "Payment") -> "Payment":
-        url = config.get_endpoint(f"salesorders/{sale_order_id}/payments/{payment_id}")
-        res = requests.put(url, data=payload.model_dump_json(exclude_none=True), headers=config.headers)
-        return cls(**res.json())
+

producteca/payments/tests/test_payments.py

@@ -1,13 +1,13 @@
 import unittest
 from unittest.mock import patch, Mock
 from datetime import datetime
-from producteca.config.config import ConfigProducteca
-from producteca.payments.payments import Payment, PaymentCard, PaymentIntegration
+from producteca.client import ProductecaClient
+from producteca.payments.payments import Payment
 
 
 class TestPayments(unittest.TestCase):
     def setUp(self):
-        self.config = ConfigProducteca(token="asd", api_key="test_key")
+        self.client = ProductecaClient(token="asd", api_key="test_key")
         self.sale_order_id = 123
         self.payment_id = 456
         
@@ -35,7 +35,15 @@ class TestPayments(unittest.TestCase):
         payment = Payment(**self.payment_data)
         
         # Test create method
-        result = Payment.create(self.config, self.sale_order_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",
+            }).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 = Payment.update(self.config, self.sale_order_id, 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/__init__.py

@@ -1 +0,0 @@
-from . import products

producteca/products/products.py

@@ -1,20 +1,24 @@
 from typing import List, Optional, Union
-from pydantic import BaseModel, Field
-import requests
-from ..config.config import ConfigProducteca
+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
+from producteca.utils import clean_model_dump
 import logging
+import requests
 
 _logger = logging.getLogger(__name__)
 
-# Models for nested structures
 
 class Attribute(BaseModel):
     key: str
     value: str
 
+
 class Tag(BaseModel):
     tag: str
 
+
 class Dimensions(BaseModel):
     weight: Optional[float] = None
     width: Optional[float] = None
@@ -22,11 +26,13 @@ class Dimensions(BaseModel):
     length: Optional[float] = None
     pieces: Optional[int] = None
 
+
 class Deal(BaseModel):
     campaign: str
     regular_price: Optional[float] = Field(default=None, alias='regularPrice')
     deal_price: Optional[float] = Field(default=None, alias='dealPrice')
 
+
 class Stock(BaseModel):
     quantity: Optional[int] = None
     available_quantity: Optional[int] = Field(default=None, alias='availableQuantity')
@@ -35,15 +41,18 @@ class Stock(BaseModel):
     reserved: Optional[int] = None
     available: Optional[int] = None
 
+
 class Price(BaseModel):
     amount: Optional[float] = None
     currency: str
     price_list: str = Field(alias='priceList')
     price_list_id: Optional[int] = Field(default=None, alias='priceListId')
 
+
 class Picture(BaseModel):
     url: str
 
+
 class Integration(BaseModel):
     app: Optional[int] = None
     integration_id: Optional[str] = Field(default=None, alias='integrationId')
@@ -57,96 +66,96 @@ class Integration(BaseModel):
     id: Optional[int] = None
     parent_integration: Optional[str] = Field(default=None, alias='parentIntegration')
 
+
 class Variation(BaseModel):
     variation_id: Optional[int] = Field(default=None, alias='variationId')
     components: Optional[List] = None
-    pictures: Optional[List[Picture]] = None
-    stocks: Optional[List[Stock]] = None
+    pictures: Optional[Union[List[Picture], List]] = None
+    stocks: Optional[Union[List[Stock], List]] = None
     attributes_hash: Optional[str] = Field(default=None, alias='attributesHash')
     primary_color: Optional[str] = Field(default=None, alias='primaryColor')
     thumbnail: Optional[str] = None
-    attributes: Optional[List[Attribute]] = None
-    integrations: Optional[List[Integration]] = None
+    attributes: Optional[Union[List[Attribute], List]] = None
+    integrations: Optional[Union[List[Integration], List]] = None
     id: Optional[int] = None
     sku: Optional[str] = None
     barcode: Optional[str] = None
 
-# Model base para los productos
+
+class MeliCategory(BaseModel):
+    meli_id: Optional[str] = Field(default=None, alias='meliId')
+    accepts_mercadoenvios: Optional[bool] = Field(default=None, alias='acceptsMercadoenvios')
+    suggest: Optional[bool] = None
+    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: Union[List[BundleComponent], List]
+
+
+class BundleResult(BaseModel):
+    company_id: int = Field(alias='companyId')
+    product_id: int = Field(alias='productId')
+    variations: Union[List[BundleVariation], List]
+    id: str
+
+
+class BundleResponse(BaseModel):
+    results: Union[List[BundleResult], List]
+    count: int
+
+
 class Product(BaseModel):
-    config: Optional[ConfigProducteca] = Field(default=None, exclude=True)
-    endpoint: str = Field(default='products', exclude=True)
-    create_if_it_doesnt_exist: bool = Field(default=False, exclude=True)
-    sku: Optional[str] = None
-    variation_id: Optional[int] = None
+    updatable_properties: Optional[List[str]] = Field(default=None, alias='$updatableProperties')
+    integrations: Optional[Union[List[Integration], List]] = None
+    variations: Optional[Union[List[Variation], List]] = 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[Union[List[Price], List]] = None
+    buying_price: Optional[float] = Field(default=None, alias='buyingPrice')
+    is_archived: Optional[bool] = Field(default=None, alias='isArchived')
+    dimensions: Optional[Union[Dimensions, dict]] = None
+    attributes: Optional[Union[List[Attribute], List]] = None
+    metadata: Optional[List[str]] = None
+    is_original: Optional[bool] = Field(default=None, alias='isOriginal')
+    name: str
     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, dict]] = None  # Puede ser string en POST o dict en GET Meli
+    sku: Optional[str] = None
     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
+    id: Optional[int] = None
 
 
-    def create(self):
-        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.model_dump_json(by_alias=True, exclude_none=True)
-        response = requests.post(endpoint_url, data=data, headers=headers)
-        if response.status_code == 204:
-            final_response = {"Message":"Product does not exist and the request cant create if it does not exist"}
-        else:
-            final_response = response.json()
-        return final_response, response.status_code
-
-    def update(self):
-        endpoint_url = self.config.get_endpoint(f'{self.endpoint}/synchronize')
-        headers = self.config.headers.copy()
-        data = self.model_dump_json(by_alias=True, exclude_none=True)
-        if not self.code and not self.sku:
-            return {"Message":"Sku or code should be provided to update the product"}, 204
-        response = requests.post(endpoint_url, data=data, headers=headers)
-        if response.status_code == 204:
-            final_response = {"Message":"Product does not exist and the request cant create if it does not exist"}
-        else:
-            final_response = response.json()
-        return final_response, response.status_code
-
-    @classmethod
-    def get(cls, config: ConfigProducteca, product_id: int):
-        endpoint_url = config.get_endpoint(f'{cls().endpoint}/{product_id}')
-        headers = config.headers
-        response = requests.get(endpoint_url, headers=headers)
-        response_data = response.json()
-        return response_data, response.status_code
+class ProductVariationBase(BaseModel):
+    sku: str
+    variation_id: Optional[int] = Field(default=None, alias='variationId')
+    code: Optional[str] = None
+    barcode: Optional[str] = None
+    attributes: Union[List[Attribute], List] = []
+    tags: Optional[List[str]] = []
+    buying_price: Optional[float] = Field(default=None, alias='buyingPrice')
+    dimensions: Optional[Union[Dimensions, dict]] = Field(default_factory=Dimensions)
+    brand: Optional[str] = ''
+    notes: Optional[str] = ''
+    deals: Optional[Union[List[Deal], List]] = []
+    stocks: Optional[Union[List[Stock], List]] = []
+    prices: Optional[Union[List[Price], List]] = []
+    pictures: Optional[Union[List[Picture], List]] = []
 
-    @classmethod
-    def get_bundle(cls, config: ConfigProducteca, product_id: int):
-        endpoint_url = config.get_endpoint(f'{cls().endpoint}/{product_id}/bundles')
-        headers = config.headers
-        response = requests.get(endpoint_url, headers=headers)
-        return cls(config=config, **response.json()), response.status_code
 
-    @classmethod
-    def get_ml_integration(cls, config: ConfigProducteca, product_id: int):
-        endpoint_url = config.get_endpoint(f'{cls().endpoint}/{product_id}/listintegration')
-        headers = config.headers
-        response = requests.get(endpoint_url, headers=headers)
-        return cls(config=config, **response.json()), response.status_code
+class ProductVariation(ProductVariationBase):
+    category: Optional[str] = Field(default=None)
+    name: Optional[str] = None
 
-# Modelo con campos extra de la vista Meli
-class MeliCategory(BaseModel):
-    meli_id: Optional[str] = Field(default=None, alias='meliId')
-    accepts_mercadoenvios: Optional[bool] = Field(default=None, alias='acceptsMercadoenvios')
-    suggest: Optional[bool] = None
-    fixed: Optional[bool] = None
 
 class Shipping(BaseModel):
     local_pickup: Optional[bool] = Field(default=None, alias='localPickup')
@@ -156,9 +165,11 @@ class Shipping(BaseModel):
     mandatory_free_shipping: Optional[bool] = Field(default=None, alias='mandatoryFreeShipping')
     free_shipping_method: Optional[str] = Field(default=None, alias='freeShippingMethod')
 
+
 class MShopsShipping(BaseModel):
     enabled: Optional[bool] = None
 
+
 class AttributeCompletion(BaseModel):
     product_identifier_status: Optional[str] = Field(default=None, alias='productIdentifierStatus')
     data_sheet_status: Optional[str] = Field(default=None, alias='dataSheetStatus')
@@ -166,17 +177,162 @@ class AttributeCompletion(BaseModel):
     count: Optional[int] = None
     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')
+    shipping: Optional[Union[Shipping, dict]] = None
+    mshops_shipping: Optional[Union[MShopsShipping, dict]] = Field(default=None, alias='mShopsShipping')
     add_free_shipping_cost_to_price: Optional[bool] = Field(default=None, alias='addFreeShippingCostToPrice')
-    category: Optional[MeliCategory] = None
-    attribute_completion: Optional[AttributeCompletion] = Field(default=None, alias='attributeCompletion')
+    category: Union[MeliCategory, dict]
+    attribute_completion: Optional[Union[AttributeCompletion, dict]] = Field(default=None, alias='attributeCompletion')
     catalog_products: Optional[List[str]] = Field(default=None, alias='catalogProducts')
     warranty: Optional[str] = None
     domain: Optional[str] = None
     listing_type_id: Optional[str] = Field(default=None, alias='listingTypeId')
     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[Union[ErrorReason, dict]] = None
+    value: Optional[Union[ResolvedValue, dict]] = 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[Union[ResolvedError, dict]] = None
+    variation: Optional[Union[ResolvedError, dict]] = None
+    deals: Optional[Union[ResolvedError, dict]] = None
+    bundles: Optional[Union[ResolvedError, dict]] = None
+    taxes: Optional[Union[ResolvedError, dict]] = None
+    meliProductListingIntegrations: Optional[Union[ResolvedError, dict]] = None
+    tags: Optional[Union[ResolvedError, dict]] = None
+    productIntegrations: Optional[Union[ResolvedError, dict]] = None
+    statusCode: Optional[int] = None
+    error_context: Optional[Union[ErrorContext, dict]] = Field(None, alias='error@context')
+
+
+class ListedSynchronizeResponse(BaseModel):
+    results: Union[List[SynchronizeResponse], List]
+
+
+@dataclass
+class ProductService(BaseService):
+    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 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()})
+        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")
+        # Hacer model_dump con limpieza automática de valores vacíos
+        data = clean_model_dump(product_variation)
+        _logger.info(f"Synchronizing product: {data}")
+        _logger.info(f"POST {endpoint_url} - Headers: {headers} - Data: {data}")
+        response = requests.post(endpoint_url, json=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:
+            _logger.info("Status code is 204 (No Content), product synchronized successfully but no changes were made")
+            return None
+        
+        _logger.info(f"response text: {response.text}")
+        response_data = response.json()
+        _logger.debug(f"Response data: {response_data}")
+        if isinstance(response_data, list):
+            res = ListedSynchronizeResponse(results=response_data)
+            if res.results and hasattr(res.results[0], 'error_context') and res.results[0].error_context:
+                raise Exception(f"Errored while updating {res.results[0].error_context} {res.model_dump_json()}")
+            return res.results[0] if res.results else None
+
+        if isinstance(response_data, dict) and 'name' in response_data:
+            return Product(**response_data)
+
+        if isinstance(response_data, dict) and any(key in response_data for key in ['product', 'variation', 'statusCode']):
+            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()}")
+            return sync_resp
+
+        if isinstance(response_data, dict) and 'message' in response_data:
+            error_res = ErrorReason(**response_data)
+            raise Exception(f"Errored with the following message {error_res.message} - {error_res.model_dump_json()}")
+        
+        raise Exception(f"Unhandled response format, check response {response.text}")
+
+    def get(self, product_id: int) -> "ProductService":
+        endpoint_url = self.config.get_endpoint(f'{self.endpoint}/{product_id}')
+        headers = self.config.headers
+        _logger.info(f"GET {endpoint_url} - Headers: {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 self(**response_data)
+
+    def get_bundle(self, product_id: int) -> BundleResponse:
+        endpoint_url = self.config.get_endpoint(f'{self.endpoint}/{product_id}/bundles')
+        headers = self.config.headers
+        _logger.info(f"GET {endpoint_url} - Headers: {headers}")
+        response = requests.get(endpoint_url, headers=headers)
+        if not response.ok:
+            raise Exception(f"Error getting bundle {product_id}\n {response.text}")
+        return BundleResponse(**response.json())
+
+    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
+        _logger.info(f"GET {endpoint_url} - Headers: {headers}")
+        response = requests.get(endpoint_url, headers=headers)
+        if not response.ok:
+            raise Exception(f"Error getting ml integration {product_id}\n {response.text}")
+        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)
+        params_dict = clean_model_dump(params)
+        _logger.info(f"GET {url} - Headers: {headers} - Params: {params_dict}")
+        response = requests.get(url, headers=headers, params=params_dict)
+        _logger.info(f"Response status: {response.status_code} - Response text: {response.text}")
+        if not response.ok:
+            raise Exception(f"error in searching products {response.text}")
+        return SearchProduct(**response.json())