vtexpy 0.0.0b10__py3-none-any.whl → 0.0.0b11__py3-none-any.whl

vtex/__init__.py

@@ -1,10 +1,10 @@
 from . import _constants as VTEXConstants  # noqa: N812
 from ._dto import (
     VTEXCartItem,
-    VTEXListResponse,
-    VTEXPaginatedListResponse,
+    VTEXDataResponse,
+    VTEXItemsResponse,
+    VTEXPaginatedItemsResponse,
     VTEXResponse,
-    VTEXScrollListResponse,
 )
 from ._exceptions import VTEXError, VTEXRequestError, VTEXResponseError
 from ._vtex import VTEX
@@ -14,12 +14,12 @@ __all__ = [
     "VTEXCartItem",
     "VTEXConstants",
     "VTEXError",
-    "VTEXListResponse",
-    "VTEXPaginatedListResponse",
+    "VTEXDataResponse",
+    "VTEXItemsResponse",
+    "VTEXPaginatedItemsResponse",
     "VTEXRequestError",
     "VTEXResponse",
     "VTEXResponseError",
-    "VTEXScrollListResponse",
 ]
 
 

vtex/_api/base.py

@@ -28,7 +28,7 @@ from tenacity import (
 
 from .._config import Config  # type: ignore[attr-defined]
 from .._constants import APP_KEY_HEADER, APP_TOKEN_HEADER
-from .._dto import VTEXResponse, VTEXResponseType
+from .._dto import VTEXDataResponse, VTEXResponseType
 from .._exceptions import VTEXRequestError, VTEXResponseError
 from .._logging import get_logger, log_before_retry
 from .._types import HTTPMethodType
@@ -38,7 +38,7 @@ from .._vtex import VTEX
 
 class BaseAPI:
     """
-    Base client for VTEX API.
+    Base client for a VTEX API.
     """
 
     def __init__(self, client: VTEX) -> None:
@@ -138,7 +138,7 @@ class BaseAPI:
 
         return cast(
             VTEXResponseType,
-            (response_class or VTEXResponse).factory(response),
+            (response_class or VTEXDataResponse).factory(response),
         )
 
     def _raise_from_response(self, response: Response, config: Config) -> None:

vtex/_api/catalog.py

@@ -1,6 +1,5 @@
-from typing import Any, Union
+from typing import Any, List, Union
 
-from .. import VTEXPaginatedListResponse
 from .._constants import (
     GET_CATEGORY_TREE_MAX_LEVELS,
     LIST_CATEGORIES_MAX_PAGE_SIZE,
@@ -9,8 +8,9 @@ from .._constants import (
     LIST_SKU_IDS_START_PAGE,
     MIN_PAGE_SIZE,
 )
-from .._dto import VTEXListResponse, VTEXResponse
+from .._dto import VTEXDataResponse, VTEXItemsResponse, VTEXPaginatedItemsResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
+from .._types import DictType
 from .._utils import exclude_undefined_values
 from .base import BaseAPI
 
@@ -29,7 +29,7 @@ class CatalogAPI(BaseAPI):
         seller_type: Union[int, UndefinedSentinel] = UNDEFINED,
         is_better_scope: Union[bool, UndefinedSentinel] = UNDEFINED,
         **kwargs: Any,
-    ) -> VTEXListResponse:
+    ) -> VTEXItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -40,7 +40,7 @@ class CatalogAPI(BaseAPI):
                 "isBetterScope": is_better_scope,
             }),
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            response_class=VTEXItemsResponse[DictType, DictType],
         )
 
     def list_sku_ids(
@@ -48,7 +48,7 @@ class CatalogAPI(BaseAPI):
         page: int = LIST_SKU_IDS_START_PAGE,
         page_size: int = LIST_SKU_IDS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXListResponse:
+    ) -> VTEXItemsResponse[List[str], str]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -61,16 +61,20 @@ class CatalogAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            response_class=VTEXItemsResponse[List[str], str],
         )
 
-    def get_sku_with_context(self, sku_id: int, **kwargs: Any) -> VTEXResponse:
+    def get_sku_with_context(
+        self,
+        sku_id: int,
+        **kwargs: Any,
+    ) -> VTEXDataResponse[DictType]:
         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=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def list_categories(
@@ -78,7 +82,7 @@ class CatalogAPI(BaseAPI):
         page: int = LIST_SKU_IDS_START_PAGE,
         page_size: int = LIST_SKU_IDS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -91,27 +95,31 @@ class CatalogAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
     def get_category_tree(
         self,
         levels: int = GET_CATEGORY_TREE_MAX_LEVELS,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         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=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
-    def get_category(self, category_id: str, **kwargs: Any) -> VTEXResponse:
+    def get_category(
+        self,
+        category_id: str,
+        **kwargs: Any,
+    ) -> VTEXDataResponse[DictType]:
         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=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/checkout.py

@@ -1,7 +1,8 @@
 from typing import Any, List, Union
 
-from .._dto import VTEXCartItem, VTEXResponse
+from .._dto import VTEXCartItem, VTEXDataResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
+from .._types import DictType
 from .._utils import exclude_undefined_values
 from .base import BaseAPI
 
@@ -14,7 +15,7 @@ class CheckoutAPI(BaseAPI):
 
     ENVIRONMENT = "vtexcommercestable"
 
-    def cart_simulation(
+    def run_cart_simulation(
         self,
         cart: List[VTEXCartItem],
         country: Union[str, UndefinedSentinel] = UNDEFINED,
@@ -24,7 +25,7 @@ class CheckoutAPI(BaseAPI):
         sales_channel: Union[int, UndefinedSentinel] = UNDEFINED,
         individual_shipping_estimates: Union[bool, UndefinedSentinel] = UNDEFINED,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="POST",
             environment=self.ENVIRONMENT,
@@ -41,5 +42,5 @@ class CheckoutAPI(BaseAPI):
                 "geoCoordinates": geo_coordinates,
             }),
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/custom.py

@@ -60,6 +60,11 @@ class CustomAPI(BaseAPI):
             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 get_main_seller(self) -> str:
         return "1"
 
@@ -73,6 +78,5 @@ class CustomAPI(BaseAPI):
     def get_franchise_sellers(self) -> List[str]:
         return [
             seller["seller_id"]
-            for seller in
-            self.client.catalog.list_sellers(seller_type=2).items
+            for seller in self.client.catalog.list_sellers(seller_type=2).items
         ]

vtex/_api/license_manager.py

@@ -1,7 +1,8 @@
 from typing import Any
 
-from .._dto import VTEXResponse
+from .._dto import VTEXDataResponse
 from .base import BaseAPI
+from .types.license_manager import GetAccountData
 
 
 class LicenseManagerAPI(BaseAPI):
@@ -12,11 +13,11 @@ class LicenseManagerAPI(BaseAPI):
 
     ENVIRONMENT = "vtexcommercestable"
 
-    def get_account(self, **kwargs: Any) -> VTEXResponse:
+    def get_account(self, **kwargs: Any) -> VTEXDataResponse[GetAccountData]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint="/api/vlm/account",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[GetAccountData],
         )

vtex/_api/logistics.py

@@ -9,7 +9,8 @@ from .._constants import (
     LIST_SHIPPING_POLICIES_START_PAGE,
     MIN_PAGE_SIZE,
 )
-from .._dto import VTEXPaginatedListResponse, VTEXResponse
+from .._dto import VTEXDataResponse, VTEXPaginatedItemsResponse
+from .._types import DictType
 from .base import BaseAPI
 
 
@@ -26,7 +27,7 @@ class LogisticsAPI(BaseAPI):
         page: int = LIST_SHIPPING_POLICIES_START_PAGE,
         page_size: int = LIST_SHIPPING_POLICIES_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -39,20 +40,20 @@ class LogisticsAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
     def get_shipping_policy(
         self,
         shipping_policy_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         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=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def list_carriers(
@@ -60,7 +61,7 @@ class LogisticsAPI(BaseAPI):
         page: int = LIST_CARRIERS_START_PAGE,
         page_size: int = LIST_CARRIERS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -73,20 +74,20 @@ class LogisticsAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
     def get_carrier(
         self,
         carrier_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         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=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def list_docks(
@@ -94,7 +95,7 @@ class LogisticsAPI(BaseAPI):
         page: int = LIST_DOCKS_START_PAGE,
         page_size: int = LIST_DOCKS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -107,23 +108,27 @@ class LogisticsAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
-    def get_dock(self, dock_id: str, **kwargs: Any) -> VTEXResponse:
+    def get_dock(self, dock_id: str, **kwargs: Any) -> VTEXDataResponse[DictType]:
         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=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
-    def get_sku_inventories(self, sku_id: str, **kwargs: Any) -> VTEXResponse:
+    def get_sku_inventories(
+        self,
+        sku_id: str,
+        **kwargs: Any,
+    ) -> VTEXDataResponse[DictType]:
         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=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/master_data.py

@@ -1,13 +1,13 @@
-from typing import Any, Iterable, Union
+from typing import Any, List, Union
 
 from .._constants import (
     MIN_PAGE_SIZE,
     SEARCH_DOCUMENTS_MAX_PAGE_SIZE,
     SEARCH_DOCUMENTS_START_PAGE,
 )
-from .._dto import VTEXPaginatedListResponse
+from .._dto import VTEXPaginatedItemsResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
-from .._types import IterableType, OrderingDirectionType
+from .._types import DictType, OrderingDirectionType
 from .._utils import exclude_undefined_values
 from .base import BaseAPI
 
@@ -20,17 +20,17 @@ class MasterDataAPI(BaseAPI):
 
     ENVIRONMENT = "vtexcommercestable"
 
-    def search_documents(
+    def list_documents(
         self,
         entity_name: str,
         where: Union[str, UndefinedSentinel] = UNDEFINED,
-        fields: Union[IterableType[str], str, UndefinedSentinel] = UNDEFINED,
+        fields: Union[List[str], str, UndefinedSentinel] = UNDEFINED,
         order_by_field: str = "id",
         order_by_direction: OrderingDirectionType = "DESC",
         page: int = SEARCH_DOCUMENTS_START_PAGE,
         page_size: int = SEARCH_DOCUMENTS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         params = {
             "_where": where,
             "_sort": f"{order_by_field} {order_by_direction.upper()}",
@@ -38,7 +38,7 @@ class MasterDataAPI(BaseAPI):
 
         if fields is UNDEFINED:
             params["_fields"] = "all"
-        elif not isinstance(fields, str) and isinstance(fields, Iterable):
+        elif not isinstance(fields, str) and isinstance(fields, list):
             params["_fields"] = ",".join(fields)
         else:
             params["_fields"] = fields
@@ -58,5 +58,5 @@ class MasterDataAPI(BaseAPI):
                 "REST-Range": f"resources={(page - 1) * page_size}-{page * page_size}",
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXPaginatedListResponse,
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )

vtex/_api/orders.py

@@ -1,5 +1,5 @@
 from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, Union
+from typing import Any, Dict, List, Union
 
 from .._constants import (
     LIST_FEED_ORDERS_MAX_PAGE_SIZE,
@@ -8,9 +8,9 @@ from .._constants import (
     LIST_ORDERS_START_PAGE,
     MIN_PAGE_SIZE,
 )
-from .._dto import VTEXListResponse, VTEXPaginatedListResponse, VTEXResponse
+from .._dto import VTEXDataResponse, VTEXItemsResponse, VTEXPaginatedItemsResponse
 from .._sentinels import UNDEFINED, UndefinedSentinel
-from .._types import IterableType, OrderingDirectionType
+from .._types import DictType, 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,
-    ) -> VTEXPaginatedListResponse:
+    ) -> VTEXPaginatedItemsResponse[DictType, DictType]:
         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=VTEXPaginatedListResponse,
+            response_class=VTEXPaginatedItemsResponse[DictType, DictType],
         )
 
         pagination = response.pagination
@@ -93,20 +93,20 @@ class OrdersAPI(BaseAPI):
 
         return response
 
-    def get_order(self, order_id: str, **kwargs: Any) -> VTEXResponse:
+    def get_order(self, order_id: str, **kwargs: Any) -> VTEXDataResponse[DictType]:
         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=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def list_feed_orders(
         self,
         page_size: int = LIST_FEED_ORDERS_MAX_PAGE_SIZE,
         **kwargs: Any,
-    ) -> VTEXListResponse:
+    ) -> VTEXItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
@@ -118,14 +118,14 @@ class OrdersAPI(BaseAPI):
                 ),
             },
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            response_class=VTEXItemsResponse[DictType, DictType],
         )
 
     def commit_feed_orders(
         self,
-        handles: IterableType[str],
+        handles: List[str],
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         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=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/payments_gateway.py

@@ -1,6 +1,7 @@
 from typing import Any
 
-from .._dto import VTEXListResponse, VTEXResponse
+from .._dto import VTEXDataResponse, VTEXItemsResponse
+from .._types import DictType
 from .base import BaseAPI
 
 
@@ -12,39 +13,43 @@ class PaymentsGatewayAPI(BaseAPI):
 
     ENVIRONMENT = "vtexpayments"
 
-    def get_transaction(self, transaction_id: str, **kwargs: Any) -> VTEXResponse:
+    def get_transaction(
+        self,
+        transaction_id: str,
+        **kwargs: Any,
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/pvt/transactions/{transaction_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def list_transaction_interactions(
         self,
         transaction_id: str,
         **kwargs: Any,
-    ) -> VTEXListResponse:
+    ) -> VTEXItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/pvt/transactions/{transaction_id}/interactions",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            response_class=VTEXItemsResponse[DictType, DictType],
         )
 
     def list_transaction_payments(
         self,
         transaction_id: str,
         **kwargs: Any,
-    ) -> VTEXListResponse:
+    ) -> VTEXItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/pvt/transactions/{transaction_id}/payments",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            response_class=VTEXItemsResponse[DictType, DictType],
         )
 
     def get_transaction_payment(
@@ -52,63 +57,63 @@ class PaymentsGatewayAPI(BaseAPI):
         transaction_id: str,
         payment_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/pvt/transactions/{transaction_id}/payments/{payment_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def get_transaction_capabilities(
         self,
         transaction_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/pvt/transactions/{transaction_id}/capabilities",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def get_transaction_cancellations(
         self,
         transaction_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/pvt/transactions/{transaction_id}/cancellations",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def get_transaction_refunds(
         self,
         transaction_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/pvt/transactions/{transaction_id}/refunds",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def get_transaction_settlements(
         self,
         transaction_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/pvt/transactions/{transaction_id}/settlements",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/promotions_and_taxes.py

@@ -1,7 +1,7 @@
 from typing import Any
 
-from .. import VTEXListResponse
-from .._dto import VTEXResponse
+from .._dto import VTEXDataResponse, VTEXItemsResponse
+from .._types import DictType
 from .base import BaseAPI
 
 
@@ -13,42 +13,45 @@ class PromotionsAndTaxesAPI(BaseAPI):
 
     ENVIRONMENT = "vtexcommercestable"
 
-    def list_archived_promotions(self, **kwargs: Any) -> VTEXListResponse:
+    def list_archived_promotions(
+        self,
+        **kwargs: Any,
+    ) -> VTEXItemsResponse[DictType, DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint="api/rnb/pvt/archive/benefits/calculatorconfiguration",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            response_class=VTEXItemsResponse[DictType, DictType],
         )
 
-    def list_promotions(self, **kwargs: Any) -> VTEXResponse:
+    def get_promotions(self, **kwargs: Any) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint="api/rnb/pvt/benefits/calculatorconfiguration",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
-    def list_taxes(self, **kwargs: Any) -> VTEXResponse:
+    def get_taxes(self, **kwargs: Any) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint="api/rnb/pvt/taxes/calculatorconfiguration",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )
 
     def get_promotion_or_tax(
         self,
         promotion_or_tax_id: str,
         **kwargs: Any,
-    ) -> VTEXResponse:
+    ) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint=f"/api/rnb/pvt/calculatorconfiguration/{promotion_or_tax_id}",
             config=self.client.config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/types/license_manager.py

@@ -0,0 +1,17 @@
+from typing import TypedDict, Union
+
+
+class GetAccountData(TypedDict, total=False):
+    account_name: str
+    company_name: str
+    creation_date: str
+    have_parent_account: bool
+    id: str
+    inactivation_date: Union[str, None]
+    is_active: bool
+    is_operating: bool
+    name: str
+    operation_date: Union[str, None]
+    parent_account_id: Union[str, None]
+    parent_account_name: Union[str, None]
+    trading_name: str

vtex/_config.py

@@ -1,6 +1,6 @@
 # type: ignore
 from os import getenv
-from typing import Union
+from typing import List, Union
 
 from ._constants import (
     ACCOUNT_NAME_ENV_VAR,
@@ -24,7 +24,6 @@ from ._constants import (
     TIMEOUT_ENV_VAR,
 )
 from ._sentinels import UNDEFINED, UndefinedSentinel
-from ._types import IterableType
 from ._utils import is_nullish_str, str_to_bool
 
 
@@ -41,7 +40,7 @@ class Config:
         retry_backoff_exponential: Union[
             bool, float, int, UndefinedSentinel
         ] = UNDEFINED,
-        retry_statuses: Union[IterableType[int], UndefinedSentinel] = UNDEFINED,
+        retry_statuses: Union[List[int], UndefinedSentinel] = UNDEFINED,
         retry_logs: Union[bool, UndefinedSentinel] = UNDEFINED,
         raise_for_status: Union[bool, UndefinedSentinel] = UNDEFINED,
     ) -> None:
@@ -74,7 +73,7 @@ class Config:
         retry_backoff_exponential: Union[
             bool, int, float, UndefinedSentinel
         ] = UNDEFINED,
-        retry_statuses: Union[IterableType[int], UndefinedSentinel] = UNDEFINED,
+        retry_statuses: Union[List[int], UndefinedSentinel] = UNDEFINED,
         retry_logs: Union[bool, UndefinedSentinel] = UNDEFINED,
         raise_for_status: Union[bool, UndefinedSentinel] = UNDEFINED,
     ) -> "Config":
