vtexpy 0.0.0b16__py3-none-any.whl → 0.0.0b18__py3-none-any.whl

vtex/__init__.py

@@ -1,4 +1,5 @@
 from . import _constants as VTEXConstants  # noqa: N812
+from ._config import VTEXConfig
 from ._dto import (
     VTEXCartItem,
     VTEXDataResponse,
@@ -12,6 +13,7 @@ from ._vtex import VTEX
 __all__ = [
     "VTEX",
     "VTEXCartItem",
+    "VTEXConfig",
     "VTEXConstants",
     "VTEXError",
     "VTEXDataResponse",

vtex/_api/base.py

@@ -1,6 +1,5 @@
 from http import HTTPStatus
 from json import JSONDecodeError
-from logging import WARNING
 from typing import Any, Type, Union, cast
 from urllib.parse import urljoin
 
@@ -26,11 +25,11 @@ from tenacity import (
     wait_exponential,
 )
 
-from .._config import Config  # type: ignore[attr-defined]
+from .._config import VTEXConfig
 from .._constants import APP_KEY_HEADER, APP_TOKEN_HEADER
 from .._dto import VTEXDataResponse, VTEXResponseType
 from .._exceptions import VTEXRequestError, VTEXResponseError
-from .._logging import get_logger, log_before_retry
+from .._logging import disable_loggers, get_logger, log_before_retry
 from .._types import HTTPMethodType
 from .._utils import redact_headers, to_snake_case, to_snake_case_deep
 from .._vtex import VTEX
@@ -60,58 +59,89 @@ class BaseAPI:
         data: Union[RequestData, None] = None,
         content: Union[RequestContent, None] = None,
         files: Union[RequestFiles, None] = None,
-        config: Union[Config, None] = None,
+        config: Union[VTEXConfig, None] = None,
         response_class: Union[Type[VTEXResponseType], None] = None,
+        **kwargs: Any,
     ) -> VTEXResponseType:
-        request_config = config or self.client.config
+        request_config = (config or self.client.config).with_overrides(**kwargs)
 
         url = urljoin(
-            f"https://{request_config.get_account_name()}.{environment}.com.br",
+            f"https://{request_config.account_name}.{environment}.com.br",
             endpoint,
         )
 
         headers = Headers(headers=headers)
-        headers[APP_KEY_HEADER] = request_config.get_app_key()
-        headers[APP_TOKEN_HEADER] = request_config.get_app_token()
+        headers[APP_KEY_HEADER] = request_config.app_key.get_secret_value()
+        headers[APP_TOKEN_HEADER] = request_config.app_token.get_secret_value()
         headers["Content-Type"] = "application/json; charset=utf-8"
         headers["Accept"] = "application/json"
 
         @retry(
             stop=stop_after_attempt(
-                max_attempt_number=request_config.get_retry_attempts() + 1,
+                max_attempt_number=request_config.retry_attempts + 1,
             ),
             wait=wait_exponential(
-                min=request_config.get_retry_backoff_min(),
-                max=request_config.get_retry_backoff_max(),
-                exp_base=request_config.get_retry_backoff_exponential(),
+                min=request_config.retry_backoff_min,
+                max=request_config.retry_backoff_max,
+                exp_base=2.0,
             ),
-            retry=retry_if_exception_type(exception_types=HTTPError),
+            retry=retry_if_exception_type(exception_types=HTTPStatusError),
             before_sleep=(
-                log_before_retry(logger=self.logger, log_level=WARNING)
-                if request_config.get_retry_logs()
+                log_before_retry(
+                    logger=self.logger,
+                    log_level=request_config.log_retries,
+                    environment=environment,
+                    endpoint=endpoint,
+                    account_name=request_config.account_name,
+                )
+                if request_config.log_retries is not False
                 else None
             ),
             reraise=True,
         )
         def send_vtex_request() -> Response:
-            with Client(timeout=request_config.get_timeout()) as client:
-                response = client.request(
-                    method.upper(),
-                    url,
-                    headers=headers,
-                    cookies=cookies,
-                    params=params,
-                    json=json,
-                    data=data,
-                    content=content,
-                    files=files,
-                )
+            with Client(timeout=request_config.timeout) as client:
+                with disable_loggers(["httpcore", "httpx"]):
+                    response = client.request(
+                        method.upper(),
+                        url,
+                        headers=headers,
+                        cookies=cookies,
+                        params=params,
+                        json=json,
+                        data=data,
+                        content=content,
+                        files=files,
+                    )
 
                 response.request.headers = Headers(
                     redact_headers(dict(response.request.headers)),
                 )
                 response.headers = Headers(redact_headers(dict(response.headers)))
-                if response.status_code in request_config.get_retry_statuses():
+
+                for should_log, log_level in [
+                    (response.is_informational, request_config.log_1xx),
+                    (response.is_success, request_config.log_2xx),
+                    (response.is_redirect, request_config.log_3xx),
+                    (response.is_client_error, request_config.log_4xx),
+                    (response.is_server_error, request_config.log_5xx),
+                ]:
+                    if should_log and log_level:
+                        self.logger.log(
+                            log_level,
+                            f"{response.request.method} {response.request.url} "
+                            f"{response.status_code} {response.reason_phrase}",
+                            extra={
+                                "method": response.request.method,
+                                "url": response.request.url,
+                                "status": response.status_code,
+                                "environment": environment,
+                                "endpoint": endpoint,
+                                "account_name": request_config.account_name,
+                            },
+                        )
+
+                if response.status_code in request_config.retry_statuses:
                     response.raise_for_status()
 
                 return response
@@ -141,14 +171,14 @@ class BaseAPI:
             (response_class or VTEXDataResponse).factory(response),
         )
 
