amazon-sp-cli 0.2.5__tar.gz → 0.2.7__tar.gz

{amazon_sp_cli-0.2.5/amazon_sp_cli.egg-info → amazon_sp_cli-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-sp-cli
-Version: 0.2.5
+Version: 0.2.7
 Summary: CLI tool for Amazon Selling Partner API (SP-API) operations
 Home-page: https://github.com/stellaraether/amazon-sp-cli
 Author: Lunan Li

amazon_sp_cli-0.2.7/amazon_sp_cli/__init__.py

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

{amazon_sp_cli-0.2.5 → amazon_sp_cli-0.2.7}/amazon_sp_cli/client.py

@@ -9,6 +9,14 @@ from botocore.awsrequest import AWSRequest
 from botocore.credentials import Credentials
 
 
+class SPAPIError(Exception):
+    """Raised when SP-API returns an error response."""
+
+    def __init__(self, message, response_body=None):
+        super().__init__(message)
+        self.response_body = response_body
+
+
 class SPAPIClient:
     """Client for making signed requests to Amazon SP-API."""
 
@@ -55,7 +63,17 @@ class SPAPIClient:
         headers, url, body = self._sign_request(method, path, data)
 
         response = requests.request(method, url, headers=headers, data=body)
-        response.raise_for_status()
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            try:
+                error_body = response.json()
+            except ValueError:
+                error_body = None
+            raise SPAPIError(
+                _format_spapi_error(response.status_code, error_body or response.text),
+                response_body=error_body,
+            ) from exc
 
         return response.json() if response.text else {}
 
@@ -64,11 +82,41 @@ class SPAPIClient:
         path = f"/listings/2021-08-01/items/{self.seller_id}/{sku}"
         params = {
             "marketplaceIds": self.marketplace_id,
-            "includedData": "summaries,attributes",
+            "includedData": "summaries,attributes,issues,offers,fulfillmentAvailability",
         }
         path += "?" + urlencode(params)
         return self.request("GET", path)
 
+    def put_listing(
+        self, sku: str, product_type: str, attributes: dict, requirements: str = None, mode: str = None
+    ) -> dict:
+        """Create or fully replace a listing for a SKU."""
+        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": product_type,
+            "attributes": attributes,
+        }
+        if requirements:
+            data["requirements"] = requirements
+
+        return self.request("PUT", path, data)
+
+    def delete_listing(self, sku: str) -> dict:
+        """Delete a listing for a SKU."""
+        path = f"/listings/2021-08-01/items/{self.seller_id}/{sku}"
+        params = {
+            "marketplaceIds": self.marketplace_id,
+        }
+        path += "?" + urlencode(params)
+        return self.request("DELETE", 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}"
@@ -189,3 +237,22 @@ class SPAPIClient:
             params["fileName"] = file_name
         path += "?" + urlencode(params)
         return self.request("POST", path)
+
+
+def _format_spapi_error(status_code, body):
+    """Format an SP-API error into a human-readable string."""
+    if isinstance(body, dict):
+        parts = [f"SP-API returned {status_code}"]
+        for error in body.get("errors", []):
+            code = error.get("code", "Unknown")
+            message = error.get("message", "")
+            parts.append(f"  [{code}] {message}")
+        for issue in body.get("issues", []):
+            code = issue.get("code", "Unknown")
+            message = issue.get("message", "")
+            severity = issue.get("severity", "")
+            parts.append(f"  [{code}] ({severity}) {message}")
+        if len(parts) == 1:
+            parts.append(f"  {json.dumps(body)}")
+        return "\n".join(parts)
+    return f"SP-API returned {status_code}: {body}"

amazon_sp_cli-0.2.7/amazon_sp_cli/commands/listings.py