@@ -162,7 +161,7 @@ class Config:
 
         return self._retry_backoff_exponential
 
-    def get_retry_statuses(self) -> IterableType[int]:
+    def get_retry_statuses(self) -> List[int]:
         if self._retry_statuses is UNDEFINED:
             return DEFAULT_RETRY_STATUSES
 
@@ -398,8 +397,8 @@ class Config:
 
     def _parse_retry_statuses(
         self,
-        retry_statuses: Union[IterableType[int], UndefinedSentinel] = UNDEFINED,
-    ) -> Union[IterableType[int], UndefinedSentinel]:
+        retry_statuses: Union[List[int], UndefinedSentinel] = UNDEFINED,
+    ) -> Union[List[int], UndefinedSentinel]:
         if isinstance(retry_statuses, (list, set, tuple)) and all(
             isinstance(status, int) and 100 <= status <= 599
             for status in retry_statuses

vtex/_dto.py

@@ -1,14 +1,15 @@
 from dataclasses import dataclass
 from json import JSONDecodeError
 from math import ceil
-from typing import Dict, TypeVar, Union
+from typing import Any, Dict, Generic, List, TypeVar, Union
 
 from httpx import Request, Response
 
-from ._types import IterableType, JSONType
-from ._utils import to_snake_case_deep
+from ._utils import remove_null_bytes, to_snake_case_deep
 
-VTEXResponseType = TypeVar("VTEXResponseType", bound="VTEXResponse", covariant=True)
+VTEXResponseType = TypeVar("VTEXResponseType", bound="VTEXResponse")
+DataType = TypeVar("DataType", bound=Any)
+ItemType = TypeVar("ItemType", bound=Any)
 
 
 @dataclass
@@ -32,34 +33,51 @@ class VTEXRequest:
 class VTEXResponse:
     request: VTEXRequest
     response: Response
-    data: JSONType
     status: int
     headers: Dict[str, str]
 
     @classmethod
     def factory(cls, response: Response) -> "VTEXResponse":
-        try:
-            data = to_snake_case_deep(response.json(strict=False))
-        except JSONDecodeError:
-            data = response.text
-
         return cls(
             request=VTEXRequest.factory(response.request),
             response=response,
-            data=data,
             status=int(response.status_code),
             headers=dict(response.headers),
         )
 
 
 @dataclass
-class VTEXListResponse(VTEXResponse):
-    items: IterableType[JSONType]
+class VTEXDataResponse(VTEXResponse, Generic[DataType]):
+    data: DataType
 
     @classmethod
-    def factory(cls, response: Response) -> "VTEXListResponse":
+    def get_original_response_data(cls, response: Response) -> Any:
+        try:
+            return to_snake_case_deep(response.json(strict=False))
+        except JSONDecodeError:
+            return remove_null_bytes(response.text)
+
+    @classmethod
+    def factory(cls, response: Response) -> "VTEXDataResponse[DataType]":
         vtex_response = VTEXResponse.factory(response)
-        data = vtex_response.data
+
+        return cls(
+            request=vtex_response.request,
+            response=vtex_response.response,
+            status=vtex_response.status,
+            headers=vtex_response.headers,
+            data=cls.get_original_response_data(response),
+        )
+
+
+@dataclass
+class VTEXItemsResponse(VTEXDataResponse[DataType], Generic[DataType, ItemType]):
+    items: List[ItemType]
+
+    @classmethod
+    def factory(cls, response: Response) -> "VTEXItemsResponse[DataType, ItemType]":
+        vtex_data_response = VTEXDataResponse[DataType].factory(response)
+        data = vtex_data_response.data
 
         if isinstance(data, list):
             items = data
@@ -70,15 +88,15 @@ class VTEXListResponse(VTEXResponse):
         elif isinstance(data, dict) and isinstance(data.get("data"), list):
             items = data["data"]
         else:
-            raise ValueError(f"Not a valid list response: {data}")
+            raise ValueError(f"Not a valid items response: {data}")
 
         return cls(
-            request=vtex_response.request,
-            response=vtex_response.response,
-            data=vtex_response.data,
-            status=vtex_response.status,
-            headers=vtex_response.headers,
-            items=items,
+            request=vtex_data_response.request,
+            response=vtex_data_response.response,
+            status=vtex_data_response.status,
+            headers=vtex_data_response.headers,
+            data=vtex_data_response.data,
+            items=list(items),
         )
 
 
@@ -92,10 +110,13 @@ class VTEXPagination:
     next_page: Union[int, None]
 
     @classmethod
-    def factory(cls, vtex_list_response: VTEXListResponse) -> "VTEXPagination":
-        data = vtex_list_response.data
-        request_headers = vtex_list_response.request.headers
-        response_headers = vtex_list_response.headers
+    def factory(
+        cls,
+        vtex_items_response: VTEXItemsResponse[DataType, ItemType],
+    ) -> "VTEXPagination":
+        data = vtex_items_response.data
+        request_headers = vtex_items_response.request.headers
+        response_headers = vtex_items_response.headers
 
         total, pages, page_size, page = -1, -1, -1, -1
         if isinstance(data, dict) and data.get("paging"):
@@ -132,53 +153,25 @@ class VTEXPagination:
                 next_page=page + 1 if page < pages else None,
             )
 
