wildberries-cli 0.1.0__py3-none-any.whl

wildberries_cli/__init__.py

@@ -0,0 +1 @@
+"""wildberries-cli package."""

wildberries_cli/args.py

@@ -0,0 +1,65 @@
+"""CLI argument parsing helpers."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Iterable
+
+from wildberries_cli.output import read_text_arg
+
+
+def load_json_input(body_json: str | None = None, body_file: str | None = None) -> Any:
+    """Load JSON from one source (`--body-json` or `--body-file`)."""
+    if body_json and body_file:
+        raise ValueError("Use only one of --body-json or --body-file")
+    if body_json is None and body_file is None:
+        raise ValueError("Body JSON is required")
+
+    if body_json is not None:
+        text = read_text_arg(body_json)
+    else:
+        if body_file == "-":
+            text = read_text_arg("-")
+        else:
+            text = Path(str(body_file)).read_text()
+
+    return json.loads(text)
+
+
+def parse_rfc3339ish(value: str) -> datetime:
+    """Parse an RFC3339-ish datetime/date string accepted by the SDK."""
+    text = value.strip()
+    if text.endswith("Z"):
+        text = text[:-1] + "+00:00"
+    try:
+        return datetime.fromisoformat(text)
+    except ValueError as exc:
+        raise ValueError(f"Invalid datetime '{value}'. Use ISO/RFC3339 (e.g. 2024-01-01 or 2024-01-01T12:00:00+03:00).") from exc
+
+
+def parse_kv_pairs(items: Iterable[str]) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for item in items:
+        key, value = _split_kv(item)
+        out[key] = value
+    return out
+
+
+def parse_json_kv_pairs(items: Iterable[str]) -> dict[str, Any]:
+    out: dict[str, Any] = {}
+    for item in items:
+        key, value = _split_kv(item)
+        out[key] = json.loads(value)
+    return out
+
+
+def _split_kv(item: str) -> tuple[str, str]:
+    if "=" not in item:
+        raise ValueError(f"Expected KEY=VALUE, got '{item}'")
+    key, value = item.split("=", 1)
+    key = key.strip()
+    if not key:
+        raise ValueError(f"Expected KEY=VALUE, got '{item}'")
+    return key, value

wildberries_cli/client.py

@@ -0,0 +1,159 @@
+"""Dynamic Wildberries SDK client factory and API invocation helpers."""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+import pkgutil
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import typer
+import wildberries_sdk
+
+from wildberries_cli.output import print_error
+
+if TYPE_CHECKING:
+    from wildberries_cli.config import Config
+
+
+@dataclass
+class ModuleClient:
+    module_name: str
+    sdk_module: Any
+    api: Any
+
+
+def list_sdk_modules() -> list[str]:
+    return sorted(m.name for m in pkgutil.iter_modules(wildberries_sdk.__path__))
+
+
+def list_methods(module_name: str) -> list[str]:
+    cls = _get_default_api_class(normalize_module_name(module_name))
+    methods = []
+    for name, fn in inspect.getmembers(cls, inspect.isfunction):
+        if name.startswith("_"):
+            continue
+        methods.append(name)
+    return sorted(methods)
+
+
+def method_signature(module_name: str, method_name: str) -> str:
+    cls = _get_default_api_class(normalize_module_name(module_name))
+    fn = getattr(cls, method_name, None)
+    if fn is None or not callable(fn):
+        raise AttributeError(f"Method '{method_name}' not found in module '{module_name}'")
+    return f"{method_name}{inspect.signature(fn)}"
+
+
+def get_module_client(module_name: str, cfg: "Config", *, require_token: bool = True) -> ModuleClient:
+    module_name = normalize_module_name(module_name)
+    if require_token:
+        _require_token(cfg)
+
+    sdk_module = importlib.import_module(f"wildberries_sdk.{module_name}")
+    Configuration = getattr(sdk_module, "Configuration")
+    ApiClient = getattr(sdk_module, "ApiClient")
+    DefaultApi = getattr(sdk_module, "DefaultApi")
+
+    conf_kwargs: dict[str, Any] = {}
+    if cfg.api_token:
+        conf_kwargs["api_key"] = {"HeaderApiKey": cfg.api_token}
+    if cfg.retries:
+        conf_kwargs["retries"] = cfg.retries
+    conf = Configuration(**conf_kwargs)
+    api_client = ApiClient(conf)
+    api = DefaultApi(api_client)
+    return ModuleClient(module_name=module_name, sdk_module=sdk_module, api=api)
+
+
+def call_api(
+    module_name: str,
+    method_name: str,
+    cfg: "Config",
+    *,
+    require_token: bool = True,
+    **kwargs: Any,
+) -> Any:
+    client = get_module_client(module_name, cfg, require_token=require_token)
+    fn = getattr(client.api, method_name, None)
+    if fn is None or not callable(fn):
+        print_error("validation_error", f"Unknown method '{method_name}' for module '{client.module_name}'")
+        raise typer.Exit(1)
+    return call_with_retry(fn, cfg, **kwargs)
+
+
+def call_with_retry(fn: Any, cfg: "Config", **kwargs: Any) -> Any:
+    sig = inspect.signature(fn)
+    if "_request_timeout" in sig.parameters and "_request_timeout" not in kwargs:
+        kwargs["_request_timeout"] = cfg.timeout_seconds
+
+    max_attempts = max(1, int(cfg.retries))
+    for attempt in range(max_attempts):
+        try:
+            return fn(**kwargs)
+        except Exception as exc:
+            status = getattr(exc, "status", None)
+            if status in {429, 500, 502, 503, 504} and attempt < max_attempts - 1:
+                delay = _retry_after_seconds(exc) or min(2 ** attempt, 10)
+                time.sleep(delay)
+                continue
+            _handle_exception(exc)
+            raise typer.Exit(1)
+
+    raise typer.Exit(1)
+
+
+def normalize_module_name(value: str) -> str:
+    return value.replace("-", "_").strip()
+
+
+def _require_token(cfg: "Config") -> None:
+    if not cfg.api_token:
+        print_error(
+            "auth_error",
+            "No WB API token configured. Set WB_API_TOKEN, use --api-token, or run `wb config init`.",
+        )
+        raise typer.Exit(1)
+
+
+def _get_default_api_class(module_name: str) -> Any:
+    sdk_module = importlib.import_module(f"wildberries_sdk.{module_name}")
+    return getattr(sdk_module, "DefaultApi")
+
+
+def _retry_after_seconds(exc: Exception) -> int | None:
+    headers = getattr(exc, "headers", None)
+    if not headers:
+        return None
+    try:
+        value = headers.get("Retry-After")  # type: ignore[union-attr]
+        if value is None:
+            return None
+        return max(1, int(value))
+    except Exception:
+        return None
+
+
+def _handle_exception(exc: Exception) -> None:
+    status = getattr(exc, "status", None)
+    message = str(exc)
+    detail = getattr(exc, "body", None)
+
+    if status == 401:
+        print_error("auth_error", "Authentication failed. Check WB_API_TOKEN.", status_code=status, detail=detail)
+        return
+    if status == 403:
+        print_error("forbidden", "Permission denied or token lacks required scope.", status_code=status, detail=detail)
+        return
+    if status == 404:
+        print_error("not_found", "Resource not found.", status_code=status, detail=detail)
+        return
+    if status == 429:
+        print_error("rate_limit", "Rate limit exceeded.", status_code=status, detail=detail)
+        return
+    if status is not None:
+        print_error("api_error", message, status_code=status, detail=detail)
+        return
+    print_error("cli_error", message)

wildberries_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""wb command modules."""

