amazon-sp-cli 0.1.0__py3-none-any.whl

amazon_sp_cli/__init__.py

@@ -0,0 +1,2 @@
+# Amazon SP-API CLI
+__version__ = "0.1.0"

amazon_sp_cli/auth.py

@@ -0,0 +1,103 @@
+"""Amazon SP-API authentication handler."""
+
+import json
+import os
+import time
+from pathlib import Path
+
+import requests
+import yaml
+
+
+class SPAPIAuth:
+    """Handles SP-API token refresh and caching."""
+
+    TOKEN_ENDPOINT = "https://api.amazon.com/auth/o2/token"
+    CACHE_FILE = Path.home() / ".config" / "amazon-sp-pricing" / "token-cache.json"
+    BUFFER_SECONDS = 60
+
+    def __init__(self, credentials_path: str = None):
+        self.credentials = self._load_credentials(credentials_path)
+        self._ensure_cache_dir()
+
+    def _load_credentials(self, path: str = None) -> dict:
+        """Load credentials from YAML file."""
+        if path is None:
+            path = Path.home() / ".config" / "amazon-sp-pricing" / "credentials.yml"
+
+        with open(path, "r") as f:
+            config = yaml.safe_load(f)
+
+        return config.get("default", config)
+
+    def _ensure_cache_dir(self):
+        """Ensure cache directory exists."""
+        self.CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+    def _load_cache(self) -> dict:
+        """Load token cache from disk."""
+        if self.CACHE_FILE.exists():
+            with open(self.CACHE_FILE, "r") as f:
+                return json.load(f)
+        return {
+            "access_token": None,
+            "expires_at": 0,
+            "refreshed_at": None,
+        }
+
+    def _save_cache(self, cache: dict):
+        """Save token cache to disk."""
+        with open(self.CACHE_FILE, "w") as f:
+            json.dump(cache, f)
+        os.chmod(self.CACHE_FILE, 0o600)
+
+    def _is_token_valid(self, cache: dict) -> bool:
+        """Check if cached token is still valid."""
+        if cache.get("access_token") is None:
+            return False
+        now = time.time()
+        return now < cache.get("expires_at", 0) - self.BUFFER_SECONDS
+
+    def _exchange_token(self) -> dict:
+        """Exchange refresh token for access token."""
+        response = requests.post(
+            self.TOKEN_ENDPOINT,
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            data={
+                "grant_type": "refresh_token",
+                "refresh_token": self.credentials["refresh_token"],
+                "client_id": self.credentials["client_id"],
+                "client_secret": self.credentials["client_secret"],
+            },
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        now = time.time()
+        return {
+            "access_token": data["access_token"],
+            "expires_at": now + data["expires_in"],
+            "refreshed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        }
+
+    def get_access_token(self) -> str:
+        """Get a valid access token, refreshing if necessary."""
+        cache = self._load_cache()
+
+        # Fast path: valid cached token
+        if self._is_token_valid(cache):
+            return cache["access_token"]
+
+        # Slow path: refresh token
+        new_cache = self._exchange_token()
+        self._save_cache(new_cache)
+        return new_cache["access_token"]
+
+    def invalidate(self):
+        """Invalidate cached token."""
+        self._save_cache({
+            "access_token": None,
+            "expires_at": 0,
+            "refreshed_at": None,
+        })
+        print("Token cache invalidated.")

amazon_sp_cli/client.py

@@ -0,0 +1,104 @@
+"""Amazon SP-API client with AWS SigV4 signing."""
+
+import json
+from urllib.parse import urlencode
+
+import requests
+from botocore.auth import SigV4Auth
+from botocore.awsrequest import AWSRequest
+from botocore.credentials import Credentials
+from botocore.session import Session
+
+
+class SPAPIClient:
+    """Client for making signed requests to Amazon SP-API."""
+
+    HOST = "sellingpartnerapi-na.amazon.com"
+    REGION = "us-east-1"
+    SERVICE = "execute-api"
+
+    def __init__(self, auth, aws_access_key: str = None, aws_secret_key: str = None):
+        self.auth = auth
+        self.credentials = auth.credentials
+        self.aws_access_key = aws_access_key or self.credentials.get("aws_access_key_id")
+        self.aws_secret_key = aws_secret_key or self.credentials.get("aws_secret_access_key")
+        self.marketplace_id = self.credentials.get("marketplace_id", "ATVPDKIKX0DER")
+        self.seller_id = self.credentials.get("seller_id")
+
+    def _sign_request(self, method: str, path: str, data: dict = None) -> dict:
+        """Create signed request headers."""
+        access_token = self.auth.get_access_token()
+
+        headers = {
+            "x-amz-access-token": access_token,
+            "accept": "application/json",
+        }
+
+        if data is not None:
+            headers["content-type"] = "application/json"
+
+        # Create the request
+        url = f"https://{self.HOST}{path}"
+        body = json.dumps(data) if data else ""
+
+        # Create AWS request for signing
+        request = AWSRequest(method=method, url=url, headers=headers, data=body)
+
+        # Sign with SigV4
+        credentials = Credentials(self.aws_access_key, self.aws_secret_key)
+        signer = SigV4Auth(credentials, self.SERVICE, self.REGION)
+        signer.add_auth(request)
+
+        return dict(request.headers), request.url, body
+
+    def request(self, method: str, path: str, data: dict = None) -> dict:
+        """Make a signed request to SP-API."""
+        headers, url, body = self._sign_request(method, path, data)
+
+        response = requests.request(method, url, headers=headers, data=body)
+        response.raise_for_status()
+
+        return response.json() if response.text else {}
+
+    def get_listing(self, sku: str) -> dict:
+        """Get listing information for a SKU."""
+        path = f"/listings/2021-08-01/items/{self.seller_id}/{sku}"
+        params = {
+            "marketplaceIds": self.marketplace_id,
+            "includedData": "summaries,attributes",
+        }
+        path += "?" + urlencode(params)
+        return self.request("GET", path)
+
+    def update_price(self, sku: str, price: float, mode: str = "VALIDATION_PREVIEW") -> dict:
+        """Update listing price."""
+        path = f"/listings/2021-08-01/items/{self.seller_id}/{sku}"
+        params = {
+            "marketplaceIds": self.marketplace_id,
+        }
+        if mode:
+            params["mode"] = mode
+        path += "?" + urlencode(params)
+
+        data = {
+            "productType": "PET_TOY",
+            "requirements": "LISTING_OFFER_ONLY",
+            "attributes": {
+                "condition_type": [{"value": "new_new"}],
+                "item_name": [{"value": "Placeholder"}],
+                "list_price": [{"currency": "USD", "value": price}],
+                "purchasable_price": [{"currency": "USD", "value": price}],
+            },
+        }
+
+        return self.request("PUT", path, data)
+
+    def get_catalog_item(self, asin: str) -> dict:
+        """Get catalog item details."""
+        path = f"/catalog/2022-04-01/items/{asin}"
+        params = {
+            "marketplaceIds": self.marketplace_id,
+            "includedData": "attributes,salesRanks",
+        }
+        path += "?" + urlencode(params)
+        return self.request("GET", path)

amazon_sp_cli/main.py

@@ -0,0 +1,175 @@
+"""Main CLI entry point for Amazon SP-API CLI."""
+
+import json
+from datetime import datetime, timezone
+
+import click
+
+from .auth import SPAPIAuth
+from .client import SPAPIClient
+
+
+@click.group()
+@click.option("--credentials", "-c", help="Path to credentials YAML file")
+@click.pass_context
+def cli(ctx, credentials):
+    """Amazon SP-API CLI - Manage listings, pricing, inventory, and more."""
+    ctx.ensure_object(dict)
+    ctx.obj["auth"] = SPAPIAuth(credentials)
+    ctx.obj["client"] = SPAPIClient(ctx.obj["auth"])
+
+
+@cli.command()
+@click.argument("sku")
+@click.pass_context
+def get_price(ctx, sku):
+    """Get current price for a SKU."""
+    client = ctx.obj["client"]
+    try:
+        response = client.get_listing(sku)
+        attributes = response.get("attributes", {})
+        list_price = attributes.get("list_price", [{}])[0]
+
+        result = {
+            "sku": sku,
+            "asin": response.get("summaries", [{}])[0].get("asin"),
+            "status": response.get("summaries", [{}])[0].get("status", []),
+            "price": list_price.get("value"),
+            "currency": list_price.get("currency"),
+        }
+        click.echo(json.dumps(result, indent=2))
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise click.Abort()
+
+
+@cli.command()
+@click.argument("sku")
+@click.argument("price", type=float)
+@click.option("--dry-run", is_flag=True, help="Validate without applying")
+@click.pass_context
+def set_price(ctx, sku, price, dry_run):
+    """Set price for a SKU."""
+    client = ctx.obj["client"]
+    try:
+        mode = "VALIDATION_PREVIEW" if dry_run else None
+        response = client.update_price(sku, price, mode)
+
+        if dry_run:
+            if response.get("issues"):
+                click.echo("Validation issues found:")
+                click.echo(json.dumps(response["issues"], indent=2))
+            else:
+                click.echo("✓ Validation passed")
+        else:
+            click.echo(json.dumps(response, indent=2))
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise click.Abort()
+
+
+@cli.command()
+@click.argument("sku")
+@click.argument("percent", type=float)
+@click.option("--all-variations", is_flag=True, help="Apply to all variations")
+@click.pass_context
+def create_discount(ctx, sku, percent, all_variations):
+    """Create discount for a SKU."""
+    client = ctx.obj["client"]
+
+    try:
+        if all_variations:
+            # Get parent SKU and find all variations
+            parent_sku = sku.split("-")[0] if "-" in sku else sku
+            click.echo(f"Creating {percent}% discount for all variations of {parent_sku}")
+            # TODO: Implement variation discovery
+            return
+
+        # Get current price
+        response = client.get_listing(sku)
+        attributes = response.get("attributes", {})
+        list_price = attributes.get("list_price", [{}])[0]
+        current_price = list_price.get("value", 0)
+
+        if not current_price:
+            click.echo("Error: Could not get current price", err=True)
+            raise click.Abort()
+
+        sale_price = round(current_price * (100 - percent) / 100, 2)
+        effective_date = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        click.echo(f"Current price: ${current_price}")
+        click.echo(f"Sale price: ${sale_price} ({percent}% off)")
+        click.echo("")
+        click.echo("Note: SP-API doesn't support direct discount creation.")
+        click.echo("Options:")
+        click.echo("1. Seller Central → Advertising → Prime Exclusive Discounts")
+        click.echo("2. Seller Central → Advertising → Coupons")
+        click.echo("3. Submit feed via SP-API Feeds API")
+        click.echo("")
+        click.echo("Feed data for option 3:")
+
+        feed = {
+            "header": {
+                "sellerId": client.seller_id,
+                "version": "2.0",
+                "issueLocale": "en_US",
+            },
+            "messages": [
+                {
+                    "messageId": 1,
+                    "sku": sku,
+                    "operationType": "PARTIAL_UPDATE",
+                    "productType": "PET_TOY",
+                    "attributes": {
+                        "list_price": [{"currency": "USD", "value": current_price}],
+                        "sale_price": [
+                            {
+                                "currency": "USD",
+                                "value": sale_price,
+                                "effective_date": effective_date,
+                            }
+                        ],
+                    },
+                }
+            ],
+        }
+        click.echo(json.dumps(feed, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise click.Abort()
+
+
+@cli.command()
+@click.argument("asin")
+@click.pass_context
+def check_competitors(ctx, asin):
+    """Check competitor pricing for an ASIN."""
+    client = ctx.obj["client"]
+    try:
+        response = client.get_catalog_item(asin)
+        attributes = response.get("attributes", {})
+
+        result = {
+            "asin": response.get("asin"),
+            "title": attributes.get("item_name", [{}])[0].get("value"),
+            "brand": attributes.get("brand", [{}])[0].get("value"),
+            "list_price": attributes.get("list_price", [{}])[0].get("value"),
+            "sales_rank": response.get("salesRanks", [{}])[0].get("displayRank"),
+        }
+        click.echo(json.dumps(result, indent=2))
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise click.Abort()
+
+
+@cli.command()
+@click.pass_context
+def invalidate(ctx):
+    """Invalidate cached access token."""
+    ctx.obj["auth"].invalidate()
+
+
+if __name__ == "__main__":
+    cli()

amazon_sp_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: amazon-sp-cli
+Version: 0.1.0
+Summary: CLI tool for Amazon Selling Partner API (SP-API) operations
+Home-page: https://github.com/stellaraether/amazon-sp-cli
+Author: Lunan Li
+Author-email: lunan@stellaraether.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.27.0
+Requires-Dist: boto3>=1.20.0
+Requires-Dist: pyyaml>=6.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

amazon_sp_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+amazon_sp_cli/__init__.py,sha256=T_4puy5VIHfteU5oUY564XscbZMR1JoUo2w7069H3sA,42
+amazon_sp_cli/auth.py,sha256=P0Fabbd7EqUDeiHQap9vJFvqaGxqLgPfQMO9CG4rIHY,3297
+amazon_sp_cli/client.py,sha256=s1x7xflay5AKcSnK3OGHtyiv1xFnEbbuuDpzpvlbpBA,3765
+amazon_sp_cli/main.py,sha256=udsXL-1fwtouxtOYqjM_HKjczxs6pZ23iJjaUCtJB4g,5773
+amazon_sp_cli-0.1.0.dist-info/licenses/LICENSE,sha256=Rtg-CZrSD0Uralzy3OEr5wexL20SRgFiWxXINIR9up0,1071
+tests/__init__.py,sha256=Wk73Io62J15BtlLVIzxmASDWaaJkQLevS4BLK5LDAQg,16
+tests/test_auth.py,sha256=EXl6Tw4R7mMBulf8IkaG5SU-vv2QTBQsKKb7Ufla5Ug,3590
+tests/test_client.py,sha256=F-YWgaHXVVN78kGWPbXfCy28qf9BhVM0ZUVNUS-2EwA,1877
+amazon_sp_cli-0.1.0.dist-info/METADATA,sha256=UOtJUHKJoel6jUYC3i10vEqghMCzujti8Ew3SpM9yjo,951
+amazon_sp_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+amazon_sp_cli-0.1.0.dist-info/entry_points.txt,sha256=Kj3g2CyK22IQqjbT8TV2TR8b7LzckliU3Fy6oYEjqOU,50
+amazon_sp_cli-0.1.0.dist-info/top_level.txt,sha256=I2NfsRf7HfqfWbhTmATISQf055_xqBKLfrQlLHrcFCU,20
+amazon_sp_cli-0.1.0.dist-info/RECORD,,

amazon_sp_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

amazon_sp_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+amz-sp = amazon_sp_cli.main:cli

amazon_sp_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stellar Aether
+
+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_sp_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+amazon_sp_cli
+tests

tests/__init__.py

@@ -0,0 +1 @@
+# Tests package

tests/test_auth.py

@@ -0,0 +1,116 @@
+"""Tests for SP-API authentication."""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import pytest
+
+from amazon_sp_cli.auth import SPAPIAuth
+
+
+class TestSPAPIAuth:
+    """Test SPAPIAuth class."""
+
+    @pytest.fixture
+    def temp_credentials(self):
+        """Create temporary credentials file."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yml", delete=False) as f:
+            f.write("""
+default:
+  refresh_token: "test-refresh-token"
+  client_id: "test-client-id"
+  client_secret: "test-client-secret"
+""")
+            path = f.name
+        yield path
+        os.unlink(path)
+
+    @pytest.fixture
+    def temp_cache_dir(self):
+        """Create temporary cache directory."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            cache_file = Path(tmpdir) / "token-cache.json"
+            with patch.object(SPAPIAuth, "CACHE_FILE", cache_file):
+                yield cache_file
+
+    def test_load_credentials(self, temp_credentials):
+        """Test credentials loading."""
+        auth = SPAPIAuth(temp_credentials)
+        assert auth.credentials["refresh_token"] == "test-refresh-token"
+        assert auth.credentials["client_id"] == "test-client-id"
+        assert auth.credentials["client_secret"] == "test-client-secret"
+
+    def test_token_valid(self, temp_credentials, temp_cache_dir):
+        """Test token validation."""
+        auth = SPAPIAuth(temp_credentials)
+
+        # Valid token
+        valid_cache = {
+            "access_token": "valid-token",
+            "expires_at": 9999999999,
+        }
+        assert auth._is_token_valid(valid_cache) is True
+
+        # Expired token
+        expired_cache = {
+            "access_token": "expired-token",
+            "expires_at": 0,
+        }
+        assert auth._is_token_valid(expired_cache) is False
+
+        # No token
+        empty_cache = {"access_token": None}
+        assert auth._is_token_valid(empty_cache) is False
+
+    @patch("amazon_sp_cli.auth.requests.post")
+    def test_exchange_token(self, mock_post, temp_credentials, temp_cache_dir):
+        """Test token exchange."""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "access_token": "new-access-token",
+            "expires_in": 3600,
+        }
+        mock_response.raise_for_status = Mock()
+        mock_post.return_value = mock_response
+
+        auth = SPAPIAuth(temp_credentials)
+        cache = auth._exchange_token()
+
+        assert cache["access_token"] == "new-access-token"
+        assert cache["expires_at"] > 0
+
+    @patch("amazon_sp_cli.auth.requests.post")
+    def test_get_access_token_cached(self, mock_post, temp_credentials, temp_cache_dir):
+        """Test getting cached access token."""
+        auth = SPAPIAuth(temp_credentials)
+
+        # Pre-populate cache with valid token
+        cache = {
+            "access_token": "cached-token",
+            "expires_at": 9999999999,
+        }
+        auth._save_cache(cache)
+
+        token = auth.get_access_token()
+        assert token == "cached-token"
+        mock_post.assert_not_called()
+
+    def test_invalidate(self, temp_credentials, temp_cache_dir):
+        """Test token invalidation."""
+        auth = SPAPIAuth(temp_credentials)
+
+        # Pre-populate cache
+        cache = {
+            "access_token": "token",
+            "expires_at": 9999999999,
+        }
+        auth._save_cache(cache)
+
+        auth.invalidate()
+
+        new_cache = auth._load_cache()
+        assert new_cache["access_token"] is None
+        assert new_cache["expires_at"] == 0

tests/test_client.py

@@ -0,0 +1,59 @@
+"""Tests for SP-API client."""
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from amazon_sp_cli.auth import SPAPIAuth
+from amazon_sp_cli.client import SPAPIClient
+
+
+class TestSPAPIClient:
+    """Test SPAPIClient class."""
+
+    @pytest.fixture
+    def mock_auth(self):
+        """Create mock auth object."""
+        auth = Mock(spec=SPAPIAuth)
+        auth.credentials = {
+            "aws_access_key_id": "test-aws-key",
+            "aws_secret_access_key": "test-aws-secret",
+            "seller_id": "TESTSELLER",
+            "marketplace_id": "ATVPDKIKX0DER",
+        }
+        auth.get_access_token.return_value = "test-access-token"
+        return auth
+
+    @pytest.fixture
+    def client(self, mock_auth):
+        """Create SPAPIClient instance."""
+        return SPAPIClient(mock_auth)
+
+    def test_init(self, client, mock_auth):
+        """Test client initialization."""
+        assert client.auth == mock_auth
+        assert client.seller_id == "TESTSELLER"
+        assert client.marketplace_id == "ATVPDKIKX0DER"
+
+    def test_get_listing_path(self, client):
+        """Test listing path construction."""
+        path = f"/listings/2021-08-01/items/{client.seller_id}/TEST-SKU"
+        assert "TESTSELLER" in path
+        assert "TEST-SKU" in path
+
+    @patch("amazon_sp_cli.client.requests.request")
+    @patch("amazon_sp_cli.client.SigV4Auth")
+    def test_request(self, mock_signer_class, mock_request, client):
+        """Test API request."""
+        mock_response = Mock()
+        mock_response.json.return_value = {"test": "data"}
+        mock_response.text = '{"test": "data"}'
+        mock_request.return_value = mock_response
+
+        mock_signer = Mock()
+        mock_signer_class.return_value = mock_signer
+
+        result = client.request("GET", "/test/path")
+
+        assert result == {"test": "data"}
+        mock_request.assert_called_once()