-        raise ValueError(f"Not a valid paginated list response: {vtex_list_response}")
+        raise ValueError(f"Not a valid paginated items response: {vtex_items_response}")
 
 
 @dataclass
-class VTEXPaginatedListResponse(VTEXListResponse):
+class VTEXPaginatedItemsResponse(VTEXItemsResponse[DataType, ItemType]):
     pagination: VTEXPagination
 
     @classmethod
-    def factory(cls, response: Response) -> "VTEXPaginatedListResponse":
-        vtex_list_response = VTEXListResponse.factory(response)
-
-        return cls(
-            request=vtex_list_response.request,
-            response=vtex_list_response.response,
-            data=vtex_list_response.data,
-            status=vtex_list_response.status,
-            headers=vtex_list_response.headers,
-            items=vtex_list_response.items,
-            pagination=VTEXPagination.factory(vtex_list_response),
-        )
-
-
-@dataclass
-class VTEXScroll:
-    token: Union[str, None]
-
-    @classmethod
-    def factory(cls, vtex_list_response: VTEXListResponse) -> "VTEXScroll":
-        return cls(token=None)
-
-
-@dataclass
-class VTEXScrollListResponse(VTEXListResponse):
-    scroll: VTEXScroll
-
-    @classmethod
-    def factory(cls, response: Response) -> "VTEXScrollListResponse":
-        vtex_list_response = VTEXListResponse.factory(response)
+    def factory(cls, response: Response) -> "VTEXItemsResponse[DataType, ItemType]":
+        vtex_items_response = VTEXItemsResponse[DataType, ItemType].factory(response)
 
         return cls(
-            request=vtex_list_response.request,
-            response=vtex_list_response.response,
-            data=vtex_list_response.data,
-            status=vtex_list_response.status,
-            headers=vtex_list_response.headers,
-            items=vtex_list_response.items,
-            scroll=VTEXScroll.factory(vtex_list_response),
+            request=vtex_items_response.request,
+            response=vtex_items_response.response,
+            data=vtex_items_response.data,
+            status=vtex_items_response.status,
+            headers=vtex_items_response.headers,
+            items=vtex_items_response.items,
+            pagination=VTEXPagination.factory(vtex_items_response),
         )
 
 