-    def _raise_from_response(self, response: Response, config: Config) -> None:
-        if response.is_error and config.get_raise_for_status():
+    def _raise_from_response(self, response: Response, config: VTEXConfig) -> None:
+        if response.is_error and config.raise_for_status:
             try:
                 data = to_snake_case_deep(response.json(strict=False))
             except JSONDecodeError:
                 data = response.text or HTTPStatus(response.status_code).phrase
 
-            error = VTEXResponseError(
+            raise VTEXResponseError(
                 data,
                 method=str(response.request.method).upper(),
                 url=str(response.request.url),
@@ -156,11 +186,4 @@ class BaseAPI:
                 status=response.status_code,
                 data=data,
                 response_headers=response.headers,
-            )
-
-            if response.is_server_error:
-                self.logger.error(data, extra=error.to_dict())
-            else:
-                self.logger.warning(data, extra=error.to_dict())
-
-            raise error from None
+            ) from None

vtex/_api/catalog.py

@@ -10,9 +10,9 @@ from .._constants import (
 )
 from .._dto import VTEXDataResponse, VTEXItemsResponse, VTEXPaginatedItemsResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
-from .._types import DictType
-from .._utils import exclude_undefined_values
+from .._utils import omitting_undefined
 from .base import BaseAPI
+from .types.catalog import SalesChannel, Seller
 
 
 class CatalogAPI(BaseAPI):
@@ -29,18 +29,30 @@ class CatalogAPI(BaseAPI):
         seller_type: Union[int, UndefinedSentinel] = UNDEFINED,
         is_better_scope: Union[bool, UndefinedSentinel] = UNDEFINED,
         **kwargs: Any,