wildberries_cli/commands/communications.py

@@ -0,0 +1,128 @@
+"""communications subcommand (feedbacks/questions)."""
+
+from __future__ import annotations
+
+import typer
+
+from wildberries_cli.client import call_api
+from wildberries_cli.config import Config
+from wildberries_cli.output import emit, feedbacks_table, print_error, questions_table, read_text_arg
+from wildberries_cli.serialize import to_data
+
+app = typer.Typer(name="communications", help="Buyer communications APIs.", no_args_is_help=True)
+feedbacks_app = typer.Typer(name="feedbacks", help="Feedbacks API.", no_args_is_help=True)
+questions_app = typer.Typer(name="questions", help="Questions API.", no_args_is_help=True)
+app.add_typer(feedbacks_app, name="feedbacks")
+app.add_typer(questions_app, name="questions")
+
+
+@feedbacks_app.command("list")
+def feedbacks_list(
+    ctx: typer.Context,
+    answered: bool = typer.Option(..., "--answered/--unanswered", help="Filter by answered state"),
+    take: int = typer.Option(100, "--take", min=1, max=5000, help="Number of feedbacks to return"),
+    skip: int = typer.Option(0, "--skip", min=0, help="Offset"),
+    nm_id: int | None = typer.Option(None, "--nm-id", help="WB nmID"),
+    order: str | None = typer.Option(None, "--order", help="dateAsc or dateDesc"),
+    date_from: int | None = typer.Option(None, "--date-from", help="Unix timestamp start"),
+    date_to: int | None = typer.Option(None, "--date-to", help="Unix timestamp end"),
+) -> None:
+    cfg: Config = ctx.obj
+    kwargs = {
+        "is_answered": answered,
+        "take": take,
+        "skip": skip,
+        "nm_id": nm_id,
+        "order": order,
+        "date_from": date_from,
+        "date_to": date_to,
+    }
+    data = to_data(call_api("communications", "api_v1_feedbacks_get", cfg, **{k: v for k, v in kwargs.items() if v is not None}))
+    emit(data, pretty=cfg.pretty, table_builder=feedbacks_table)
+
+
+@feedbacks_app.command("get")
+def feedbacks_get(ctx: typer.Context, feedback_id: str = typer.Argument(..., help="Feedback ID")) -> None:
+    cfg: Config = ctx.obj
+    data = to_data(call_api("communications", "api_v1_feedback_get", cfg, id=feedback_id))
+    emit(data, pretty=cfg.pretty)
+
+
+@feedbacks_app.command("answer")
+def feedbacks_answer(
+    ctx: typer.Context,
+    feedback_id: str = typer.Argument(..., help="Feedback ID"),
+    text: str = typer.Option(..., "--text", help="Answer text or '-' for stdin"),
+) -> None:
+    cfg: Config = ctx.obj
+    try:
+        from wildberries_sdk.communications import ApiV1FeedbacksAnswerPostRequest
+
+        req = ApiV1FeedbacksAnswerPostRequest(id=feedback_id, text=read_text_arg(text))
+    except Exception as exc:
+        print_error("validation_error", f"Invalid feedback answer payload: {exc}")
+        raise typer.Exit(1)
+
+    data = to_data(call_api("communications", "api_v1_feedbacks_answer_post", cfg, api_v1_feedbacks_answer_post_request=req))
+    emit(data if data is not None else {"ok": True, "id": feedback_id}, pretty=cfg.pretty)
+
+
+@questions_app.command("list")
+def questions_list(
+    ctx: typer.Context,
+    answered: bool = typer.Option(..., "--answered/--unanswered", help="Filter by answered state"),
+    take: int = typer.Option(100, "--take", min=1, max=10000, help="Number of questions to return"),
+    skip: int = typer.Option(0, "--skip", min=0, help="Offset"),
+    nm_id: int | None = typer.Option(None, "--nm-id", help="WB nmID"),
+    order: str | None = typer.Option(None, "--order", help="dateAsc or dateDesc"),
+    date_from: int | None = typer.Option(None, "--date-from", help="Unix timestamp start"),
+    date_to: int | None = typer.Option(None, "--date-to", help="Unix timestamp end"),
+) -> None:
+    cfg: Config = ctx.obj
+    kwargs = {
+        "is_answered": answered,
+        "take": take,
+        "skip": skip,
+        "nm_id": nm_id,
+        "order": order,
+        "date_from": date_from,
+        "date_to": date_to,
+    }
+    data = to_data(call_api("communications", "api_v1_questions_get", cfg, **{k: v for k, v in kwargs.items() if v is not None}))
+    emit(data, pretty=cfg.pretty, table_builder=questions_table)
+
+
+@questions_app.command("get")
+def questions_get(ctx: typer.Context, question_id: str = typer.Argument(..., help="Question ID")) -> None:
+    cfg: Config = ctx.obj
+    data = to_data(call_api("communications", "api_v1_question_get", cfg, id=question_id))
+    emit(data, pretty=cfg.pretty)
+
+
+@questions_app.command("answer")
+def questions_answer(
+    ctx: typer.Context,
+    question_id: str = typer.Argument(..., help="Question ID"),
+    text: str = typer.Option(..., "--text", help="Answer text or '-' for stdin"),
+    state: str = typer.Option("wbRu", "--state", help="Question state (`wbRu` to publish answer, `none` to reject)")
+) -> None:
+    cfg: Config = ctx.obj
+    try:
+        from wildberries_sdk.communications import (
+            ApiV1QuestionsPatchRequest,
+            ApiV1QuestionsPatchRequestOneOf1,
+            ApiV1QuestionsPatchRequestOneOf1Answer,
+        )
+
+        payload = ApiV1QuestionsPatchRequestOneOf1(
+            id=question_id,
+            answer=ApiV1QuestionsPatchRequestOneOf1Answer(text=read_text_arg(text)),
+            state=state,
+        )
+        req = ApiV1QuestionsPatchRequest(actual_instance=payload)
+    except Exception as exc:
+        print_error("validation_error", f"Invalid question answer payload: {exc}")
+        raise typer.Exit(1)
+
+    data = to_data(call_api("communications", "api_v1_questions_patch", cfg, api_v1_questions_patch_request=req))
+    emit(data, pretty=cfg.pretty)

