vtexpy 0.0.0b16__tar.gz → 0.0.0b17__tar.gz

{vtexpy-0.0.0b16 → vtexpy-0.0.0b17}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.1
 Name: vtexpy
-Version: 0.0.0b16
-Summary: Unofficial Python SDK for VTEX API
+Version: 0.0.0b17
+Summary: Unofficial VTEX API's Python SDK
 Home-page: https://github.com/lvieirajr/vtex-python
-License: MIT
+License: Apache
 Keywords: vtex,sdk,client,api
 Author: Luis Vieira
 Author-email: lvieira@lvieira.com
 Maintainer: Luis Vieira
 Maintainer-email: lvieira@lvieira.com
-Requires-Python: >=3.9,<3.14
+Requires-Python: >=3.9,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -21,13 +21,14 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Dist: httpx (>=0.26,<1.0)
+Requires-Dist: pydantic (>=2.6,<3.0)
 Requires-Dist: python-dateutil (>=2.9,<3.0)
 Requires-Dist: tenacity (>=8.3,<10.0)
+Requires-Dist: typing-extensions (>=4.7,<5.0) ; python_version < "3.12"
 Project-URL: Documentation, https://github.com/lvieirajr/vtex-python
 Project-URL: Repository, https://github.com/lvieirajr/vtex-python
 Description-Content-Type: text/markdown
@@ -35,7 +36,7 @@ Description-Content-Type: text/markdown
 # VTEXPY
 [![PyPI Version](https://img.shields.io/pypi/v/vtexpy.svg)](https://pypi.python.org/pypi/vtexpy)
 
-## Unofficial Python SDK for VTEX API
+## Unofficial VTEX API's Python SDK
 
 VTEXPY is an unofficial Python SDK designed to facilitate integration with the VTEX API.
 
@@ -45,19 +46,17 @@ API.
 
 ### Features
 
-- Easy to use Python interface for calling endpoints on the VTEX API.
+- Easy to use Python interface for calling VTEX API endpoints
+- Response format standardization
 - Custom exception handling
-- Automatic retries
+- Automatic request retrying
 - Request logging
 
 ### Getting Started
 
 #### Requirements
 
-- Python >= 3.9, < 3.14
-- httpx >= 0.26, < 1.0
-- python-dateutil >= 2.9, < 3.0
-- tenacity >= 8.3, < 10.0
+- Python >= 3.9, < 3.13
 
 #### Installation
 
@@ -67,29 +66,34 @@ pip install vtexpy
 
 #### Usage
 
-If the API you want to call is not yet implemented, feel free to create an issue on the 
+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
+from vtex import VTEX, VTEXConfig
 
-# 1 - Instantiate the VTEX client for the account you want to access:
-vtex_client = VTEX(
-    account_name="<ACCOUNT_NAME>", 
-    app_key="<APP_KEY>", 
+# Instantiate your VTEX API configuration:
+vtex_config = VTEXConfig(
+    account_name="<ACCOUNT_NAME>",
+    app_key="<APP_KEY>",
     app_token="<APP_TOKEN>",
+    # Other arguments such as: retrying, logging, etc...
 )
 
-# 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)
+# Instantiate the VTEX client with your configuration:
+vtex_client = VTEX(config=vtex_config)
 
-# 3 - If the API you want to call is not yet implemented you can use the `custom` API.
-vtex_client.custom.request(
+# Call one of the available APIs, e.g.:
+account_response = vtex_client.license_manager.get_account()
+list_sku_ids_response = vtex_client.catalog.list_sku_ids(page=1, page_size=1000)
+list_orders_response = vtex_client.orders.list_orders(page=1, page_size=100)
+
+# If the API you want to call is not yet implemented you can use the `custom` API.
+response = vtex_client.custom.request(
     method="GET",
     environment="vtexcommercestable",
     endpoint="/api/catalog_system/pvt/commercialcondition/list",
+    # Other arguments such as: query params, headers, json data, response class, etc...
 )
 ```
 

vtexpy-0.0.0b17/README.md

@@ -0,0 +1,63 @@
+# VTEXPY
+[![PyPI Version](https://img.shields.io/pypi/v/vtexpy.svg)](https://pypi.python.org/pypi/vtexpy)
+
+## Unofficial VTEX API's Python SDK
+
+VTEXPY is an unofficial Python SDK designed to facilitate integration with the VTEX API.
+
+Even though it is still tagged as beta, vtexpy has been in use by a _SaaS_ company in a
+production environment for over a year, making millions of requests a day to the VTEX
+API.
+
+### Features
+
+- Easy to use Python interface for calling VTEX API endpoints
+- Response format standardization
+- Custom exception handling
+- Automatic request retrying
+- Request logging
+
+### Getting Started
+
+#### Requirements
+
+- Python >= 3.9, < 3.13
+
+#### Installation
+
+```bash
+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, VTEXConfig
+
+# Instantiate your VTEX API configuration:
+vtex_config = VTEXConfig(
+    account_name="<ACCOUNT_NAME>",
+    app_key="<APP_KEY>",
+    app_token="<APP_TOKEN>",
+    # Other arguments such as: retrying, logging, etc...
+)
+
+# Instantiate the VTEX client with your configuration:
+vtex_client = VTEX(config=vtex_config)
+
+# Call one of the available APIs, e.g.:
+account_response = vtex_client.license_manager.get_account()
+list_sku_ids_response = vtex_client.catalog.list_sku_ids(page=1, page_size=1000)
+list_orders_response = vtex_client.orders.list_orders(page=1, page_size=100)
+
+# If the API you want to call is not yet implemented you can use the `custom` API.
+response = vtex_client.custom.request(
+    method="GET",
+    environment="vtexcommercestable",
+    endpoint="/api/catalog_system/pvt/commercialcondition/list",
+    # Other arguments such as: query params, headers, json data, response class, etc...
+)
+```

{vtexpy-0.0.0b16 → vtexpy-0.0.0b17}/pyproject.toml

@@ -1,8 +1,13 @@
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
 [tool.poetry]
 name = "vtexpy"
-description = "Unofficial Python SDK for VTEX API"
+description = "Unofficial VTEX API's Python SDK"
+version = "0.0.0b17"
 readme = "README.md"
-license = "MIT"
+license = "Apache"
 authors = [
     "Luis Vieira <lvieira@lvieira.com>",
 ]
@@ -23,7 +28,6 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
-  "Programming Language :: Python :: 3.13",
   "Operating System :: OS Independent",
   "Topic :: Software Development :: Libraries",
   "Topic :: Software Development :: Libraries :: Python Modules",
@@ -32,17 +36,14 @@ classifiers = [
 packages = [
     {include = "vtex"},
 ]
-version = "0.0.0b16"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.14"
+python = ">=3.9,<3.13"
 httpx = {version = ">=0.26,<1.0"}
+pydantic = {version = ">=2.6,<3.0"}
 python-dateutil = {version = ">=2.9,<3.0"}
 tenacity = {version = ">=8.3,<10.0"}
+typing-extensions = {version = ">=4.7,<5.0", markers = "python_version < \"3.12\""}
 
 [tool.poetry.group.dev.dependencies]
 ipdb = {version = "*"}
@@ -51,6 +52,7 @@ mock = {version = "*"}
 mypy = {version = "*"}
 pip = {version = "*"}
 poetry = {version = "*"}
+pre-commit = {version = "*"}
 pytest = {version = "*"}
 pytest-mock = {version = "*"}
 ruff = {version = "*"}
@@ -59,6 +61,9 @@ types-decorator = {version = "*"}
 types-python-dateutil = {version = "*"}
 types-six = {version = "*"}
 
+[tool.poetry.scripts]
+install-hooks = "pre-commit install:main"
+
 
 # ======
 # PyTest
@@ -79,9 +84,12 @@ mock_use_standalone_module = true
 [tool.mypy]
 exclude = [".*tests/*"]
 ignore_missing_imports = true
+install_types = true
 namespace_packages = true
 no_implicit_reexport = false
+non_interactive = true
 plugins = []
+pretty = true
 strict = true
 
 

{vtexpy-0.0.0b16 → vtexpy-0.0.0b17}/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",

{vtexpy-0.0.0b16 → vtexpy-0.0.0b17}/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

{vtexpy-0.0.0b16 → vtexpy-0.0.0b17}/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],
         )

{vtexpy-0.0.0b16 → vtexpy-0.0.0b17}/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],
         )

{vtexpy-0.0.0b16 → vtexpy-0.0.0b17}/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"])
         ]

{vtexpy-0.0.0b16 → vtexpy-0.0.0b17}/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",