amazon-creators-async 0.1.0__tar.gz

amazon_creators_async-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Upload Python Package to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.12'
+        
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build twine
+        
+    - name: Build package
+      run: python -m build
+      
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

amazon_creators_async-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,41 @@
+name: Python package test
+
+on:
+  push:
+    branches: [ "master", "main" ]
+  pull_request:
+    branches: [ "master", "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install flake8 pytest pytest-asyncio
+        if [ -f pyproject.toml ]; then pip install -e .; fi
+    
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    
+    # We will skip direct pytest here as we need live credentials for integration testing,
+    # or you can implement mock-based unittests later.
+    - name: Project Install Verification
+      run: |
+        python -c "import amazon-creators-async; print(amazon-creators-async.__version__)"

amazon_creators_async-0.1.0/.gitignore

@@ -0,0 +1,48 @@
+# Environments
+.env
+venv/
+.venv/
+env/
+ENV/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Test scripts (local usage only)
+test_*.py
+
+# IDEs and Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db

amazon_creators_async-0.1.0/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-03-05
+### Added
+- Initial release of the `amazon-creators-async` wrapper.
+- Full OAuth 2.0 support (Cognito v2.x and LWA v3.x credentials).
+- Native asynchronous core leveraging `httpx`.
+- Configurable Rate Limiting defaulting to 1 TPS via `aiolimiter`.
+- Complete Pydantic v2 models mapping Python `snake_case` to Amazon API `lowerCamelCase`.
+- Endpoints: `search_items`, `get_items`, `get_browse_nodes`, `get_variations`.
+- PyPI release metadata (`pyproject.toml`).
+- Examples and documentation (README, QUICK_START, CONTRIBUTING).

amazon_creators_async-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,56 @@
+# Contributing to amazon-creators-async
+
+Thank you for your interest in contributing! This project follows the same open-source model as `aliexpress-async-api`.
+
+## 🛠 Prerequisites
+
+1.  **Python 3.8+**
+2.  **Amazon Associate & Creators API Credentials**: You need a `credential_id`, `credential_secret`, and `partner_tag` to run the live tests.
+
+## 🚀 Setting Up Your Development Environment
+
+1.  **Fork** the repository and clone your fork:
+    ```bash
+    git clone https://github.com/yourusername/amazon-creators-async.git
+    cd amazon-creators-async
+    ```
+2.  **Create a virtual environment**:
+    ```bash
+    python -m venv .venv
+    source .venv/bin/activate  # Windows: .venv\Scripts\activate
+    ```
+3.  **Install dependencies in editable mode**:
+    ```bash
+    pip install -e .
+    ```
+
+## 🧪 Testing
+
+We use the provided `test_client.py` and `test_extra_endpoints.py` to validate API responses directly against Amazon's servers.
+
+1.  Create a `.env` file in the root directory:
+    ```ini
+    AMAZON_CREDENTIAL_ID="amzn1.application-oa2-client..."
+    AMAZON_CREDENTIAL_SECRET="amzn1.oa2-cs.v1..."
+    AMAZON_PARTNER_TAG="yourtag-20"
+    AMAZON_VERSION="3.1"
+    ```
+2.  Run the tests:
+    ```bash
+    python test_client.py
+    python test_extra_endpoints.py
+    ```
+3.  Ensure your code doesn't produce `400 Invalid Request` or `429 TooManyRequests`.
+
+## 📌 Coding Guidelines
+
+*   **Asynchronous First**: All network operations must remain asynchronous using `httpx`.
+*   **Pydantic Consistency**: Always map native Amazon `lowerCamelCase` responses to Pythonic `snake_case` using Pydantic `ConfigDict` and `alias_generator`. Do not leak `CamelCase` variables into the public Python signatures.
+*   **Rate Limits**: Do not bypass or hardcode modifications to the `RateLimiter` unless introducing a documented generic feature (like supporting Amazon's tiered TPS).
+
+## 📄 Pull Request Process
+
+1.  Create a feature branch (`git checkout -b feature/awesome-new-feature`).
+2.  Commit your changes following [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
+3.  Push your branch (`git push origin feature/awesome-new-feature`).
+4.  Open a Pull Request on GitHub.

amazon_creators_async-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Igor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

amazon_creators_async-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: amazon-creators-async
+Version: 0.1.0
+Summary: A modern, high-performance asynchronous Python wrapper for the new Amazon Creators API (OAuth 2.0 based).
+Project-URL: Homepage, https://github.com/ils15/amazon-creators-async
+Project-URL: Repository, https://github.com/ils15/amazon-creators-async.git
+Project-URL: Bug Tracker, https://github.com/ils15/amazon-creators-async/issues
+Author-email: Igor <igor@example.com>
+License: MIT
+License-File: LICENSE
+Keywords: affiliate,amazon,api,async,creators,httpx,oauth2
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: aiolimiter>=1.1.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Async Amazon Creators API (OAuth 2.0)
+
+[![PyPI version](https://badge.fury.io/py/amazon-creators-async.svg)](https://badge.fury.io/py/amazon-creators-async)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Versions](https://img.shields.io/pypi/pyversions/amazon-creators-async.svg)](https://pypi.org/project/amazon-creators-async/)
+
+A modern, high-performance, asynchronous Python wrapper for the **Amazon Creators API** (the replacement for the old Product Advertising API 5.0). 
+
+It fully supports the new **OAuth 2.0** authentication flow, including `v3.1` (Login with Amazon - LWA) credentials, and handles the strict rate limitations automatically to protect your account.
+
+## Features
+
+- ⚡️ **Fully Asynchronous**: Built directly on `httpx` and `asyncio` for maximum performance.
+- 🔐 **OAuth 2.0 Native**: Automatic token fetching, caching, and renewal before expiration. Supports Cognito (v2.x) and LWA (v3.x).
+- 🚦 **Built-in Rate Limiting**: Uses `aiolimiter` to ensure you never exceed Amazon's 1 TPS (Transactions Per Second) limit by default, preventing `429 TooManyRequests` bans.
+- 📦 **Pydantic Validation**: Full request and response validation using Pydantic v2.
+- 🐪 **Auto CamelCase mapping**: You write Pythonic `snake_case`, the library talks to Amazon in their required `lowerCamelCase`.
+- 🛠️ **Full API Coverage**: `SearchItems`, `GetItems`, `GetBrowseNodes`, and `GetVariations`.
+
+## Installation
+
+```bash
+pip install amazon-creators-async
+```
+
+## Quick Start
+
+```python
+import asyncio
+from amazon_creators_async import AmazonCreatorsAsyncClient, Region
+
+async def main():
+    async with AmazonCreatorsAsyncClient(
+        credential_id="YOUR_APP_ID",
+        credential_secret="YOUR_APP_SECRET",
+        partner_tag="yourtag-20",       # Your Amazon Associate tag
+        marketplace="www.amazon.com",   # Target marketplace domain
+        region=Region.NORTH_AMERICA,    # Standard region (includes Brazil)
+        version="3.1"                   # Version from your Creator Console
+    ) as client:
+    
+        # 1. Search for products
+        search_res = await client.search_items(
+            keywords="Mechanical Keyboard",
+            item_count=5, # Number of items to return
+            resources=[
+                "itemInfo.title",
+                "offersV2.listings.price",
+                "images.primary.large"
+            ]
+        )
+        
+        for item in search_res.search_result.items:
+            print(f"ASIN: {item.asin}")
+            if item.item_info and item.item_info.title:
+                print(f"Title: {item.item_info.title.get('displayValue')}")
+            
+        print("-" * 20)
+
+        # 2. Get specific items by ASIN
+        get_res = await client.get_items(
+            item_ids=["B07XQXZXJC", "B08FJMVZX6"],
+            resources=["itemInfo.features"]
+        )
+        
+        for item in get_res.items_result.items:
+             print(f"Features for {item.asin}:")
+             if item.item_info and item.item_info.features:
+                 for feature in item.item_info.features.get('displayValues', []):
+                     print(f" - {feature}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Available Resources
+The Amazon API requires you to specify the `resources` you want returned to minimize payload size. We use the updated **lowerCamelCase** format required by v3.x of the API.
+Common Examples:
+- `itemInfo.title`
+- `offersV2.listings.price`
+- `images.primary.small`
+- `images.variants.large`
+- `itemInfo.features`
+- `browseNodeInfo.browseNodes`
+
+## Rate Limiting (Throttling)
+
+Amazon imposes strict API limitations. Exceeding them regularly can lead to your account being blocked.
+*   **Default Limit**: 1 request per second (TPS).
+*   **Library Behavior**: The `AmazonCreatorsAsyncClient` handles this automatically. If you fire 10 requests at once using `asyncio.gather()`, the built-in limiter will process exactly 1 per second. 
+*   **Custom Limits**: If your account has a higher tier limit, you can adjust the TPS:
+    ```python
+    AmazonCreatorsAsyncClient(..., rate_limit_tps=5.0) # For accounts with 5 TPS
+    ```
+
+## Authentication Versions
+
+The library automatically negotiates endpoints based on the `version` passed during initialization:
+- **v2.x (e.g., "2.1")**: Uses Cognito endpoints with Basic Auth forms.
+- **v3.x (e.g., "3.1")**: Uses Login with Amazon (LWA) endpoints with JSON bodies. 
+
+## Documentation
+- [Amazon Creators API Official Docs](https://affiliate-program.amazon.com/creatorsapi/docs/en-us/introduction)
+- [Quick Start Guide](QUICK_START.md)
+- [Contributing](CONTRIBUTING.md)
+
+## License
+MIT License. See [LICENSE](LICENSE) for details.

amazon_creators_async-0.1.0/QUICK_START.md

@@ -0,0 +1,98 @@
+# Quick Start: amazon-creators-async
+
+Get up and running with the Amazon Creators API in 5 minutes!
+
+## Requirements
+* An approved **Amazon Associates** account.
+* A registered application in the **Amazon Creators Console**.
+* Your `credential_id`, `credential_secret`, and `partner_tag`.
+
+## 1. Installation
+
+```bash
+pip install amazon-creators-async
+```
+
+## 2. Basic Setup (FastAPI Example)
+
+Here is how you would use this library inside a modern async framework like FastAPI to prevent thread-blocking while waiting for Amazon's API:
+
+```python
+from fastapi import FastAPI
+from amazon_creators_async import AmazonCreatorsAsyncClient, Region
+
+app = FastAPI()
+
+# Usually, you'd load these from environment variables (.env)
+CREATOR_ID = "amzn1.application..."
+CREATOR_SECRET = "amzn1.oa2-cs..."
+PARTNER_TAG = "mywebsite-20"
+
+# Note: In production, instantiate this client once on startup (Lifespan event) 
+# and share it across requests to reuse the connection pool and rate limiter.
+client = AmazonCreatorsAsyncClient(
+    credential_id=CREATOR_ID,
+    credential_secret=CREATOR_SECRET,
+    partner_tag=PARTNER_TAG,
+    marketplace="www.amazon.com",
+    region=Region.NORTH_AMERICA,
+    version="3.1" # Find your version in the Creators Console
+)
+
+@app.get("/search/{keyword}")
+async def search_amazon(keyword: str):
+    response = await client.search_items(
+        keywords=keyword,
+        item_count=5,
+        resources=[
+            "itemInfo.title",
+            "offersV2.listings.price",
+            "images.primary.large"
+        ]
+    )
+    
+    # Map the response into a clean JSON output
+    results = []
+    for item in response.search_result.items:
+        title = item.item_info.title.get('displayValue', 'No title') if item.item_info and item.item_info.title else "No title"
+        
+        price = "Out of Stock"
+        if item.offers_v2 and item.offers_v2.listings:
+            price = item.offers_v2.listings[0].price.display_amount
+
+        results.append({
+            "asin": item.asin,
+            "title": title,
+            "price": price
+        })
+        
+    return {"results": results}
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    # Always close the client cleanly
+    await client.close()
+```
+
+## 3. Parallel Execution (Safe Throttling)
+
+If you need to query multiple distinct ASINs or categories at once, you can safely use `asyncio.gather`.
+Our built-in `RateLimiter` ensures you don't violate the 1 TPS limit:
+
+```python
+import asyncio
+
+async def parallel_fetch():
+    # Assuming `client` is already initialized
+    
+    # These three calls are fired immediately
+    tasks = [
+        client.get_items(item_ids=["B07XQXZXJC"], resources=["itemInfo.title"]),
+        client.get_items(item_ids=["B08FJMVZX6"], resources=["itemInfo.title"]),
+        client.get_items(item_ids=["B09B8VGCR8"], resources=["itemInfo.title"])
+    ]
+    
+    # The client will space them out (1 request per second) automatically!
+    results = await asyncio.gather(*tasks)
+    return results
+```

amazon_creators_async-0.1.0/README.md

@@ -0,0 +1,108 @@
+# Async Amazon Creators API (OAuth 2.0)
+
+[![PyPI version](https://badge.fury.io/py/amazon-creators-async.svg)](https://badge.fury.io/py/amazon-creators-async)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Versions](https://img.shields.io/pypi/pyversions/amazon-creators-async.svg)](https://pypi.org/project/amazon-creators-async/)
+
+A modern, high-performance, asynchronous Python wrapper for the **Amazon Creators API** (the replacement for the old Product Advertising API 5.0). 
+
+It fully supports the new **OAuth 2.0** authentication flow, including `v3.1` (Login with Amazon - LWA) credentials, and handles the strict rate limitations automatically to protect your account.
+
+## Features
+
+- ⚡️ **Fully Asynchronous**: Built directly on `httpx` and `asyncio` for maximum performance.
+- 🔐 **OAuth 2.0 Native**: Automatic token fetching, caching, and renewal before expiration. Supports Cognito (v2.x) and LWA (v3.x).
+- 🚦 **Built-in Rate Limiting**: Uses `aiolimiter` to ensure you never exceed Amazon's 1 TPS (Transactions Per Second) limit by default, preventing `429 TooManyRequests` bans.
+- 📦 **Pydantic Validation**: Full request and response validation using Pydantic v2.
+- 🐪 **Auto CamelCase mapping**: You write Pythonic `snake_case`, the library talks to Amazon in their required `lowerCamelCase`.
+- 🛠️ **Full API Coverage**: `SearchItems`, `GetItems`, `GetBrowseNodes`, and `GetVariations`.
+
+## Installation
+
+```bash
+pip install amazon-creators-async
+```
+
+## Quick Start
+
+```python
+import asyncio
+from amazon_creators_async import AmazonCreatorsAsyncClient, Region
+
+async def main():
+    async with AmazonCreatorsAsyncClient(
+        credential_id="YOUR_APP_ID",
+        credential_secret="YOUR_APP_SECRET",
+        partner_tag="yourtag-20",       # Your Amazon Associate tag
+        marketplace="www.amazon.com",   # Target marketplace domain
+        region=Region.NORTH_AMERICA,    # Standard region (includes Brazil)
+        version="3.1"                   # Version from your Creator Console
+    ) as client:
+    
+        # 1. Search for products
+        search_res = await client.search_items(
+            keywords="Mechanical Keyboard",
+            item_count=5, # Number of items to return
+            resources=[
+                "itemInfo.title",
+                "offersV2.listings.price",
+                "images.primary.large"
+            ]
+        )
+        
+        for item in search_res.search_result.items:
+            print(f"ASIN: {item.asin}")
+            if item.item_info and item.item_info.title:
+                print(f"Title: {item.item_info.title.get('displayValue')}")
+            
+        print("-" * 20)
+
+        # 2. Get specific items by ASIN
+        get_res = await client.get_items(
+            item_ids=["B07XQXZXJC", "B08FJMVZX6"],
+            resources=["itemInfo.features"]
+        )
+        
+        for item in get_res.items_result.items:
+             print(f"Features for {item.asin}:")
+             if item.item_info and item.item_info.features:
+                 for feature in item.item_info.features.get('displayValues', []):
+                     print(f" - {feature}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Available Resources
+The Amazon API requires you to specify the `resources` you want returned to minimize payload size. We use the updated **lowerCamelCase** format required by v3.x of the API.
+Common Examples:
+- `itemInfo.title`
+- `offersV2.listings.price`
+- `images.primary.small`
+- `images.variants.large`
+- `itemInfo.features`
+- `browseNodeInfo.browseNodes`
+
+## Rate Limiting (Throttling)
+
+Amazon imposes strict API limitations. Exceeding them regularly can lead to your account being blocked.
+*   **Default Limit**: 1 request per second (TPS).
+*   **Library Behavior**: The `AmazonCreatorsAsyncClient` handles this automatically. If you fire 10 requests at once using `asyncio.gather()`, the built-in limiter will process exactly 1 per second. 
+*   **Custom Limits**: If your account has a higher tier limit, you can adjust the TPS:
+    ```python
+    AmazonCreatorsAsyncClient(..., rate_limit_tps=5.0) # For accounts with 5 TPS
+    ```
+
+## Authentication Versions
+
+The library automatically negotiates endpoints based on the `version` passed during initialization:
+- **v2.x (e.g., "2.1")**: Uses Cognito endpoints with Basic Auth forms.
+- **v3.x (e.g., "3.1")**: Uses Login with Amazon (LWA) endpoints with JSON bodies. 
+
+## Documentation
+- [Amazon Creators API Official Docs](https://affiliate-program.amazon.com/creatorsapi/docs/en-us/introduction)
+- [Quick Start Guide](QUICK_START.md)
+- [Contributing](CONTRIBUTING.md)
+
+## License
+MIT License. See [LICENSE](LICENSE) for details.

amazon_creators_async-0.1.0/amazon_creators_async/__init__.py

@@ -0,0 +1,17 @@
+from .client import AmazonCreatorsAsyncClient
+from .exceptions import AmazonCreatorsException, RateLimitError, AuthenticationError
+from .models.requests import SearchItemsRequest, GetItemsRequest
+from .models.responses import SearchItemsResponse, GetItemsResponse
+from .utils import Region
+
+__all__ = [
+    "AmazonCreatorsAsyncClient",
+    "AmazonCreatorsException",
+    "RateLimitError",
+    "AuthenticationError",
+    "SearchItemsRequest",
+    "GetItemsRequest",
+    "SearchItemsResponse",
+    "GetItemsResponse",
+    "Region"
+]

amazon_creators_async-0.1.0/amazon_creators_async/auth.py

@@ -0,0 +1,105 @@
+import base64
+import time
+import asyncio
+import httpx
+from typing import Optional
+
+from .exceptions import AuthenticationError
+from .utils import get_auth_endpoint, get_scope
+
+class AuthManager:
+    """
+    Manages OAuth 2.0 Client Credentials token fetching and caching
+    for the Amazon Creators API. Supports both Cognito (v2.x) and LWA (v3.x).
+    """
+    
+    def __init__(
+        self, 
+        credential_id: str, 
+        credential_secret: str, 
+        version: str,
+        client: Optional[httpx.AsyncClient] = None
+    ):
+        self.credential_id = credential_id
+        self.credential_secret = credential_secret
+        self.version = version
+        
+        # Determine endpoints and scopes
+        self.auth_url = get_auth_endpoint(version)
+        self.scope = get_scope(version)
+        
+        # Pass a client if you want to share the connection pool, otherwise we manage our own
+        self._client = client or httpx.AsyncClient(timeout=30.0)
+        self._owns_client = client is None
+        self._token_lock = asyncio.Lock()
+
+        # State for token caching
+        self._access_token: Optional[str] = None
+        self._token_expires_at: float = 0.0
+
+    async def get_valid_token(self) -> str:
+        """
+        Returns a valid OAuth 2.0 access token. 
+        If the current token is missing or expired (with a 60s buffer), it fetches a new one.
+        """
+        if self._access_token and time.time() < (self._token_expires_at - 60):
+            return self._access_token
+
+        # Avoid parallel refreshes from concurrent API calls.
+        async with self._token_lock:
+            if self._access_token and time.time() < (self._token_expires_at - 60):
+                return self._access_token
+            return await self._fetch_new_token()
+
+    async def _fetch_new_token(self) -> str:
+        """
+        Performs the HTTP call to the auth endpoint to get the token.
+        Handles both Cognito (form-encoded) and LWA (JSON) versions.
+        """
+        is_lwa = self.version.startswith("3.")
+        
+        try:
+            if is_lwa:
+                # LWA (v3.1+) uses JSON body with credentials inside
+                headers = {"Content-Type": "application/json"}
+                payload = {
+                    "grant_type": "client_credentials",
+                    "client_id": self.credential_id,
+                    "client_secret": self.credential_secret,
+                    "scope": self.scope
+                }
+                response = await self._client.post(self.auth_url, headers=headers, json=payload)
+            else:
+                # Cognito (v2.x) uses Basic Auth + form-encoded data
+                auth_string = f"{self.credential_id}:{self.credential_secret}"
+                encoded_auth = base64.b64encode(auth_string.encode("utf-8")).decode("utf-8")
+                headers = {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "Authorization": f"Basic {encoded_auth}"
+                }
+                data = {
+                    "grant_type": "client_credentials",
+                    "scope": self.scope
+                }
+                response = await self._client.post(self.auth_url, headers=headers, data=data)
+            
+            if response.status_code != 200:
+                raise AuthenticationError(
+                    f"Failed to obtain token ({self.version}). Status: {response.status_code}. Response: {response.text}"
+                )
+
+            payload_data = response.json()
+            self._access_token = payload_data["access_token"]
+            
+            # Usually expires in 3600 seconds (1 hour)
+            expires_in = payload_data.get("expires_in", 3600)
+            self._token_expires_at = time.time() + expires_in
+            
+            return self._access_token
+        except httpx.RequestError as exc:
+            raise AuthenticationError(f"HTTP error occurred while requesting auth token: {exc}") from exc
+
+    async def close(self):
+        """Close internally managed HTTP client."""
+        if self._owns_client:
+            await self._client.aclose()

amazon_creators_async-0.1.0/amazon_creators_async/client.py

@@ -0,0 +1,195 @@
+import asyncio
+import httpx
+from typing import Optional, Dict, Any, List
+
+from .auth import AuthManager
+from .limiter import RateLimiter
+from .utils import Region, get_api_endpoint, get_version_for_region, validate_marketplace
+from .exceptions import RateLimitError, InvalidRequestError, APIError
+from .models.requests import SearchItemsRequest, GetItemsRequest, GetBrowseNodesRequest, GetVariationsRequest
+from .models.responses import SearchItemsResponse, GetItemsResponse, GetBrowseNodesResponse, GetVariationsResponse
+
+class AmazonCreatorsAsyncClient:
+    """
+    Asynchronous client for the Amazon Creators API.
+    Handles OAuth 2.0 authentication, rate limiting, and parameter serialization.
+    """
+
+    def __init__(
+        self,
+        credential_id: str,
+        credential_secret: str,
+        marketplace: str = "www.amazon.com.br",
+        partner_tag: str = "",
+        region: Region = Region.NORTH_AMERICA,
+        version: Optional[str] = None, # Allow explicit version (e.g. 3.1)
+        rate_limit_tps: float = 1.0,
+        max_retries: int = 2,
+        retry_backoff_seconds: float = 0.5,
+        client: Optional[httpx.AsyncClient] = None
+    ):
+        validate_marketplace(marketplace)
+        if not partner_tag:
+            raise ValueError("partner_tag is required.")
+
+        self.credential_id = credential_id
+        self.credential_secret = credential_secret
+        self.marketplace = marketplace
+        self.partner_tag = partner_tag
+        self.region = region
+        self.api_version = version or get_version_for_region(region)
+        self.endpoint_url = get_api_endpoint(region)
+        self.max_retries = max(0, int(max_retries))
+        self.retry_backoff_seconds = max(0.1, float(retry_backoff_seconds))
+        
+        # Async HTTP client
+        self._client = client or httpx.AsyncClient(timeout=30.0)
+        self._owns_client = client is None
+
+        # Managers
+        self._auth_manager = AuthManager(
+            credential_id=self.credential_id,
+            credential_secret=self.credential_secret,
+            version=self.api_version,
+            client=self._client
+        )
+        self._limiter = RateLimiter(tps=rate_limit_tps)
+
+    async def _request(self, operation: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Core method to dispatch a request to the Amazon API with Auth & Limiter."""
+        url = f"{self.endpoint_url}/{operation}"
+
+        for attempt in range(self.max_retries + 1):
+            # 1. Wait for Rate Limiter Capacity.
+            await self._limiter.acquire()
+
+            # 2. Get a valid OAuth2 Token (cached or renewed).
+            token = await self._auth_manager.get_valid_token()
+
+            # 3. Prepare headers.
+            if self.api_version.startswith("3."):
+                auth_header = f"Bearer {token}"
+            else:
+                auth_header = f"Bearer {token}, Version {self.api_version}"
+
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": auth_header,
+                "x-marketplace": self.marketplace,
+                "User-Agent": "amazon_creators_async/0.1.0",
+            }
+
+            try:
+                response = await self._client.post(url, json=payload, headers=headers)
+            except httpx.RequestError as exc:
+                if attempt >= self.max_retries:
+                    raise APIError(f"Network error: {exc}") from exc
+                await asyncio.sleep(self.retry_backoff_seconds * (2 ** attempt))
+                continue
+
+            if response.status_code == 200:
+                return response.json()
+
+            if response.status_code == 429:
+                if attempt >= self.max_retries:
+                    raise RateLimitError(f"Rate limit exceeded: {response.text}")
+                retry_after = response.headers.get("Retry-After")
+                delay = self.retry_backoff_seconds * (2 ** attempt)
+                if retry_after:
+                    try:
+                        delay = max(0.0, float(retry_after))
+                    except ValueError:
+                        pass
+                await asyncio.sleep(delay)
+                continue
+
+            if response.status_code == 400:
+                raise InvalidRequestError(f"Invalid request: {response.text}")
+
+            if response.status_code in {500, 502, 503, 504} and attempt < self.max_retries:
+                await asyncio.sleep(self.retry_backoff_seconds * (2 ** attempt))
+                continue
+
+            raise APIError(
+                f"API Error ({response.status_code}): {response.text}",
+                status_code=response.status_code,
+            )
+
+        raise APIError("Unexpected request retry flow termination")
+
+    async def search_items(self, **kwargs) -> SearchItemsResponse:
+        """
+        Search for items on Amazon using keywords, browse_node_id, brand, etc.
+        """
+        # Inject defaults if missing
+        kwargs.setdefault("marketplace", self.marketplace)
+        kwargs.setdefault("partner_tag", self.partner_tag)
+        
+        # Validate through Pydantic model
+        request_obj = SearchItemsRequest(**kwargs)
+        
+        # Export forcing lowerCamelCase format and removing nulls
+        payload = request_obj.model_dump(by_alias=True, exclude_none=True)
+        
+        data = await self._request("searchItems", payload)
+        return SearchItemsResponse(**data)
+
+    async def get_items(self, item_ids: List[str], **kwargs) -> GetItemsResponse:
+        """
+        Get detailed item information using a batch of ASINs (ItemIds).
+        """
+        if not item_ids:
+            raise ValueError("item_ids must contain at least one ASIN")
+
+        kwargs.setdefault("marketplace", self.marketplace)
+        kwargs.setdefault("partner_tag", self.partner_tag)
+        kwargs["item_ids"] = item_ids
+        
+        # Validate through Pydantic model
+        request_obj = GetItemsRequest(**kwargs)
+        
+        # Export forcing lowerCamelCase format and removing nulls
+        payload = request_obj.model_dump(by_alias=True, exclude_none=True)
+        
+        data = await self._request("getItems", payload)
+        return GetItemsResponse(**data)
+
+    async def get_browse_nodes(self, browse_node_ids: List[str], **kwargs) -> GetBrowseNodesResponse:
+        """
+        Get Browse Node details (categories geometry) on Amazon using their IDs.
+        """
+        kwargs.setdefault("marketplace", self.marketplace)
+        kwargs.setdefault("partner_tag", self.partner_tag)
+        kwargs["browse_node_ids"] = browse_node_ids
+        
+        request_obj = GetBrowseNodesRequest(**kwargs)
+        payload = request_obj.model_dump(by_alias=True, exclude_none=True)
+        
+        data = await self._request("getBrowseNodes", payload)
+        return GetBrowseNodesResponse(**data)
+
+    async def get_variations(self, asin: str, **kwargs) -> GetVariationsResponse:
+        """
+        Get all variations (e.g. size, colors) for a given parent ASIN.
+        """
+        kwargs.setdefault("marketplace", self.marketplace)
+        kwargs.setdefault("partner_tag", self.partner_tag)
+        kwargs["asin"] = asin
+        
+        request_obj = GetVariationsRequest(**kwargs)
+        payload = request_obj.model_dump(by_alias=True, exclude_none=True)
+        
+        data = await self._request("getVariations", payload)
+        return GetVariationsResponse(**data)
+
+
+    async def close(self):
+        """Close the underlying httpx client if we own it."""
+        if self._owns_client:
+            await self._client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()

amazon_creators_async-0.1.0/amazon_creators_async/exceptions.py

@@ -0,0 +1,23 @@
+class AmazonCreatorsException(Exception):
+    """Base exception for all Amazon Creators API errors."""
+    pass
+
+class AuthenticationError(AmazonCreatorsException):
+    """Raised when there is an issue obtaining or refreshing the OAuth token."""
+    pass
+
+class RateLimitError(AmazonCreatorsException):
+    """Raised when the API returns a 429 TooManyRequests."""
+    pass
+
+class InvalidRequestError(AmazonCreatorsException):
+    """Raised when the API returns a 400 Bad Request."""
+    pass
+
+class APIError(AmazonCreatorsException):
+    """Raised for general API errors (e.g. 500 Internal Server Error)."""
+    def __init__(self, message: str, status_code: int = None, type: str = None, code: str = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.type = type
+        self.code = code

amazon_creators_async-0.1.0/amazon_creators_async/limiter.py

@@ -0,0 +1,33 @@
+from typing import Tuple
+from aiolimiter import AsyncLimiter
+
+class RateLimiter:
+    """
+    Ensures that API calls do not exceed the Amazon Creators API rate limits.
+    The default is 1 TPS (Transaction Per Second) for the initial 30 days.
+    """
+    def __init__(self, tps: float = 1.0):
+        if tps <= 0:
+            raise ValueError("tps must be greater than 0")
+
+        # aiolimiter takes max_rate and time_period.
+        # e.g., max_rate=1, time_period=1 => 1 request per 1 second
+        self.tps = tps
+        max_rate, time_period = limiter_config_from_tps(tps)
+        self._limiter = AsyncLimiter(max_rate=max_rate, time_period=time_period)
+
+    async def acquire(self):
+        """
+        Wait until we have capacity to make a request based on the allowed TPS.
+        """
+        await self._limiter.acquire()
+
+def limiter_config_from_tps(tps: float) -> Tuple[int, float]:
+    """
+    Convert TPS to (max_rate, time_period) for aiolimiter.
+    For TPS < 1, enforce one request every 1/tps seconds.
+    For TPS >= 1, use max_rate requests per second.
+    """
+    if tps < 1.0:
+        return 1, 1.0 / tps
+    return int(tps), 1.0

amazon_creators_async-0.1.0/amazon_creators_async/models/__init__.py

@@ -0,0 +1,50 @@
+from .requests import (
+    GetItemsRequest, 
+    SearchItemsRequest, 
+    GetBrowseNodesRequest, 
+    GetVariationsRequest, 
+    BaseAPIRequest
+)
+from .responses import (
+    GetItemsResponse, 
+    SearchItemsResponse, 
+    GetBrowseNodesResponse,
+    GetVariationsResponse,
+    Item, 
+    SearchResult, 
+    Image, 
+    Images, 
+    Price, 
+    ItemInfo, 
+    Listing, 
+    OffersV2,
+    BrowseNode,
+    BrowseNodesResult,
+    VariationDimension,
+    VariationsResult
+)
+
+__all__ = [
+    "GetItemsRequest",
+    "SearchItemsRequest",
+    "GetBrowseNodesRequest",
+    "GetVariationsRequest",
+    "BaseAPIRequest",
+    "GetItemsResponse",
+    "SearchItemsResponse",
+    "GetBrowseNodesResponse",
+    "GetVariationsResponse",
+    "Item",
+    "SearchResult",
+    "Image",
+    "Images",
+    "Price",
+    "ItemInfo",
+    "Listing",
+    "OffersV2",
+    "BrowseNode",
+    "BrowseNodesResult",
+    "VariationDimension",
+    "VariationsResult"
+]
+

amazon_creators_async-0.1.0/amazon_creators_async/models/requests.py

@@ -0,0 +1,90 @@
+from typing import List, Optional
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+class BaseAPIRequest(BaseModel):
+    """
+    Base configuration for Amazon Creators API requests.
+    Forces lowerCamelCase as required by the new API.
+    """
+    model_config = ConfigDict(
+        populate_by_name=True,
+        alias_generator=lambda string: "".join(
+            word.capitalize() if i > 0 else word for i, word in enumerate(string.split("_"))
+        )
+    )
+
+class GetItemsRequest(BaseAPIRequest):
+    item_ids: List[str] = Field(min_length=1, max_length=10)
+    partner_tag: str
+    partner_type: str = "Associates"
+    marketplace: str
+    resources: Optional[List[str]] = None
+    condition: Optional[str] = None
+    currency_of_preference: Optional[str] = None
+    languages_of_preference: Optional[List[str]] = None
+    merchant: Optional[str] = None
+
+class SearchItemsRequest(BaseAPIRequest):
+    keywords: Optional[str] = None
+    actor: Optional[str] = None
+    artist: Optional[str] = None
+    author: Optional[str] = None
+    brand: Optional[str] = None
+    browse_node_id: Optional[str] = None
+    condition: Optional[str] = None
+    currency_of_preference: Optional[str] = None
+    delivery_flags: Optional[List[str]] = None
+    item_count: Optional[int] = Field(ge=1, le=10, default=10) # 10 items max per page usually
+    item_page: Optional[int] = Field(ge=1, le=10, default=1)
+    languages_of_preference: Optional[List[str]] = None
+    marketplace: str
+    merchant: Optional[str] = None
+    min_price: Optional[int] = None
+    max_price: Optional[int] = None
+    partner_tag: str
+    partner_type: str = "Associates"
+    resources: Optional[List[str]] = None
+    search_index: Optional[str] = "All"
+    sort_by: Optional[str] = None
+    title: Optional[str] = None
+
+    @model_validator(mode="after")
+    def validate_search_criteria(self):
+        if not any(
+            [
+                self.keywords,
+                self.actor,
+                self.artist,
+                self.author,
+                self.brand,
+                self.browse_node_id,
+                self.title,
+            ]
+        ):
+            raise ValueError(
+                "At least one search criterion must be provided: "
+                "keywords, actor, artist, author, brand, browse_node_id, or title."
+            )
+        return self
+
+class GetBrowseNodesRequest(BaseAPIRequest):
+    browse_node_ids: List[str] = Field(min_length=1, max_length=10)
+    partner_tag: str
+    partner_type: str = "Associates"
+    marketplace: str
+    languages_of_preference: Optional[List[str]] = None
+    resources: Optional[List[str]] = None
+
+class GetVariationsRequest(BaseAPIRequest):
+    asin: str
+    partner_tag: str
+    partner_type: str = "Associates"
+    marketplace: str
+    condition: Optional[str] = None
+    currency_of_preference: Optional[str] = None
+    languages_of_preference: Optional[List[str]] = None
+    merchant: Optional[str] = None
+    offer_count: Optional[int] = Field(ge=1, le=10, default=1)
+    resources: Optional[List[str]] = None
+    variation_count: Optional[int] = Field(ge=1, le=10, default=10)
+    variation_page: Optional[int] = Field(ge=1, le=10, default=1)

amazon_creators_async-0.1.0/amazon_creators_async/models/responses.py

@@ -0,0 +1,98 @@
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, ConfigDict, Field
+
+class BaseAPIResponse(BaseModel):
+    """
+    Base configuration for Amazon Creators API responses.
+    Ensures lowerCamelCase mapping from the API JSON.
+    """
+    model_config = ConfigDict(
+        populate_by_name=True,
+        alias_generator=lambda string: "".join(
+            word.capitalize() if i > 0 else word for i, word in enumerate(string.split("_"))
+        )
+    )
+
+class Image(BaseAPIResponse):
+    url: Optional[str] = Field(None, alias="url")
+    height: Optional[int] = None
+    width: Optional[int] = None
+
+class Images(BaseAPIResponse):
+    primary: Optional[Dict[str, Image]] = None
+    variants: Optional[List[Dict[str, Image]]] = None
+
+class Price(BaseAPIResponse):
+    amount: Optional[float] = None
+    currency: Optional[str] = None
+    display_amount: Optional[str] = None
+    savings: Optional[Dict[str, Any]] = None
+
+class ItemInfo(BaseAPIResponse):
+    title: Optional[Dict[str, str]] = None
+    features: Optional[Dict[str, List[str]]] = None
+    by_line_info: Optional[Dict[str, Any]] = None
+
+class Listing(BaseAPIResponse):
+    id: Optional[str] = None
+    price: Optional[Price] = None
+    delivery_info: Optional[Dict[str, Any]] = None
+    condition: Optional[Dict[str, str]] = None
+
+class OffersV2(BaseAPIResponse):
+    listings: Optional[List[Listing]] = None
+    summaries: Optional[List[Dict[str, Any]]] = None
+
+class Item(BaseAPIResponse):
+    asin: str
+    detail_page_url: Optional[str] = None
+    images: Optional[Images] = None
+    item_info: Optional[ItemInfo] = None
+    offers_v2: Optional[OffersV2] = None
+
+class SearchResult(BaseAPIResponse):
+    total_result_count: Optional[int] = None
+    search_url: Optional[str] = None
+    items: List[Item] = Field(default_factory=list)
+
+class SearchItemsResponse(BaseAPIResponse):
+    search_result: Optional[SearchResult] = None
+    errors: Optional[List[Dict[str, str]]] = None
+
+class GetItemsResult(BaseAPIResponse):
+    items: List[Item] = Field(default_factory=list)
+
+class GetItemsResponse(BaseAPIResponse):
+    items_result: Optional[GetItemsResult] = None
+    errors: Optional[List[Dict[str, str]]] = None
+
+# Model for Traverse Tree of BrowseNodes
+class BrowseNode(BaseAPIResponse):
+    id: Optional[str] = None
+    display_name: Optional[str] = None
+    context_free_name: Optional[str] = None
+    is_root: Optional[bool] = None
+    ancestor: Optional['BrowseNode'] = None
+    children: Optional[List['BrowseNode']] = None
+
+class BrowseNodesResult(BaseAPIResponse):
+    browse_nodes: List[BrowseNode] = Field(default_factory=list)
+
+class GetBrowseNodesResponse(BaseAPIResponse):
+    browse_nodes_result: Optional[BrowseNodesResult] = None
+    errors: Optional[List[Dict[str, str]]] = None
+
+class VariationDimension(BaseAPIResponse):
+    display_name: str
+    name: str
+
+class VariationsResult(BaseAPIResponse):
+    items: List[Item] = Field(default_factory=list)
+    variation_dimensions: Optional[List[VariationDimension]] = None
+
+class GetVariationsResponse(BaseAPIResponse):
+    variations_result: Optional[VariationsResult] = None
+    errors: Optional[List[Dict[str, str]]] = None
+
+# Deal with recursive model definition for Pydantic v2
+BrowseNode.model_rebuild()

amazon_creators_async-0.1.0/amazon_creators_async/utils.py

@@ -0,0 +1,51 @@
+"""
+Utilities and constants for the Amazon Creators API.
+"""
+
+from enum import Enum
+
+class Region(str, Enum):
+    NORTH_AMERICA = "NA"
+    EUROPE = "EU"
+    FAR_EAST = "FE"
+
+def get_api_endpoint(region: Region) -> str:
+    """Returns the endpoint for the respective region."""
+    return "https://creatorsapi.amazon/catalog/v1"
+
+def get_version_for_region(region: Region) -> str:
+    """Returns the authorization version for a given Region."""
+    if region == Region.NORTH_AMERICA:
+        return "2.1"
+    elif region == Region.EUROPE:
+        return "2.2"
+    elif region == Region.FAR_EAST:
+        return "2.3"
+    raise ValueError(f"Unknown region: {region}")
+
+def get_auth_endpoint(version: str) -> str:
+    """Returns the correct OAuth2 token endpoint based on version."""
+    if version == "2.1":
+        return "https://creatorsapi.auth.us-east-1.amazoncognito.com/oauth2/token"
+    elif version == "2.2":
+        return "https://creatorsapi.auth.eu-south-2.amazoncognito.com/oauth2/token"
+    elif version == "2.3":
+        return "https://creatorsapi.auth.us-west-2.amazoncognito.com/oauth2/token"
+    elif version == "3.1":
+        return "https://api.amazon.com/auth/o2/token"
+    elif version == "3.2":
+        return "https://api.amazon.co.uk/auth/o2/token"
+    elif version == "3.3":
+        return "https://api.amazon.co.jp/auth/o2/token"
+    raise ValueError(f"Unsupported version: {version}")
+
+def get_scope(version: str) -> str:
+    """Returns the correct OAuth2 scope based on version."""
+    if version.startswith("3."):
+        return "creatorsapi::default" # LWA scope
+    return "creatorsapi/default" # Cognito scope
+
+def validate_marketplace(marketplace: str):
+    """Simple check for typical marketplace domains."""
+    if not marketplace.startswith("www.amazon."):
+        raise ValueError("Marketplace must be a valid Amazon domain (e.g. 'www.amazon.com', 'www.amazon.com.br')")

amazon_creators_async-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "amazon-creators-async"
+version = "0.1.0"
+description = "A modern, high-performance asynchronous Python wrapper for the new Amazon Creators API (OAuth 2.0 based)."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "Igor", email = "igor@example.com" }
+]
+keywords = ["amazon", "creators", "api", "affiliate", "async", "httpx", "oauth2"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Internet :: WWW/HTTP",
+]
+dependencies = [
+    "httpx>=0.24.0",
+    "pydantic>=2.0.0",
+    "aiolimiter>=1.1.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ils15/amazon-creators-async"
+Repository = "https://github.com/ils15/amazon-creators-async.git"
+"Bug Tracker" = "https://github.com/ils15/amazon-creators-async/issues"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests", "."]
+