wildberries_cli/commands/config_cmd.py

@@ -0,0 +1,91 @@
+"""config subcommand: show / set / init."""
+
+from __future__ import annotations
+
+import sys
+
+import typer
+from rich.console import Console
+from rich.prompt import Prompt
+
+from wildberries_cli.client import call_api
+from wildberries_cli.config import Config, CONFIG_PATH, config_as_dict, load_config, save_config, save_config_key
+from wildberries_cli.output import print_error, print_json
+from wildberries_cli.serialize import to_data
+
+app = typer.Typer(name="config", help="Manage wb CLI configuration.", no_args_is_help=True)
+console = Console()
+
+
+@app.command("show")
+def config_show(
+    ctx: typer.Context,
+    reveal: bool = typer.Option(False, "--reveal", help="Show full API token."),
+) -> None:
+    cfg: Config = ctx.obj
+    print_json(config_as_dict(cfg, reveal=reveal))
+
+
+@app.command("set")
+def config_set(
+    key: str = typer.Argument(..., help="Dotted config key, e.g. core.retries"),
+    value: str = typer.Argument(..., help="Value to set"),
+) -> None:
+    try:
+        save_config_key(key, value)
+        print_json({"ok": True, "key": key, "value": value})
+    except Exception as exc:
+        print_error("config_error", f"Failed to write config: {exc}")
+        raise typer.Exit(1)
+
+
+@app.command("init")
+def config_init(ctx: typer.Context) -> None:
+    if not sys.stdin.isatty():
+        print_error("validation_error", "`wb config init` requires an interactive terminal.")
+        raise typer.Exit(1)
+
+    cfg: Config = ctx.obj
+    console.print("[bold]wb setup wizard[/bold]")
+    console.print(f"Config will be saved to: [dim]{CONFIG_PATH}[/dim]\n")
+
+    api_token = Prompt.ask("WB API token", password=True, default=cfg.api_token or "")
+    timeout_text = Prompt.ask("Request timeout (seconds)", default=str(cfg.timeout_seconds))
+    retries_text = Prompt.ask("Retry attempts", default=str(cfg.retries))
+    locale_text = Prompt.ask("Default locale (ru/en/zh, optional)", default=cfg.locale or "")
+
+    if not api_token:
+        print_error("validation_error", "WB API token is required.")
+        raise typer.Exit(1)
+
+    try:
+        timeout_seconds = float(timeout_text)
+        retries = int(retries_text)
+    except ValueError:
+        print_error("validation_error", "Timeout must be a number and retries must be an integer.")
+        raise typer.Exit(1)
+
+    new_cfg = load_config()
+    new_cfg.api_token = api_token
+    new_cfg.timeout_seconds = timeout_seconds
+    new_cfg.retries = retries
+    new_cfg.locale = locale_text or None
+
+    console.print("\nValidating token with `general.api_v1_seller_info_get`…")
+    try:
+        result = call_api("general", "api_v1_seller_info_get", new_cfg)
+        seller = to_data(result)
+        seller_name = seller.get("name") if isinstance(seller, dict) else None
+        if seller_name:
+            console.print(f"[green]✓[/green] Connected as: {seller_name}")
+        else:
+            console.print("[green]✓[/green] Token is valid")
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        print_error("auth_error", f"Validation failed: {exc}")
+        raise typer.Exit(1)
+
+    save_config(new_cfg)
+    console.print(f"\n[green]✓[/green] Config saved to {CONFIG_PATH}")
+    print_json(config_as_dict(new_cfg))