@@ -0,0 +1,191 @@
+"""Listing content management commands."""
+
+import json
+
+import click
+
+from ..cli import handle_errors
+
+
+def _build_attributes(
+    title=None,
+    description=None,
+    bullet_points=None,
+    price=None,
+    currency="USD",
+    condition=None,
+    images=None,
+    inventory=None,
+    shipping_template=None,
+    language_tag="en_US",
+    attributes_json=None,
+):
+    """Build SP-API attributes dict from CLI options."""
+    attributes = {}
+
+    if title is not None:
+        attributes["item_name"] = [{"value": title, "language_tag": language_tag}]
+
+    if description is not None:
+        attributes["product_description"] = [{"value": description, "language_tag": language_tag}]
+
+    if bullet_points:
+        attributes["bullet_point"] = [{"value": bp} for bp in bullet_points]
+
+    if price is not None:
+        attributes["list_price"] = [{"currency": currency, "value": price}]
+        attributes["purchasable_price"] = [{"currency": currency, "value": price}]
+
+    if condition is not None:
+        attributes["condition_type"] = [{"value": condition}]
+
+    if images:
+        attributes["main_product_image_locator"] = [{"media_location": images[0]}]
+        for idx, img in enumerate(images[1:], start=1):
+            if idx > 8:
+                break
+            attributes[f"other_product_image_locator_{idx}"] = [{"media_location": img}]
+
+    if inventory is not None:
+        attributes["fulfillment_availability"] = [{"quantity": inventory, "fulfillment_channel_code": "DEFAULT"}]
+
+    if shipping_template is not None:
+        attributes["merchant_shipping_group"] = [{"value": shipping_template}]
+
+    if attributes_json:
+        try:
+            extra = json.loads(attributes_json)
+        except json.JSONDecodeError as exc:
+            raise click.BadParameter(f"Invalid JSON in --attributes-json: {exc}")
+        if not isinstance(extra, dict):
+            raise click.BadParameter("--attributes-json must be a JSON object")
+        attributes.update(extra)
+
+    return attributes
+
+
+def _check_issues(response):
+    """Check response for issues and exit with error if any ERROR severity items exist."""
+    issues = response.get("issues", [])
+    errors = [i for i in issues if i.get("severity") == "ERROR"]
+    if errors:
+        click.echo("Validation issues found:", err=True)
+        for issue in issues:
+            code = issue.get("code", "Unknown")
+            message = issue.get("message", "")
+            severity = issue.get("severity", "")
+            click.echo(f"  [{code}] ({severity}) {message}", err=True)
+        raise click.Abort()
+    return issues
+
+
+def register_listings_commands(cli_group, ensure_auth_client):
+    """Register listing management CLI commands."""
+
+    @cli_group.command()
+    @click.argument("sku")
+    @click.pass_context
+    @handle_errors
+    def get_listing(ctx, sku):
+        """Get full listing data for a SKU."""
+        _, client = ensure_auth_client(ctx)
+        response = client.get_listing(sku)
+        click.echo(json.dumps(response, indent=2))
+
+    @cli_group.command()
+    @click.argument("sku")
+    @click.option("--product-type", "-p", required=True, help="SP-API product type (e.g., PET_TOY)")
+    @click.option(
+        "--requirements",
+        type=click.Choice(["LISTING", "LISTING_PRODUCT_ONLY", "LISTING_OFFER_ONLY"]),
+        default="LISTING",
+        help="Requirements level for the update",
+    )
+    @click.option("--title", help="Item title")
+    @click.option("--description", help="Product description")
+    @click.option("--bullet-point", multiple=True, help="Bullet point (can be used multiple times)")
+    @click.option("--price", type=float, help="List price")
+    @click.option("--currency", default="USD", help="Currency code (default USD)")
+    @click.option("--condition", help="Condition type (e.g., new_new)")
+    @click.option("--image", multiple=True, help="Image URL (first becomes main, rest become other)")
+    @click.option("--inventory", type=int, help="Available quantity")
+    @click.option("--shipping-template", help="Merchant shipping group name")
+    @click.option("--language-tag", default="en_US", help="Language tag for text attributes")
+    @click.option(
+        "--attributes-json",
+        help="Raw JSON string of additional attributes (merged on top of other flags)",
+    )
+    @click.option("--dry-run", is_flag=True, help="Validate without applying")
+    @click.pass_context
+    @handle_errors
+    def update_listing(
+        ctx,
+        sku,
+        product_type,
+        requirements,
+        title,
+        description,
+        bullet_point,
+        price,
+        currency,
+        condition,
+        image,
+        inventory,
+        shipping_template,
+        language_tag,
+        attributes_json,
+        dry_run,
+    ):
+        """Update listing attributes for a SKU."""
+        _, client = ensure_auth_client(ctx)
+
+        attributes = _build_attributes(
+            title=title,
+            description=description,
+            bullet_points=bullet_point or None,
+            price=price,
+            currency=currency,
+            condition=condition,
+            images=image or None,
+            inventory=inventory,
+            shipping_template=shipping_template,
+            language_tag=language_tag,
+            attributes_json=attributes_json,
+        )
+
+        if not attributes:
+            click.echo("Error: No attributes provided. Use flags or --attributes-json.", err=True)
+            raise click.Abort()
+
+        mode = "VALIDATION_PREVIEW" if dry_run else None
+        response = client.put_listing(
+            sku,
+            product_type=product_type,
+            attributes=attributes,
+            requirements=requirements,
+            mode=mode,
+        )
+
+        issues = _check_issues(response)
+        if dry_run and issues:
+            click.echo("Validation warnings:")
+            for issue in issues:
+                code = issue.get("code", "Unknown")
+                message = issue.get("message", "")
+                severity = issue.get("severity", "")
+                click.echo(f"  [{code}] ({severity}) {message}")
+            click.echo("Validation passed with warnings")
+        elif dry_run:
+            click.echo("Validation passed")
+        else:
+            click.echo(json.dumps(response, indent=2))
+
+    @cli_group.command()
+    @click.argument("sku")
+    @click.pass_context
+    @handle_errors
+    def delete_listing(ctx, sku):
+        """Delete a listing for a SKU."""
+        _, client = ensure_auth_client(ctx)
+        response = client.delete_listing(sku)
+        click.echo(json.dumps(response, indent=2))

