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

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._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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._config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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._config.with_overrides(**kwargs),
-            response_class=VTEXListResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            response_class=VTEXDataResponse[DictType],
         )

vtex/_api/promotions_and_taxes.py

@@ -1,6 +1,7 @@
 from typing import Any
 
-from .._dto import VTEXResponse
+from .._dto import VTEXDataResponse, VTEXItemsResponse
+from .._types import DictType
 from .base import BaseAPI
 
 
@@ -12,33 +13,45 @@ class PromotionsAndTaxesAPI(BaseAPI):
 
     ENVIRONMENT = "vtexcommercestable"
 
-    def list_promotions(self, **kwargs: Any) -> VTEXResponse:
+    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=VTEXItemsResponse[DictType, DictType],
+        )
+
+    def get_promotions(self, **kwargs: Any) -> VTEXDataResponse[DictType]:
         return self._request(
             method="GET",
             environment=self.ENVIRONMENT,
             endpoint="api/rnb/pvt/benefits/calculatorconfiguration",
-            config=self._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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._config.with_overrides(**kwargs),
-            response_class=VTEXResponse,
+            config=self.client.config.with_overrides(**kwargs),
+            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

@@ -3,12 +3,13 @@ from re import compile
 from typing import Any, Dict, Mapping, Union
 from uuid import UUID
 
+from dateutil.parser import parse as parse_datetime
+from dateutil.tz import tzoffset
 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])")
@@ -42,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 = {}
 
@@ -82,8 +83,34 @@ def redact_headers(headers: Mapping[str, str]) -> Dict[str, str]:
     return redacted_headers
 
 
+def to_tzinfo(tz: Union[tzinfo, int, None] = None) -> tzinfo:
+    if isinstance(tz, tzinfo):
+        return tz
+
+    if isinstance(tz, int):
+        return tzoffset(None, tz)
+
+    return timezone.utc
+
+
+def to_datetime(
+    value: Union[datetime, str],
+    use_tz: bool = True,
+    tz: Union[tzinfo, int, None] = None,
+) -> datetime:
+    value_as_datetime = value if isinstance(value, datetime) else parse_datetime(value)
+
+    if not use_tz:
+        return value_as_datetime.replace(tzinfo=None)
+
+    if value_as_datetime.tzinfo and tz is None:
+        return value_as_datetime
+
+    return value_as_datetime.replace(tzinfo=to_tzinfo(tz))
+
+
 def now(use_tz: bool = True, tz: Union[tzinfo, None] = None) -> datetime:
-    return datetime.now((tz or timezone.utc) if use_tz else None)
+    return datetime.now(to_tzinfo(tz) if use_tz else None)
 
 
 def three_years_ago(use_tz: bool = True, tz: Union[tzinfo, None] = None) -> datetime: