producteca 1.0.13__tar.gz → 2.0.14__tar.gz

{producteca-1.0.13 → producteca-2.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: producteca
-Version: 1.0.13
+Version: 2.0.14
 Summary: 
 Author: Chroma Agency, Matias Rivera
 Author-email: mrivera@chroma.agency
@@ -38,10 +38,40 @@ To use the Producteca client, first instantiate `ProductecaClient` with your cre
 from producteca.client import ProductecaClient
 
 client = ProductecaClient(token='your_token', api_key='your_api_key')
+
+# Usage examples for SalesOrderService
+sale_order_service = client.SalesOrder
+# Get from api
+sale_order = sale_order_service.get(123)
+# or construct from db
+sale_order = client.SalesOrder(...argswithid)
+labels = sale_order.get_shipping_labels()
+status_code, close_response = sale_order.close()
+status_code, cancel_response = sale_order.cancel()
+status_code, synchronized_order = sale_order.synchronize()
+status_code, invoice_response = sale_order.invoice_integration(sale_order)
+search_results = sale_order_service.search(params)
+payment = sale_order.add_payment(payment_payload)
+updated_payment = sale_order.update_payment(payment_id, payment_payload)
+shipment = sale_order.add_shipment(shipment_payload)
+updated_shipment = sale_order.update_shipment(shipment_id, shipment_payload)
+
+# Usage examples for ProductService
+product_service = client.Products
+# Get from api
+product = product_service.get(456)
+bundle = product_service.get_bundle(456)
+ml_integration = product_service.get_ml_integration(456)
+search_results = product_service.search(search_params)
+# Or construct from db
+product = client.Products(...args)
+created_product = product.create()
+updated_product = product.update()
 ```
 
 then with the client you should use every other module, like SalesOrder, Products, Payments, Shipments and Search
 
+
 ## Contributing
 
 We welcome contributions to improve this project! Here's how you can help:

{producteca-1.0.13 → producteca-2.0.14}/README.md

@@ -20,10 +20,40 @@ To use the Producteca client, first instantiate `ProductecaClient` with your cre
 from producteca.client import ProductecaClient
 
 client = ProductecaClient(token='your_token', api_key='your_api_key')
+
+# Usage examples for SalesOrderService
+sale_order_service = client.SalesOrder
+# Get from api
+sale_order = sale_order_service.get(123)
+# or construct from db
+sale_order = client.SalesOrder(...argswithid)
+labels = sale_order.get_shipping_labels()
+status_code, close_response = sale_order.close()
+status_code, cancel_response = sale_order.cancel()
+status_code, synchronized_order = sale_order.synchronize()
+status_code, invoice_response = sale_order.invoice_integration(sale_order)
+search_results = sale_order_service.search(params)
+payment = sale_order.add_payment(payment_payload)
+updated_payment = sale_order.update_payment(payment_id, payment_payload)
+shipment = sale_order.add_shipment(shipment_payload)
+updated_shipment = sale_order.update_shipment(shipment_id, shipment_payload)
+
+# Usage examples for ProductService
+product_service = client.Products
+# Get from api
+product = product_service.get(456)
+bundle = product_service.get_bundle(456)
+ml_integration = product_service.get_ml_integration(456)
+search_results = product_service.search(search_params)
+# Or construct from db
+product = client.Products(...args)
+created_product = product.create()
+updated_product = product.update()
 ```
 
 then with the client you should use every other module, like SalesOrder, Products, Payments, Shipments and Search
 
+
 ## Contributing
 
 We welcome contributions to improve this project! Here's how you can help:

producteca-2.0.14/producteca/abstract/abstract_dataclass.py

@@ -0,0 +1,11 @@
+from abc import ABC
+from ..config.config import ConfigProducteca
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class BaseService[T](ABC):
+    config: ConfigProducteca
+    endpoint: str
+    _record: Optional[T] = None

producteca-2.0.14/producteca/client.py

@@ -0,0 +1,22 @@
+from producteca.config.config import ConfigProducteca
+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.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 ProductService(self.config)
+
+    @property
+    def SalesOrder(self):
+        return SaleOrderService(self.config)

{producteca-1.0.13 → producteca-2.0.14}/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):
@@ -32,14 +30,4 @@ class Payment(BaseModel):
     hasCancelableStatus: bool
     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-1.0.13 → producteca-2.0.14}/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,7 @@ 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).add_payment(payment)
         
         # Assertions
         mock_post.assert_called_once()
