vtexpy 0.0.0b16__tar.gz → 0.0.0b18__tar.gz

{vtexpy-0.0.0b16 → vtexpy-0.0.0b18}/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.0b18
+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,29 +36,28 @@ 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.
 
 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.
+API. The only reason why it is tagged as beta is that it is still under heavy
+development and breaking changes are expected on the external 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 +67,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.0b18/README.md

@@ -0,0 +1,64 @@
+# 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. The only reason why it is tagged as beta is that it is still under heavy
+development and breaking changes are expected on the external 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.0b18}/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.0b18"
 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 = "*"}
@@ -79,9 +81,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.0b18}/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.0b18}/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.0b18}/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.0b18}/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.0b18}/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.0b18}/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",