wildberries_cli/commands/general.py

@@ -0,0 +1,45 @@
+"""general subcommand: ping / seller-info / users."""
+
+from __future__ import annotations
+
+import typer
+
+from wildberries_cli.client import call_api
+from wildberries_cli.config import Config
+from wildberries_cli.output import emit
+from wildberries_cli.serialize import to_data
+
+app = typer.Typer(name="general", help="General Wildberries seller APIs.", no_args_is_help=True)
+
+
+@app.command("ping")
+def ping(ctx: typer.Context) -> None:
+    cfg: Config = ctx.obj
+    data = to_data(call_api("general", "ping_get", cfg, require_token=False))
+    emit(data, pretty=cfg.pretty)
+
+
+@app.command("seller-info")
+def seller_info(ctx: typer.Context) -> None:
+    cfg: Config = ctx.obj
+    data = to_data(call_api("general", "api_v1_seller_info_get", cfg))
+    emit(data, pretty=cfg.pretty)
+
+
+@app.command("users")
+def users_list(
+    ctx: typer.Context,
+    limit: int | None = typer.Option(None, "--limit", help="Max users to return (<=100)"),
+    offset: int | None = typer.Option(None, "--offset", help="Pagination offset"),
+    invited_only: bool | None = typer.Option(
+        None,
+        "--invited-only/--active",
+        help="List invited (not activated) users or active users",
+    ),
+) -> None:
+    cfg: Config = ctx.obj
+    kwargs = {"limit": limit, "offset": offset}
+    if invited_only is not None:
+        kwargs["is_invite_only"] = invited_only
+    data = to_data(call_api("general", "api_v1_users_get", cfg, **{k: v for k, v in kwargs.items() if v is not None}))
+    emit(data, pretty=cfg.pretty)