vtex/_exceptions.py

@@ -2,8 +2,6 @@ from typing import Any, Dict, Union
 
 from httpx import Headers
 
-from ._types import JSONType
-
 
 class VTEXError(Exception):
     def __init__(self, *args: Any, **kwags: Any) -> None:
@@ -46,7 +44,7 @@ class VTEXResponseError(VTEXError):
         url: Union[str, None] = None,
         request_headers: Union[Headers, Dict[str, str], None] = None,
         status: Union[int, None] = None,
-        data: JSONType = None,
+        data: Any = None,
         response_headers: Union[Headers, Dict[str, str], None] = None,
         **kwargs: Any,
     ) -> None:

vtex/_types.py

@@ -1,19 +1,4 @@
-from typing import (
-    List,
-    Literal,
-    Mapping,
-    Set,
-    Tuple,
-    TypeVar,
-    Union,
-)
-
-IterableValueType = TypeVar("IterableValueType")
-IterableType = Union[
-    Tuple[IterableValueType, ...],
-    Set[IterableValueType],
-    List[IterableValueType],
-]
+from typing import Any, Dict, Literal
 
 OrderingDirectionType = Literal["ASC", "DESC", "asc", "desc"]
 
@@ -34,5 +19,4 @@ HTTPMethodType = Literal[
     "put",
 ]
 
-PrimitiveTypes = Union[None, bool, int, float, str]
-JSONType = Union[PrimitiveTypes, IterableType["JSONType"], Mapping[str, "JSONType"]]
+DictType = Dict[str, Any]

vtex/_utils.py

@@ -10,7 +10,6 @@ from distutils.util import strtobool
 from ._constants import APP_KEY_HEADER, APP_TOKEN_HEADER
 from ._logging import UTILS_LOGGER
 from ._sentinels import UNDEFINED
-from ._types import JSONType
 
 TO_SNAKE_CASE_STEP_1_PATTERN = compile(r"(.)([A-Z][a-z]+)")
 TO_SNAKE_CASE_STEP_2_PATTERN = compile(r"([a-z0-9])([A-Z])")
@@ -44,7 +43,7 @@ def to_snake_case(string: str) -> str:
     return string
 
 
-def to_snake_case_deep(obj: JSONType) -> JSONType:
+def to_snake_case_deep(obj: Any) -> Any:
     if isinstance(obj, dict):
         snake_cased_obj = {}
 

vtex/_vtex.py

@@ -1,10 +1,9 @@
 from functools import cached_property
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, List, Union
 
 from ._config import Config  # type: ignore[attr-defined]
 from ._logging import CLIENT_LOGGER
 from ._sentinels import UNDEFINED, UndefinedSentinel
-from ._types import IterableType
 
 if TYPE_CHECKING:
     from ._api import (
@@ -36,7 +35,7 @@ class VTEX:
         retry_backoff_min: Union[float, UndefinedSentinel] = UNDEFINED,
         retry_backoff_max: Union[float, UndefinedSentinel] = UNDEFINED,
         retry_backoff_exponential: Union[bool, float, UndefinedSentinel] = UNDEFINED,
-        retry_statuses: Union[IterableType[int], UndefinedSentinel] = UNDEFINED,
+        retry_statuses: Union[List[int], UndefinedSentinel] = UNDEFINED,
         retry_logs: Union[bool, UndefinedSentinel] = UNDEFINED,
         raise_for_status: Union[bool, UndefinedSentinel] = UNDEFINED,
     ) -> None:
@@ -58,44 +57,53 @@ class VTEX:
     @cached_property
     def custom(self) -> "CustomAPI":
         from ._api import CustomAPI
+
         return CustomAPI(client=self)
 
     @cached_property
     def catalog(self) -> "CatalogAPI":
         from ._api import CatalogAPI
+
         return CatalogAPI(client=self)
 
     @cached_property
     def checkout(self) -> "CheckoutAPI":
         from ._api import CheckoutAPI