@@ -55,7 +55,7 @@ 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).update_payment(self.payment_id, payment)
         
         # Assertions
         mock_put.assert_called_once()

{producteca-1.0.13 → producteca-2.0.14}/producteca/products/products.py

@@ -1,20 +1,23 @@
 from typing import List, Optional, Union
 from pydantic import BaseModel, Field
-import requests
-from ..config.config import ConfigProducteca
+from dataclasses import dataclass
+from producteca.abstract.abstract_dataclass import BaseService
+from producteca.products.search_products import SearchProduct, SearchProductParams
 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 +25,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 +40,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,6 +65,7 @@ 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
@@ -71,11 +80,15 @@ class Variation(BaseModel):
     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 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
     code: Optional[str] = None
@@ -85,7 +98,7 @@ class Product(BaseModel):
     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
+    category: Optional[Union[str, MeliCategory]]
     brand: Optional[str] = None
     notes: Optional[str] = None
     deals: Optional[List[Deal]] = None
@@ -94,60 +107,6 @@ class Product(BaseModel):
     pictures: Optional[List[Picture]] = 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
-
-    @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
-
-# 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')
     mode: Optional[str] = None
@@ -156,9 +115,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,13 +127,14 @@ class AttributeCompletion(BaseModel):
     count: Optional[int] = None
     total: Optional[int] = None
 
+
 class MeliProduct(Product):
     product_id: Optional[int] = Field(default=None, alias='productId')
     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[MeliCategory] = None
+    category: Optional[Union[str, MeliCategory]]  # will never be str, but needs compat with super class
     attribute_completion: Optional[AttributeCompletion] = Field(default=None, alias='attributeCompletion')
     catalog_products: Optional[List[str]] = Field(default=None, alias='catalogProducts')
     warranty: Optional[str] = None
@@ -180,3 +142,66 @@ class MeliProduct(Product):
     listing_type_id: Optional[str] = Field(default=None, alias='listingTypeId')
     catalog_products_status: Optional[str] = Field(default=None, alias='catalogProductsStatus')
 
+
+@dataclass
+class ProductService(BaseService[Product]):
+    endpoint: str = Field(default='products', exclude=True)
+    create_if_it_doesnt_exist: bool = Field(default=False, exclude=True)
+
+    def __call__(self, **payload):
+        self._record = Product(**payload)
+        return self
+
+    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._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())
+
+    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 response.status_code == 204:
+            raise Exception("Product does not exist and the request cant create if it does not exist")
+        return Product(**response.json())
+
+    def get(self, product_id: int) -> "Product":
+        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)
+
+    def get_bundle(self, product_id: int) -> "Product":
+        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())
+
+    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())
+
+    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))
+        return SearchProduct(**response.json())

producteca-1.0.13/producteca/search/search.py → producteca-2.0.14/producteca/products/search_products.py

@@ -1,7 +1,5 @@
 from typing import List, Optional
 from pydantic import BaseModel, Field
-import requests
-from ..config.config import ConfigProducteca
 
 
 class FacetValue(BaseModel):
@@ -124,7 +122,7 @@ class SearchResultItem(BaseModel):
     channel_pictures_templates_apps: Optional[List[str]]
 
 
-class SearchProductResponse(BaseModel):
+class SearchProduct(BaseModel):
     count: int
     facets: List[Facet]
     results: List[SearchResultItem]
@@ -138,12 +136,4 @@ class SearchProductParams(BaseModel):
     sales_channel: Optional[str] = Field(default='2', alias='salesChannel')
 
 
-class SearchProduct:
-    endpoint: str = 'search/products'
 