wildberries_cli/commands/orders_fbs.py

@@ -0,0 +1,117 @@
+"""orders-fbs subcommand (selected operational endpoints)."""
+
+from __future__ import annotations
+
+import typer
+
+from wildberries_cli.client import call_api
+from wildberries_cli.config import Config
+from wildberries_cli.output import emit, fbs_orders_table, print_error
+from wildberries_cli.serialize import to_data
+
+app = typer.Typer(name="orders-fbs", help="Orders FBS APIs (selected endpoints).", no_args_is_help=True)
+orders_app = typer.Typer(name="orders", help="FBS orders.", no_args_is_help=True)
+supplies_app = typer.Typer(name="supplies", help="FBS supplies.", no_args_is_help=True)
+app.add_typer(orders_app, name="orders")
+app.add_typer(supplies_app, name="supplies")
+
+
+@orders_app.command("new")
+def orders_new(ctx: typer.Context) -> None:
+    cfg: Config = ctx.obj
+    data = to_data(call_api("orders_fbs", "api_v3_orders_new_get", cfg))
+    emit(data, pretty=cfg.pretty, table_builder=fbs_orders_table)
+
+
+@orders_app.command("list")
+def orders_list(
+    ctx: typer.Context,
+    limit: int = typer.Option(100, "--limit", min=1, max=1000),
+    next: int = typer.Option(0, "--next", help="Pagination cursor"),
+    date_from: int | None = typer.Option(None, "--date-from", help="Unix timestamp start"),
+    date_to: int | None = typer.Option(None, "--date-to", help="Unix timestamp end"),
+) -> None:
+    cfg: Config = ctx.obj
+    kwargs = {"limit": limit, "next": next, "date_from": date_from, "date_to": date_to}
+    data = to_data(call_api("orders_fbs", "api_v3_orders_get", cfg, **{k: v for k, v in kwargs.items() if v is not None}))
+    emit(data, pretty=cfg.pretty, table_builder=fbs_orders_table)
+
+
+@orders_app.command("status")
+def orders_status(
+    ctx: typer.Context,
+    order_ids: list[int] = typer.Option(..., "--order", help="Order ID(s). Repeat option up to API limit."),
+) -> None:
+    cfg: Config = ctx.obj
+    try:
+        from wildberries_sdk.orders_fbs.models.api_v3_orders_status_post_request import ApiV3OrdersStatusPostRequest
+
+        req = ApiV3OrdersStatusPostRequest(orders=order_ids)
+    except Exception as exc:
+        print_error("validation_error", f"Invalid status request: {exc}")
+        raise typer.Exit(1)
+
+    data = to_data(call_api("orders_fbs", "api_v3_orders_status_post", cfg, api_v3_orders_status_post_request=req))
+    emit(data, pretty=cfg.pretty)
+
+
+@orders_app.command("stickers")
+def orders_stickers(
+    ctx: typer.Context,
+    order_ids: list[int] = typer.Option(..., "--order", help="Order ID(s). Repeat option."),
+    type: str = typer.Option(..., "--type", help="Sticker type"),
+    width: int = typer.Option(..., "--width", help="Sticker width"),
+    height: int = typer.Option(..., "--height", help="Sticker height"),
+) -> None:
+    cfg: Config = ctx.obj
+    try:
+        from wildberries_sdk.orders_fbs.models.api_v3_orders_stickers_post_request import (
+            ApiV3OrdersStickersPostRequest,
+        )
+
+        req = ApiV3OrdersStickersPostRequest(orders=order_ids)
+    except Exception as exc:
+        print_error("validation_error", f"Invalid stickers request: {exc}")
+        raise typer.Exit(1)
+
+    data = to_data(
+        call_api(
+            "orders_fbs",
+            "api_v3_orders_stickers_post",
+            cfg,
+            type=type,
+            width=width,
+            height=height,
+            api_v3_orders_stickers_post_request=req,
+        )
+    )
+    emit(data, pretty=cfg.pretty)
+
+
+@supplies_app.command("list")
+def supplies_list(
+    ctx: typer.Context,
+    limit: int = typer.Option(100, "--limit", min=1, max=1000),
+    next: int = typer.Option(0, "--next", help="Pagination cursor"),
+) -> None:
+    cfg: Config = ctx.obj
+    data = to_data(call_api("orders_fbs", "api_v3_supplies_get", cfg, limit=limit, next=next))
+    emit(data, pretty=cfg.pretty)
+
+
+@supplies_app.command("create")
+def supplies_create(
+    ctx: typer.Context,
+    name: str = typer.Option(..., "--name", help="Supply name"),
+) -> None:
+    cfg: Config = ctx.obj
+    try:
+        from wildberries_sdk.orders_fbs.models.api_v3_supplies_post_request import ApiV3SuppliesPostRequest
+
+        req = ApiV3SuppliesPostRequest(name=name)
+    except Exception as exc:
+        print_error("validation_error", f"Invalid supply request: {exc}")
+        raise typer.Exit(1)
+
+    data = to_data(call_api("orders_fbs", "api_v3_supplies_post", cfg, api_v3_supplies_post_request=req))
+    emit(data, pretty=cfg.pretty)