+
         return CheckoutAPI(client=self)
 
     @cached_property
     def license_manager(self) -> "LicenseManagerAPI":
         from ._api import LicenseManagerAPI
+
         return LicenseManagerAPI(client=self)
 
     @cached_property
     def logistics(self) -> "LogisticsAPI":
         from ._api import LogisticsAPI
+
         return LogisticsAPI(client=self)
 
     @cached_property
     def master_data(self) -> "MasterDataAPI":
         from ._api import MasterDataAPI
+
         return MasterDataAPI(client=self)
 
     @cached_property
     def orders(self) -> "OrdersAPI":
         from ._api import OrdersAPI
+
         return OrdersAPI(client=self)
 
     @cached_property
     def payments_gateway(self) -> "PaymentsGatewayAPI":
         from ._api import PaymentsGatewayAPI
+
         return PaymentsGatewayAPI(client=self)
 
     @cached_property
     def promotions_and_taxes(self) -> "PromotionsAndTaxesAPI":
         from ._api import PromotionsAndTaxesAPI
+
         return PromotionsAndTaxesAPI(client=self)

{vtexpy-0.0.0b10.dist-info → vtexpy-0.0.0b11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtexpy
-Version: 0.0.0b10
+Version: 0.0.0b11
 Summary: Unofficial Python SDK for VTEX API
 Home-page: https://github.com/lvieirajr/vtex-python
 License: MIT
@@ -67,13 +67,29 @@ pip install vtexpy
 
 #### Usage
 
+If the API you want to call is not yet implemented, feel free to create an issue on the 
+VTEXPY Github repository and request it to be added.
+
 ```python
 from vtex import VTEX
 
+# 1 - Instantiate the VTEX client for the account you want to access:
 vtex_client = VTEX(
     account_name="<ACCOUNT_NAME>", 
     app_key="<APP_KEY>", 
     app_token="<APP_TOKEN>",
 )
+
+# 2 - Call one of the available APIs, e.g.:
+vtex_client.license_manager.get_account()
+vtex_client.catalog.list_sku_ids(page=1, page_size=1000)
+vtex_client.orders.list_orders(page=1, page_size=100)
+
+# 3 - If the API you want to call is not yet implemented you can use the `custom` API.
+vtex_client.custom.request(
+    method="GET",
+    environment="vtexcommercestable",
+    endpoint="/api/catalog_system/pvt/commercialcondition/list",
+)
 ```
 

vtexpy-0.0.0b11.dist-info/RECORD

@@ -0,0 +1,28 @@
+vtex/__init__.py,sha256=OwOtOH0pFnXplGHndMz7gOM6WE12etFD6orzxLNlkA8,586
+vtex/_api/__init__.py,sha256=V4n0SQrqCcVFWtm8J7jbmwIRI9mCSURwdD_8uHGueAI,353
+vtex/_api/base.py,sha256=rux3pUNhz76B4dm6I1I9ojnuWKp8oR2EhnJ12anxnCU,5564
+vtex/_api/catalog.py,sha256=nqiAZ3W4IXMcXED2x0WwDToTihTHvdnldoahnQc85bw,4290
+vtex/_api/checkout.py,sha256=Q_PxFvWyWNzRJw-YJuHi2NSjRqQfQ-R2NIlYhXl3Dh0,1751
+vtex/_api/custom.py,sha256=py3Zj_mY3JZfhd3LDx1OzXe1WuRbgzeCcvlrlpizYDY,2472
+vtex/_api/license_manager.py,sha256=mYEUSYLkFdaBPEmhyNx2jUbhaHubcOwpqLG0SutoQMo,692
+vtex/_api/logistics.py,sha256=tXg9V2wIBqNJuUUTJEZx4esN9T66ZKVxPb7X_4hPbUU,4618
+vtex/_api/master_data.py,sha256=1q_OKY5Cf2Cfe1lcGI2hOplXZb-VSLFIO3jXReVHMVI,2088
+vtex/_api/orders.py,sha256=2x84ym5aJD7VSHid16ize2hz57JwCC4ri61Qx2HPazY,5134
+vtex/_api/payments_gateway.py,sha256=d6Lr3D7Aj6HXXP2gX8TA961C75JQ1lelTmdb2Sjo5Os,3934
+vtex/_api/promotions_and_taxes.py,sha256=S8Vp0tlZAyJITAXEnxPi8LZMjE4wl_aChDRV1YAqt34,1973
+vtex/_api/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vtex/_api/types/license_manager.py,sha256=NhKr9pBoVAhp_hK4mAbXsjGM24oglf9ItWbQ7dgosZI,431
+vtex/_config.py,sha256=aK6efpIOamEF76GWfdII7XlKXNNrpmU9jNzTLgq7zpo,16799
+vtex/_constants.py,sha256=BV6BRgbYA6_jcp2t_SBXjXgVgg2-iDdJrYYXsXETU_8,1701
+vtex/_dto.py,sha256=gX_r0685dXRo916A-ZSw9vYfN7XcxFLxkaiIBRbxA6M,6092
+vtex/_exceptions.py,sha256=yglSMmPy4oYWU65oGY1XWA1CbmW1MJO8K-bGYIjoXeg,2127
+vtex/_logging.py,sha256=66tjBs0KvbU3dB14PdSjhdi0C4RT60GEuMPvOe87j7s,1622
+vtex/_sentinels.py,sha256=HLkYBJVHTx9GoyACPO1SuINaGlU2YiqOPuFXUa7iG8A,1120
+vtex/_types.py,sha256=I_vca-7hqRiMXJOXMB40OVTlypXdujduf4LSwW-tGKk,333
+vtex/_utils.py,sha256=OdKGAyGks0sYo8z9ljVVUnWyPZttEluE4hWCrK0hcJA,3483
+vtex/_vtex.py,sha256=kz3SfwSW8rcRVSW_-5MXb8njpqWNknzA8JDYZu9-Vjo,3321
+vtex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vtexpy-0.0.0b11.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+vtexpy-0.0.0b11.dist-info/METADATA,sha256=iN_kTbEHbX7wW_MWLGYLWTIrDY1G5ol_XsQg6A-Io04,2956
+vtexpy-0.0.0b11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vtexpy-0.0.0b11.dist-info/RECORD,,

vtexpy-0.0.0b10.dist-info/RECORD

@@ -1,26 +0,0 @@
-vtex/__init__.py,sha256=MHSWXYxS1emq7iO1iIwmMtrg_rbCROdHO20mra0gdEs,594
-vtex/_api/__init__.py,sha256=V4n0SQrqCcVFWtm8J7jbmwIRI9mCSURwdD_8uHGueAI,353
-vtex/_api/base.py,sha256=32PJNl0En-YtrMU06VjvuTXlJgpO72gs1qFQ_RUYIWE,5554
-vtex/_api/catalog.py,sha256=o2J1FNXtqFMhNbU2mZDNy-fAunkMg1BZWx5piaPHTWk,3998
-vtex/_api/checkout.py,sha256=jywcSnI5nZMycUPpglNzTS5eUOlYkmHD9yvR6MvyvFw,1685
-vtex/_api/custom.py,sha256=9p1x_vxUkj84vORWRqrdxXMOdtN1GxCFBZJ2TAPT1CU,2318
-vtex/_api/license_manager.py,sha256=HlPrD_sSqsWCaCPDwZ0YbuzeHxXFFXRWQwnbyWBGdEg,598
-vtex/_api/logistics.py,sha256=3qPkcyurN5vnsBLmvDd7AMlNYYY-dj7jRMr27Mna5EM,4314
-vtex/_api/master_data.py,sha256=LHe0uSx2FYmj5vzcyHIX2HKKd3qnfJqI8W83f1Oq1bs,2067
-vtex/_api/orders.py,sha256=tns1ExwNEQnKbpByeaQT-iy0asiR3rExCSuCCQAtzo0,4994
-vtex/_api/payments_gateway.py,sha256=_CI_R3rtYxc8w-jfEpYdIuS4juXY3CjPG-W4DrogdVI,3616
-vtex/_api/promotions_and_taxes.py,sha256=vG7p4izxdCLJCr3xL4x5sKOgUhN7TjOHrFobM33bvKI,1805
-vtex/_config.py,sha256=pOtyvpPF7hFTsdd4jb3oTTuBrkIlpE0cWF4-hqLBmpM,16866
-vtex/_constants.py,sha256=BV6BRgbYA6_jcp2t_SBXjXgVgg2-iDdJrYYXsXETU_8,1701
-vtex/_dto.py,sha256=N4fgcXCq0D4xVmD6ntG5X9vR_Clfl_F4NVLmDFPddjY,6030
-vtex/_exceptions.py,sha256=8aly7jBClpWKdZoC8SqJrCljeucebYDZNZeSS1nfaOg,2162
-vtex/_logging.py,sha256=66tjBs0KvbU3dB14PdSjhdi0C4RT60GEuMPvOe87j7s,1622
-vtex/_sentinels.py,sha256=HLkYBJVHTx9GoyACPO1SuINaGlU2YiqOPuFXUa7iG8A,1120
-vtex/_types.py,sha256=zx5DLAjaxMeYbvC_Wno7-9UwoLc8j-awkoW2SjhVXAU,675
-vtex/_utils.py,sha256=oqQ0y8_PHmvv4exV9hAZIyS0Nsp8c4BcSXlpEv2KRQE,3522
-vtex/_vtex.py,sha256=qAKeawNvFBqqut6_BT-zoHE1CljVxNYl_YGXw1u46MU,3347
-vtex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vtexpy-0.0.0b10.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-vtexpy-0.0.0b10.dist-info/METADATA,sha256=iu6RO9ywnR8AVVT5bNK2aJHDHbwk4PO1Px5s4v2m9Iw,2306
-vtexpy-0.0.0b10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vtexpy-0.0.0b10.dist-info/RECORD,,