-    ) -> VTEXItemsResponse[DictType, DictType]:
+    ) -> VTEXItemsResponse[List[Seller], Seller]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint="/api/catalog_system/pvt/seller/list",
-            params=exclude_undefined_values({
+            params=omitting_undefined({
                 "sc": sales_channel,
                 "sellerType": seller_type,
                 "isBetterScope": is_better_scope,
             }),
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXItemsResponse[DictType, DictType],
+            response_class=VTEXItemsResponse[Any, Any],
+        )
+
+    def list_sales_channels(
+        self,
+        **kwargs: Any,
+    ) -> VTEXItemsResponse[List[SalesChannel], SalesChannel]:
+        return self._request(
+            method="GET",
+            environment=self.ENVIRONMENT,
+            endpoint="/api/catalog_system/pvt/saleschannel/list",
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXItemsResponse[Any, Any],
         )
 
     def list_sku_ids(
@@ -68,13 +80,13 @@ class CatalogAPI(BaseAPI):
         self,
         sku_id: int,
         **kwargs: Any,
-    ) -> VTEXDataResponse[DictType]:
+    ) -> VTEXDataResponse[Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/catalog_system/pvt/sku/stockkeepingunitbyid/{sku_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )
 
     def list_categories(
@@ -82,7 +94,7 @@ class CatalogAPI(BaseAPI):
         page: int = LIST_SKU_IDS_START_PAGE,
         page_size: int = LIST_SKU_IDS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
+    ) -> VTEXPaginatedItemsResponse[Any, Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -95,31 +107,31 @@ class CatalogAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
+            response_class=VTEXPaginatedItemsResponse[Any, Any],
         )
 
     def get_category_tree(
         self,
         levels: int = GET_CATEGORY_TREE_MAX_LEVELS,
         **kwargs: Any,
-    ) -> VTEXDataResponse[DictType]:
+    ) -> VTEXDataResponse[Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/catalog_system/pub/category/tree/{levels}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )
 
     def get_category(
         self,
-        category_id: str,
+        category_id: int,
         **kwargs: Any,
-    ) -> VTEXDataResponse[DictType]:
+    ) -> VTEXDataResponse[Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/catalog/pvt/category/{category_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )

vtex/_api/checkout.py

@@ -2,8 +2,7 @@ from typing import Any, List, Union
 
 from .._dto import VTEXCartItem, VTEXDataResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
-from .._types import DictType
-from .._utils import exclude_undefined_values
+from .._utils import omitting_undefined
 from .base import BaseAPI
 
 
@@ -25,22 +24,22 @@ class CheckoutAPI(BaseAPI):
         sales_channel: Union[int, UndefinedSentinel] = UNDEFINED,
         individual_shipping_estimates: Union[bool, UndefinedSentinel] = UNDEFINED,
         **kwargs: Any,
-    ) -> VTEXDataResponse[DictType]:
+    ) -> VTEXDataResponse[Any]:
         return self._request(
             method="POST",
             environment=self.ENVIRONMENT,
             endpoint="/api/checkout/pub/orderForms/simulation",
-            params=exclude_undefined_values({
+            params=omitting_undefined({
                 "RnbBehavior": rnb_behavior,
                 "sc": sales_channel,
                 "individualShippingEstimates": individual_shipping_estimates,
             }),
-            json=exclude_undefined_values({
+            json=omitting_undefined({
                 "items": [item.to_vtex_cart_item() for item in cart],
                 "country": country,
                 "postalCode": postal_code,
                 "geoCoordinates": geo_coordinates,
             }),
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )

vtex/_api/custom.py

@@ -10,10 +10,13 @@ from httpx._types import (
     RequestFiles,
 )
 
+from .. import VTEXError
 from .._dto import VTEXResponseType
 from .._types import HTTPMethodType
 from .._utils import to_datetime
 from .base import BaseAPI
+from .types.catalog import Seller
+from .types.license_manager import AccountSite
 
 
 class CustomAPI(BaseAPI):
@@ -55,31 +58,37 @@ class CustomAPI(BaseAPI):
     def get_account_name(self) -> str:
         return self.client.license_manager.get_account().data["account_name"]
 
-    def get_account_creation_date(self) -> datetime:
+    def get_creation_date(self) -> datetime:
         return to_datetime(
             self.client.license_manager.get_account().data["creation_date"],
         )
 
-    def get_account_site_names(self) -> datetime:
-        return to_datetime(
-            self.client.license_manager.get_account().data["creation_date"],
-        )
+    def list_sites(self) -> List[AccountSite]:
+        return self.client.license_manager.get_account().data["sites"]
 
-    def get_main_seller(self) -> str:
-        return "1"
+    def get_main_seller(self) -> Seller:
+        for seller in self.client.catalog.list_sellers().items:
+            if seller["seller_type"] == 1 and seller["seller_id"] == "1":
+                return seller
 
-    def get_market_place_sellers(self, include_inactive: bool = False) -> List[str]:
+        raise VTEXError("Could not find main seller")
+
+    def list_market_place_sellers(
+        self,
+        include_inactive: bool = False,
+        include_main: bool = False,
+    ) -> List[Seller]:
         return [
-            seller["seller_id"]
+            seller
             for seller in self.client.catalog.list_sellers().items
             if seller["seller_type"] == 1
-            and seller["seller_id"] != "1"
-            and (seller["is_active"] or include_inactive)
+            and (include_main or seller["seller_id"] != "1")
+            and (include_inactive or seller["is_active"])
         ]
 
-    def get_franchise_sellers(self, include_inactive: bool = False) -> List[str]:
+    def list_franchise_sellers(self, include_inactive: bool = False) -> List[Seller]:
         return [
-            seller["seller_id"]
+            seller
             for seller in self.client.catalog.list_sellers().items
-            if seller["seller_type"] == 2 and (seller["is_active"] or include_inactive)
+            if seller["seller_type"] == 2 and (include_inactive or seller["is_active"])
         ]

vtex/_api/license_manager.py

@@ -38,7 +38,7 @@ class LicenseManagerAPI(BaseAPI):
                 for app_key in self.get_account().data["app_keys"]
             }
 
-            user_id = app_keys[config.get_app_key()]["id"]
+            user_id = app_keys[config.app_key.get_secret_value()]["id"]
 
         return self._request(
             method="GET",

vtex/_api/logistics.py

@@ -10,7 +10,6 @@ from .._constants import (
     MIN_PAGE_SIZE,
 )
 from .._dto import VTEXDataResponse, VTEXPaginatedItemsResponse
-from .._types import DictType
 from .base import BaseAPI
 
 
@@ -27,7 +26,7 @@ class LogisticsAPI(BaseAPI):
         page: int = LIST_SHIPPING_POLICIES_START_PAGE,
         page_size: int = LIST_SHIPPING_POLICIES_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
+    ) -> VTEXPaginatedItemsResponse[Any, Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -40,20 +39,20 @@ class LogisticsAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
+            response_class=VTEXPaginatedItemsResponse[Any, Any],
         )
 
     def get_shipping_policy(
         self,
         shipping_policy_id: str,
         **kwargs: Any,
-    ) -> VTEXDataResponse[DictType]:
+    ) -> VTEXDataResponse[Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/logistics/pvt/shipping-policies/{shipping_policy_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )
 
     def list_carriers(
@@ -61,7 +60,7 @@ class LogisticsAPI(BaseAPI):
         page: int = LIST_CARRIERS_START_PAGE,
         page_size: int = LIST_CARRIERS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
+    ) -> VTEXPaginatedItemsResponse[Any, Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -74,20 +73,20 @@ class LogisticsAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
+            response_class=VTEXPaginatedItemsResponse[Any, Any],
         )
 
     def get_carrier(
         self,
         carrier_id: str,
         **kwargs: Any,
-    ) -> VTEXDataResponse[DictType]:
+    ) -> VTEXDataResponse[Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/logistics/pvt/configuration/carriers/{carrier_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )
 
     def list_docks(
@@ -95,7 +94,7 @@ class LogisticsAPI(BaseAPI):
         page: int = LIST_DOCKS_START_PAGE,
         page_size: int = LIST_DOCKS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
+    ) -> VTEXPaginatedItemsResponse[Any, Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -108,27 +107,27 @@ class LogisticsAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
+            response_class=VTEXPaginatedItemsResponse[Any, Any],
         )
 
-    def get_dock(self, dock_id: str, **kwargs: Any) -> VTEXDataResponse[DictType]:
+    def get_dock(self, dock_id: str, **kwargs: Any) -> VTEXDataResponse[Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/logistics/pvt/configuration/docks/{dock_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )
 
     def get_sku_inventories(
         self,
         sku_id: str,
         **kwargs: Any,
-    ) -> VTEXDataResponse[DictType]:
+    ) -> VTEXDataResponse[Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/logistics/pvt/inventory/skus/{sku_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )

vtex/_api/master_data.py

@@ -7,8 +7,8 @@ from .._constants import (
 )
 from .._dto import VTEXPaginatedItemsResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
-from .._types import DictType, OrderingDirectionType
-from .._utils import exclude_undefined_values
+from .._types import OrderingDirectionType
+from .._utils import omitting_undefined
 from .base import BaseAPI
 
 
@@ -30,7 +30,7 @@ class MasterDataAPI(BaseAPI):
         page: int = SEARCH_DOCUMENTS_START_PAGE,
         page_size: int = SEARCH_DOCUMENTS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
+    ) -> VTEXPaginatedItemsResponse[Any, Any]:
         params = {
             "_where": where,
             "_sort": f"{order_by_field} {order_by_direction.upper()}",
@@ -53,10 +53,10 @@ class MasterDataAPI(BaseAPI):
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/dataentities/{entity_name}/search",
-            params=exclude_undefined_values(params),
+            params=omitting_undefined(params),
             headers={
                 "REST-Range": f"resources={(page - 1) * page_size}-{page * page_size}",
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
+            response_class=VTEXPaginatedItemsResponse[Any, Any],
         )

vtex/_api/orders.py

@@ -10,7 +10,7 @@ from .._constants import (
 )
 from .._dto import VTEXDataResponse, VTEXItemsResponse, VTEXPaginatedItemsResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
-from .._types import DictType, OrderingDirectionType
+from .._types import OrderingDirectionType
 from .._utils import now, three_years_ago
 from .base import BaseAPI
 
@@ -35,7 +35,7 @@ class OrdersAPI(BaseAPI):
         page: int = LIST_ORDERS_START_PAGE,
         page_size: int = LIST_ORDERS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
+    ) -> VTEXPaginatedItemsResponse[Any, Any]:
         if page > LIST_ORDERS_MAX_PAGE:
             raise ValueError("List Orders endpoint can only return up to page 30")
 
@@ -84,7 +84,7 @@ class OrdersAPI(BaseAPI):
             endpoint="/api/oms/pvt/orders/",
             params=params,
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
+            response_class=VTEXPaginatedItemsResponse[Any, Any],
         )
 
         pagination = response.pagination
@@ -93,20 +93,20 @@ class OrdersAPI(BaseAPI):
 
         return response
 
-    def get_order(self, order_id: str, **kwargs: Any) -> VTEXDataResponse[DictType]:
+    def get_order(self, order_id: str, **kwargs: Any) -> VTEXDataResponse[Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/oms/pvt/orders/{order_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )
 
     def list_feed_orders(
         self,
         page_size: int = LIST_FEED_ORDERS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXItemsResponse[DictType, DictType]:
+    ) -> VTEXItemsResponse[Any, Any]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -118,14 +118,14 @@ class OrdersAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXItemsResponse[DictType, DictType],
+            response_class=VTEXItemsResponse[Any, Any],
         )
 
     def commit_feed_orders(
         self,
         handles: List[str],
         **kwargs: Any,
-    ) -> VTEXDataResponse[DictType]:
+    ) -> VTEXDataResponse[Any]:
         if not handles:
             raise ValueError(
                 "At least one handle must be provided to commit to the feed"
@@ -142,5 +142,5 @@ class OrdersAPI(BaseAPI):
             endpoint="/api/orders/feed/",
             json={"handles": handles},
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXDataResponse[DictType],
+            response_class=VTEXDataResponse[Any],
         )