-    @classmethod
-    def search_product(cls, config: ConfigProducteca, params: SearchProductParams) -> SearchProductResponse:
-        headers = config.headers
-        url = config.get_endpoint(cls.endpoint)
-        response = requests.get(url, headers=headers, params=params.model_dump(by_alias=True, exclude_none=True))
-        return SearchProductResponse(**response.json())

{producteca-1.0.13 → producteca-2.0.14}/producteca/products/tests/test_products.py

@@ -1,17 +1,17 @@
 import unittest
 from unittest.mock import patch, Mock
-from producteca.config.config import ConfigProducteca
-from producteca.products.products import Product, MeliProduct
+from producteca.products.products import Product
+from producteca.client import ProductecaClient
 
 
 class TestProduct(unittest.TestCase):
     def setUp(self):
-        self.config = ConfigProducteca(token="test_id", api_key="test_secret")
+        self.client = ProductecaClient(token="test_client_id", api_key="test_client_secret")
         self.test_product = Product(
-            config=self.config,
             sku="TEST001",
             name="Test Product",
-            code="TEST001"
+            code="TEST001",
+            category="Test"
         )
 
     @patch('requests.post')
@@ -19,13 +19,12 @@ class TestProduct(unittest.TestCase):
         # Mock successful response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"id": 1, "sku": "TEST001"}
+        mock_response.json.return_value = self.test_product.model_dump()
         mock_post.return_value = mock_response
 
-        response, status_code = self.test_product.create()
+        response = self.client.Product(**self.test_product.model_dump()).create()
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["sku"], "TEST001")
+        self.assertEqual(response.sku, "TEST001")
 
     @patch('requests.post')
     def test_create_product_not_exist(self, mock_post):
@@ -34,48 +33,45 @@ class TestProduct(unittest.TestCase):
         mock_response.status_code = 204
         mock_post.return_value = mock_response
 
-        response, status_code = self.test_product.create()
-        
-        self.assertEqual(status_code, 204)
-        self.assertEqual(response["Message"], "Product does not exist and the request cant create if it does not exist")
+        with self.assertRaises(Exception):
+            self.client.Product.create()
 
     @patch('requests.post')
     def test_update_product_success(self, mock_post):
         # Mock successful update
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"id": 1, "sku": "TEST001", "name": "Updated Product"}
+        mock_response.json.return_value = self.test_product.model_dump()
         mock_post.return_value = mock_response
 
-        response, status_code = self.test_product.update()
+        response = self.client.Product(**self.test_product.model_dump()).update()
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["name"], "Updated Product")
+        self.assertEqual(response.name, "Test Product")
 
     @patch('requests.get')
     def test_get_product(self, mock_get):
         # Mock get product response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"id": 1, "sku": "TEST001"}
+        mock_response.json.return_value = self.test_product.model_dump()
         mock_get.return_value = mock_response
 
-        response, status_code = Product.get(self.config, 1)
+        response = self.client.Product.get(1)
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["sku"], "TEST001")
+        self.assertEqual(response.sku, "TEST001")
 
     @patch('requests.get')
     def test_get_bundle(self, mock_get):
         # Mock get bundle response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"sku": "TEST001", "bundles": []}
+        test_prod = self.test_product.model_dump()
+        test_prod.update({"sku": "TEST001", "bundles": []})
+        mock_response.json.return_value = test_prod
         mock_get.return_value = mock_response
 
-        product, status_code = Product.get_bundle(self.config, 1)
+        product = self.client.Product.get_bundle(1)
         
-        self.assertEqual(status_code, 200)
         self.assertEqual(product.sku, "TEST001")
 
     @patch('requests.get')
@@ -83,13 +79,15 @@ class TestProduct(unittest.TestCase):
         # Mock ML integration response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"sku": "TEST001", "integrations": []}
+        test_prod = self.test_product.model_dump()
+        test_prod.update({"sku": "TEST001", "integrations": []})
+        mock_response.json.return_value = test_prod
         mock_get.return_value = mock_response
 
-        product, status_code = Product.get_ml_integration(self.config, 1)
+        product = self.client.Product.get_ml_integration(1)
         
-        self.assertEqual(status_code, 200)
         self.assertEqual(product.sku, "TEST001")
 
+
 if __name__ == '__main__':
     unittest.main()