{amazon_sp_cli-0.2.5 → amazon_sp_cli-0.2.7}/amazon_sp_cli/main.py

@@ -3,8 +3,10 @@
 from .cli import _ensure_auth_client, cli
 from .commands.a_plus import register_a_plus_commands
 from .commands.auth import register_auth_commands
+from .commands.listings import register_listings_commands
 from .commands.pricing import register_pricing_commands
 
 register_auth_commands(cli)
+register_listings_commands(cli, _ensure_auth_client)
 register_pricing_commands(cli, _ensure_auth_client)
 register_a_plus_commands(cli, _ensure_auth_client)

{amazon_sp_cli-0.2.5 → amazon_sp_cli-0.2.7}/amazon_sp_cli/models/a_plus.py

@@ -76,6 +76,26 @@ class StandardSingleImageModule:
         return result
 
 
+class StandardSingleSideImageModule:
+    """Standard Single Side Image module."""
+
+    def __init__(self, image=None, description=None, image_position_type="LEFT"):
+        self.image = image
+        self.description = description
+        self.image_position_type = image_position_type
+
+    def to_dict(self) -> dict:
+        result = {"imagePositionType": self.image_position_type}
+        block = {}
+        if self.image:
+            block["image"] = self.image.to_dict()
+        if self.description:
+            block["description"] = self.description.to_dict()
+        if block:
+            result["block"] = block
+        return result
+
+
 class StandardMultipleImageTextModule:
     """Standard Multiple Image & Text module."""
 
@@ -192,6 +212,7 @@ class ContentModule:
     MODULE_TYPES = {
         "STANDARD_IMAGE_TEXT": "standardImageTextOverlay",
         "STANDARD_SINGLE_IMAGE": "standardSingleImage",
+        "STANDARD_SINGLE_SIDE_IMAGE": "standardSingleSideImage",
         "STANDARD_MULTIPLE_IMAGE_TEXT": "standardMultipleImageText",
         "STANDARD_FOUR_IMAGE_TEXT": "standardFourImageText",
         "STANDARD_COMPARISON_TABLE": "standardComparisonTable",
@@ -205,6 +226,7 @@ class ContentModule:
         module_type: str,
         standard_image_text: StandardImageTextModule = None,
         standard_single_image: StandardSingleImageModule = None,
+        standard_single_side_image: StandardSingleSideImageModule = None,
         standard_multiple_image_text: StandardMultipleImageTextModule = None,
         standard_four_image_text: StandardFourImageTextModule = None,
         standard_comparison_table: StandardComparisonTableModule = None,
@@ -215,6 +237,7 @@ class ContentModule:
         self.module_type = module_type
         self.standard_image_text = standard_image_text
         self.standard_single_image = standard_single_image
+        self.standard_single_side_image = standard_single_side_image
         self.standard_multiple_image_text = standard_multiple_image_text
         self.standard_four_image_text = standard_four_image_text
         self.standard_comparison_table = standard_comparison_table
@@ -230,6 +253,8 @@ class ContentModule:
             result["standardImageTextOverlay"] = self.standard_image_text_overlay.to_dict()
         elif field_name == "standardSingleImage" and self.standard_single_image:
             result["standardSingleImage"] = self.standard_single_image.to_dict()
+        elif field_name == "standardSingleSideImage" and self.standard_single_side_image:
+            result["standardSingleSideImage"] = self.standard_single_side_image.to_dict()
         elif field_name == "standardMultipleImageText" and self.standard_multiple_image_text:
             result["standardMultipleImageText"] = self.standard_multiple_image_text.to_dict()
         elif field_name == "standardFourImageText" and self.standard_four_image_text:
@@ -357,6 +382,26 @@ def build_module_from_json(data: dict) -> ContentModule:
                 image_caption=TextComponent(data["caption"]) if data.get("caption") else None,
             ),
         )
+    elif module_type == "STANDARD_SINGLE_SIDE_IMAGE":
+        description = None
+        if data.get("description"):
+            description = ParagraphComponent(text_list=[TextComponent(data["description"])])
+        return ContentModule(
+            module_type=module_type,
+            standard_single_side_image=StandardSingleSideImageModule(
+                image=(
+                    ImageComponent(
+                        data["imageId"],
+                        alt_text=data.get("altText"),
+                        image_crop_specification=data.get("imageCropSpecification"),
+                    )
+                    if data.get("imageId")
+                    else None
+                ),
+                description=description,
+                image_position_type=data.get("imagePositionType", "LEFT"),
+            ),
+        )
     elif module_type == "STANDARD_MULTIPLE_IMAGE_TEXT":
         return ContentModule(
             module_type=module_type,

{amazon_sp_cli-0.2.5 → amazon_sp_cli-0.2.7/amazon_sp_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-sp-cli
-Version: 0.2.5
+Version: 0.2.7
 Summary: CLI tool for Amazon Selling Partner API (SP-API) operations
 Home-page: https://github.com/stellaraether/amazon-sp-cli
 Author: Lunan Li

{amazon_sp_cli-0.2.5 → amazon_sp_cli-0.2.7}/amazon_sp_cli.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ amazon_sp_cli.egg-info/top_level.txt
 amazon_sp_cli/commands/__init__.py
 amazon_sp_cli/commands/a_plus.py
 amazon_sp_cli/commands/auth.py
+amazon_sp_cli/commands/listings.py
 amazon_sp_cli/commands/pricing.py
 amazon_sp_cli/models/__init__.py
 amazon_sp_cli/models/a_plus.py
@@ -25,4 +26,5 @@ tests/__init__.py
 tests/test_a_plus.py
 tests/test_auth.py
 tests/test_client.py
+tests/test_listings.py
 tests/test_pricing.py

{amazon_sp_cli-0.2.5 → amazon_sp_cli-0.2.7}/tests/test_a_plus.py

@@ -166,6 +166,21 @@ class TestBuildFromJson:
         assert result["standardImageTextOverlay"]["block"]["headline"]["value"] == "H"
         assert result["standardImageTextOverlay"]["block"]["body"]["textList"][0]["value"] == "B"
 
+    def test_build_module_single_side_image(self):
+        data = {
+            "moduleType": "STANDARD_SINGLE_SIDE_IMAGE",
+            "imageId": "img-1",
+            "altText": "Side",
+            "description": "Desc",
+            "imagePositionType": "RIGHT",
+        }
+        mod = build_module_from_json(data)
+        assert mod.module_type == "STANDARD_SINGLE_SIDE_IMAGE"
+        result = mod.to_dict()
+        assert result["standardSingleSideImage"]["imagePositionType"] == "RIGHT"
+        assert result["standardSingleSideImage"]["block"]["image"]["uploadDestinationId"] == "img-1"
+        assert result["standardSingleSideImage"]["block"]["description"]["textList"][0]["value"] == "Desc"
+
     def test_build_module_comparison_table(self):
         data = {
             "moduleType": "STANDARD_COMPARISON_TABLE",

amazon_sp_cli-0.2.7/tests/test_listings.py

@@ -0,0 +1,391 @@
+"""Tests for listing commands."""
+
+import json
+from unittest.mock import Mock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from amazon_sp_cli.main import cli
+
+
+class TestGetListing:
+    """Test get-listing command."""
+
+    @pytest.fixture
+    def mock_listing_response(self):
+        """Mock full listing response."""
+        return {
+            "summaries": [{"asin": "B09BBL8T4Z", "status": ["ACTIVE"]}],
+            "attributes": {
+                "item_name": [{"value": "Test Product", "language_tag": "en_US"}],
+                "list_price": [{"currency": "USD", "value": 29.99}],
+            },
+            "issues": [],
+        }
+
+    @pytest.fixture
+    def runner(self):
+        """Create Click test runner."""
+        return CliRunner()
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_get_listing(self, mock_client_class, mock_auth_class, runner, mock_listing_response):
+        """Test fetching a listing."""
+        mock_client = Mock()
+        mock_client.get_listing.return_value = mock_listing_response
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(cli, ["get-listing", "TEST-SKU"])
+
+        assert result.exit_code == 0
+        output = json.loads(result.output)
+        assert output["summaries"][0]["asin"] == "B09BBL8T4Z"
+        assert output["attributes"]["item_name"][0]["value"] == "Test Product"
+
+
+class TestUpdateListing:
+    """Test update-listing command."""
+
+    @pytest.fixture
+    def runner(self):
+        """Create Click test runner."""
+        return CliRunner()
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_with_title(self, mock_client_class, mock_auth_class, runner):
+        """Test updating a listing title."""
+        mock_client = Mock()
+        mock_client.put_listing.return_value = {"sku": "TEST-SKU", "status": "ACCEPTED"}
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+                "--title",
+                "New Title",
+            ],
+        )
+
+        assert result.exit_code == 0
+        mock_client.put_listing.assert_called_once()
+        call_args = mock_client.put_listing.call_args
+        assert call_args.kwargs["product_type"] == "PET_TOY"
+        assert call_args.kwargs["attributes"]["item_name"] == [{"value": "New Title", "language_tag": "en_US"}]
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_with_multiple_flags(self, mock_client_class, mock_auth_class, runner):
+        """Test updating multiple attributes at once."""
+        mock_client = Mock()
+        mock_client.put_listing.return_value = {"sku": "TEST-SKU", "status": "ACCEPTED"}
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+                "--title",
+                "New Title",
+                "--description",
+                "New Description",
+                "--bullet-point",
+                "Point 1",
+                "--bullet-point",
+                "Point 2",
+                "--price",
+                "19.99",
+                "--condition",
+                "new_new",
+                "--inventory",
+                "100",
+                "--shipping-template",
+                "Std Template",
+            ],
+        )
+
+        assert result.exit_code == 0
+        attrs = mock_client.put_listing.call_args.kwargs["attributes"]
+        assert attrs["item_name"] == [{"value": "New Title", "language_tag": "en_US"}]
+        assert attrs["product_description"] == [{"value": "New Description", "language_tag": "en_US"}]
+        assert attrs["bullet_point"] == [{"value": "Point 1"}, {"value": "Point 2"}]
+        assert attrs["list_price"] == [{"currency": "USD", "value": 19.99}]
+        assert attrs["purchasable_price"] == [{"currency": "USD", "value": 19.99}]
+        assert attrs["condition_type"] == [{"value": "new_new"}]
+        assert attrs["fulfillment_availability"] == [{"quantity": 100, "fulfillment_channel_code": "DEFAULT"}]
+        assert attrs["merchant_shipping_group"] == [{"value": "Std Template"}]
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_with_images(self, mock_client_class, mock_auth_class, runner):
+        """Test updating images."""
+        mock_client = Mock()
+        mock_client.put_listing.return_value = {"sku": "TEST-SKU", "status": "ACCEPTED"}
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+                "--image",
+                "https://example.com/main.jpg",
+                "--image",
+                "https://example.com/other1.jpg",
+                "--image",
+                "https://example.com/other2.jpg",
+            ],
+        )
+
+        assert result.exit_code == 0
+        attrs = mock_client.put_listing.call_args.kwargs["attributes"]
+        assert attrs["main_product_image_locator"] == [{"media_location": "https://example.com/main.jpg"}]
+        assert attrs["other_product_image_locator_1"] == [{"media_location": "https://example.com/other1.jpg"}]
+        assert attrs["other_product_image_locator_2"] == [{"media_location": "https://example.com/other2.jpg"}]
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_with_attributes_json(self, mock_client_class, mock_auth_class, runner):
+        """Test updating with raw attributes JSON."""
+        mock_client = Mock()
+        mock_client.put_listing.return_value = {"sku": "TEST-SKU", "status": "ACCEPTED"}
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+                "--attributes-json",
+                '{"item_name": [{"value": "JSON Title", "language_tag": "en_US"}]}',
+            ],
+        )
+
+        assert result.exit_code == 0
+        attrs = mock_client.put_listing.call_args.kwargs["attributes"]
+        assert attrs["item_name"] == [{"value": "JSON Title", "language_tag": "en_US"}]
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_flags_override_json(self, mock_client_class, mock_auth_class, runner):
+        """Test that CLI flags override --attributes-json for same keys."""
+        mock_client = Mock()
+        mock_client.put_listing.return_value = {"sku": "TEST-SKU", "status": "ACCEPTED"}
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+                "--title",
+                "Flag Title",
+                "--attributes-json",
+                '{"item_name": [{"value": "JSON Title", "language_tag": "en_US"}]}',
+            ],
+        )
+
+        assert result.exit_code == 0
+        attrs = mock_client.put_listing.call_args.kwargs["attributes"]
+        # flags are built first, then attributes_json is merged on top
+        assert attrs["item_name"] == [{"value": "JSON Title", "language_tag": "en_US"}]
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_dry_run(self, mock_client_class, mock_auth_class, runner):
+        """Test dry-run mode."""
+        mock_client = Mock()
+        mock_client.put_listing.return_value = {"sku": "TEST-SKU", "issues": []}
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+                "--title",
+                "New Title",
+                "--dry-run",
+            ],
+        )
+
+        assert result.exit_code == 0
+        assert "Validation passed" in result.output
+        assert mock_client.put_listing.call_args.kwargs["mode"] == "VALIDATION_PREVIEW"
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_with_issues(self, mock_client_class, mock_auth_class, runner):
+        """Test that ERROR issues cause failure."""
+        mock_client = Mock()
+        mock_client.put_listing.return_value = {
+            "sku": "TEST-SKU",
+            "issues": [
+                {
+                    "code": "99022",
+                    "message": "Invalid attribute",
+                    "severity": "ERROR",
+                }
+            ],
+        }
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+                "--title",
+                "New Title",
+            ],
+        )
+
+        assert result.exit_code != 0
+        assert "Validation issues found" in result.output
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_no_attributes(self, mock_client_class, mock_auth_class, runner):
+        """Test error when no attributes are provided."""
+        mock_client = Mock()
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+            ],
+        )
+
+        assert result.exit_code != 0
+        assert "No attributes provided" in result.output
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_invalid_json(self, mock_client_class, mock_auth_class, runner):
+        """Test error with invalid attributes JSON."""
+        mock_client = Mock()
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+                "--attributes-json",
+                "not json",
+            ],
+        )
+
+        assert result.exit_code != 0
+        assert "Invalid JSON" in result.output
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_update_listing_requirements_option(self, mock_client_class, mock_auth_class, runner):
+        """Test requirements option is passed through."""
+        mock_client = Mock()
+        mock_client.put_listing.return_value = {"sku": "TEST-SKU", "status": "ACCEPTED"}
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(
+            cli,
+            [
+                "update-listing",
+                "TEST-SKU",
+                "--product-type",
+                "PET_TOY",
+                "--requirements",
+                "LISTING_OFFER_ONLY",
+                "--price",
+                "9.99",
+            ],
+        )
+
+        assert result.exit_code == 0
+        call_args = mock_client.put_listing.call_args
+        assert call_args.kwargs["requirements"] == "LISTING_OFFER_ONLY"
+
+
+class TestDeleteListing:
+    """Test delete-listing command."""
+
+    @pytest.fixture
+    def runner(self):
+        """Create Click test runner."""
+        return CliRunner()
+
+    @patch("amazon_sp_cli.cli.SPAPIAuth")
+    @patch("amazon_sp_cli.cli.SPAPIClient")
+    def test_delete_listing(self, mock_client_class, mock_auth_class, runner):
+        """Test deleting a listing."""
+        mock_client = Mock()
+        mock_client.delete_listing.return_value = {"sku": "TEST-SKU", "status": "ACCEPTED"}
+        mock_client_class.return_value = mock_client
+
+        mock_auth = Mock()
+        mock_auth_class.return_value = mock_auth
+
+        result = runner.invoke(cli, ["delete-listing", "TEST-SKU"])
+
+        assert result.exit_code == 0
+        mock_client.delete_listing.assert_called_once_with("TEST-SKU")
+        output = json.loads(result.output)
+        assert output["status"] == "ACCEPTED"

amazon_sp_cli-0.2.5/amazon_sp_cli/__init__.py

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