direct-cli 0.0.0__py3-none-any.whl

direct_cli/commands/retargeting.py

@@ -0,0 +1,104 @@
+"""
+RetargetingLists commands
+"""
+
+import json
+import click
+
+from ..api import create_client
+from ..output import format_output, print_error
+from ..utils import parse_ids, get_default_fields
+
+
+@click.group()
+def retargeting():
+    """Manage retargeting lists"""
+    pass
+
+
+@retargeting.command()
+@click.option("--ids", help="Comma-separated list IDs")
+@click.option("--types", help="Filter by types")
+@click.option("--limit", type=int, help="Limit number of results")
+@click.option("--fetch-all", is_flag=True, help="Fetch all pages")
+@click.option("--format", "output_format", default="json", help="Output format")
+@click.option("--output", help="Output file")
+@click.option("--fields", help="Comma-separated field names")
+@click.pass_context
+def get(ctx, ids, types, limit, fetch_all, output_format, output, fields):
+    """Get retargeting lists"""
+    try:
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        field_names = (
+            fields.split(",") if fields else get_default_fields("retargetinglists")
+        )
+
+        criteria = {}
+        if ids:
+            criteria["Ids"] = parse_ids(ids)
+        if types:
+            criteria["Types"] = types.split(",")
+
+        params = {"SelectionCriteria": criteria, "FieldNames": field_names}
+
+        if limit:
+            params["Page"] = {"Limit": limit}
+
+        body = {"method": "get", "params": params}
+
+        result = client.retargeting().post(data=body)
+
+        if fetch_all:
+            items = []
+            for item in result().iter_items():
+                items.append(item)
+            format_output(items, output_format, output)
+        else:
+            data = result().extract()
+            format_output(data, output_format, output)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()
+
+
+@retargeting.command()
+@click.option("--name", required=True, help="List name")
+@click.option(
+    "--type", "list_type", required=True, help="List type (AUDIENCE_SEGMENT, etc.)"
+)
+@click.option("--json", "extra_json", help="Additional JSON parameters")
+@click.option("--dry-run", is_flag=True, help="Show request without sending")
+@click.pass_context
+def add(ctx, name, list_type, extra_json, dry_run):
+    """Add new retargeting list"""
+    try:
+        list_data = {"Name": name, "Type": list_type}
+
+        if extra_json:
+            extra = json.loads(extra_json)
+            list_data.update(extra)
+
+        body = {"method": "add", "params": {"RetargetingLists": [list_data]}}
+
+        if dry_run:
+            format_output(body, "json", None)
+            return
+
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        result = client.retargeting().post(data=body)
+        format_output(result().extract(), "json", None)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()

direct_cli/commands/sitelinks.py

@@ -0,0 +1,92 @@
+"""
+Sitelinks commands
+"""
+
+import json
+import click
+
+from ..api import create_client
+from ..output import format_output, print_error
+from ..utils import parse_ids
+
+
+@click.group()
+def sitelinks():
+    """Manage sitelinks"""
+    pass
+
+
+@sitelinks.command()
+@click.option("--ids", help="Comma-separated sitelink IDs")
+@click.option("--limit", type=int, help="Limit number of results")
+@click.option("--fetch-all", is_flag=True, help="Fetch all pages")
+@click.option("--format", "output_format", default="json", help="Output format")
+@click.option("--output", help="Output file")
+@click.option("--fields", help="Comma-separated field names")
+@click.pass_context
+def get(ctx, ids, limit, fetch_all, output_format, output, fields):
+    """Get sitelinks"""
+    try:
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        field_names = fields.split(",") if fields else ["Id", "Sitelinks"]
+
+        criteria = {}
+        if ids:
+            criteria["Ids"] = parse_ids(ids)
+
+        params = {"SelectionCriteria": criteria, "FieldNames": field_names}
+
+        if limit:
+            params["Page"] = {"Limit": limit}
+
+        body = {"method": "get", "params": params}
+
+        result = client.sitelinks().post(data=body)
+
+        if fetch_all:
+            items = []
+            for item in result().iter_items():
+                items.append(item)
+            format_output(items, output_format, output)
+        else:
+            data = result().extract()
+            format_output(data, output_format, output)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()
+
+
+@sitelinks.command()
+@click.option("--links", required=True, help="JSON array of sitelinks")
+@click.option("--dry-run", is_flag=True, help="Show request without sending")
+@click.pass_context
+def add(ctx, links, dry_run):
+    """Add sitelinks set"""
+    try:
+        body = {
+            "method": "add",
+            "params": {"SitelinksSets": [{"Sitelinks": json.loads(links)}]},
+        }
+
+        if dry_run:
+            format_output(body, "json", None)
+            return
+
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        result = client.sitelinks().post(data=body)
+        format_output(result().extract(), "json", None)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()

direct_cli/commands/smartadtargets.py

@@ -0,0 +1,104 @@
+"""
+SmartAdTargets commands
+"""
+
+import json
+import click
+
+from ..api import create_client
+from ..output import format_output, print_error
+from ..utils import parse_ids
+
+
+@click.group()
+def smartadtargets():
+    """Manage smart ad targets"""
+    pass
+
+
+@smartadtargets.command()
+@click.option("--ids", help="Comma-separated target IDs")
+@click.option("--adgroup-ids", help="Comma-separated ad group IDs")
+@click.option("--limit", type=int, help="Limit number of results")
+@click.option("--fetch-all", is_flag=True, help="Fetch all pages")
+@click.option("--format", "output_format", default="json", help="Output format")
+@click.option("--output", help="Output file")
+@click.option("--fields", help="Comma-separated field names")
+@click.pass_context
+def get(ctx, ids, adgroup_ids, limit, fetch_all, output_format, output, fields):
+    """Get smart ad targets"""
+    try:
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        field_names = (
+            fields.split(",")
+            if fields
+            else ["Id", "CampaignId", "AdGroupId", "Status", "ServingStatus"]
+        )
+
+        criteria = {}
+        if ids:
+            criteria["Ids"] = parse_ids(ids)
+        if adgroup_ids:
+            criteria["AdGroupIds"] = parse_ids(adgroup_ids)
+
+        params = {"SelectionCriteria": criteria, "FieldNames": field_names}
+
+        if limit:
+            params["Page"] = {"Limit": limit}
+
+        body = {"method": "get", "params": params}
+
+        result = client.smartadtargets().post(data=body)
+
+        if fetch_all:
+            items = []
+            for item in result().iter_items():
+                items.append(item)
+            format_output(items, output_format, output)
+        else:
+            data = result().extract()
+            format_output(data, output_format, output)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()
+
+
+@smartadtargets.command()
+@click.option("--adgroup-id", required=True, type=int, help="Ad group ID")
+@click.option("--type", "target_type", required=True, help="Target type")
+@click.option("--json", "extra_json", help="Additional JSON parameters")
+@click.option("--dry-run", is_flag=True, help="Show request without sending")
+@click.pass_context
+def add(ctx, adgroup_id, target_type, extra_json, dry_run):
+    """Add smart ad target"""
+    try:
+        target_data = {"AdGroupId": adgroup_id, "Type": target_type}
+
+        if extra_json:
+            extra = json.loads(extra_json)
+            target_data.update(extra)
+
+        body = {"method": "add", "params": {"SmartAdTargets": [target_data]}}
+
+        if dry_run:
+            format_output(body, "json", None)
+            return
+
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        result = client.smartadtargets().post(data=body)
+        format_output(result().extract(), "json", None)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()

direct_cli/commands/turbopages.py

@@ -0,0 +1,97 @@
+"""
+TurboPages commands
+"""
+
+import json
+import click
+
+from ..api import create_client
+from ..output import format_output, print_error
+from ..utils import parse_ids
+
+
+@click.group()
+def turbopages():
+    """Manage Turbo Pages"""
+    pass
+
+
+@turbopages.command()
+@click.option("--ids", help="Comma-separated Turbo Page IDs")
+@click.option("--limit", type=int, help="Limit number of results")
+@click.option("--fetch-all", is_flag=True, help="Fetch all pages")
+@click.option("--format", "output_format", default="json", help="Output format")
+@click.option("--output", help="Output file")
+@click.option("--fields", help="Comma-separated field names")
+@click.pass_context
+def get(ctx, ids, limit, fetch_all, output_format, output, fields):
+    """Get Turbo Pages"""
+    try:
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        field_names = fields.split(",") if fields else ["Id", "Name", "Status", "Href"]
+
+        criteria = {}
+        if ids:
+            criteria["Ids"] = parse_ids(ids)
+
+        params = {"SelectionCriteria": criteria, "FieldNames": field_names}
+
+        if limit:
+            params["Page"] = {"Limit": limit}
+
+        body = {"method": "get", "params": params}
+
+        result = client.turbopages().post(data=body)
+
+        if fetch_all:
+            items = []
+            for item in result().iter_items():
+                items.append(item)
+            format_output(items, output_format, output)
+        else:
+            data = result().extract()
+            format_output(data, output_format, output)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()
+
+
+@turbopages.command()
+@click.option("--name", required=True, help="Page name")
+@click.option("--url", required=True, help="Page URL")
+@click.option("--json", "extra_json", help="Additional JSON parameters")
+@click.option("--dry-run", is_flag=True, help="Show request without sending")
+@click.pass_context
+def add(ctx, name, url, extra_json, dry_run):
+    """Add Turbo Page"""
+    try:
+        page_data = {"Name": name, "Href": url}
+
+        if extra_json:
+            extra = json.loads(extra_json)
+            page_data.update(extra)
+
+        body = {"method": "add", "params": {"TurboPages": [page_data]}}
+
+        if dry_run:
+            format_output(body, "json", None)
+            return
+
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        result = client.turbopages().post(data=body)
+        format_output(result().extract(), "json", None)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()

direct_cli/commands/vcards.py

@@ -0,0 +1,93 @@
+"""
+VCards commands
+"""
+
+import json
+import click
+
+from ..api import create_client
+from ..output import format_output, print_error
+from ..utils import parse_ids
+
+
+@click.group()
+def vcards():
+    """Manage vCards"""
+    pass
+
+
+@vcards.command()
+@click.option("--ids", help="Comma-separated vCard IDs")
+@click.option("--limit", type=int, help="Limit number of results")
+@click.option("--fetch-all", is_flag=True, help="Fetch all pages")
+@click.option("--format", "output_format", default="json", help="Output format")
+@click.option("--output", help="Output file")
+@click.option("--fields", help="Comma-separated field names")
+@click.pass_context
+def get(ctx, ids, limit, fetch_all, output_format, output, fields):
+    """Get vCards"""
+    try:
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        field_names = (
+            fields.split(",")
+            if fields
+            else ["Id", "CampaignId", "Country", "City", "CompanyName"]
+        )
+
+        criteria = {}
+        if ids:
+            criteria["Ids"] = parse_ids(ids)
+
+        params = {"SelectionCriteria": criteria, "FieldNames": field_names}
+
+        if limit:
+            params["Page"] = {"Limit": limit}
+
+        body = {"method": "get", "params": params}
+
+        result = client.vcards().post(data=body)
+
+        if fetch_all:
+            items = []
+            for item in result().iter_items():
+                items.append(item)
+            format_output(items, output_format, output)
+        else:
+            data = result().extract()
+            format_output(data, output_format, output)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()
+
+
+@vcards.command()
+@click.option("--json", "vcard_json", required=True, help="vCard data in JSON")
+@click.option("--dry-run", is_flag=True, help="Show request without sending")
+@click.pass_context
+def add(ctx, vcard_json, dry_run):
+    """Add vCard"""
+    try:
+        body = {"method": "add", "params": {"VCards": [json.loads(vcard_json)]}}
+
+        if dry_run:
+            format_output(body, "json", None)
+            return
+
+        client = create_client(
+            token=ctx.obj.get("token"),
+            login=ctx.obj.get("login"),
+            sandbox=ctx.obj.get("sandbox"),
+        )
+
+        result = client.vcards().post(data=body)
+        format_output(result().extract(), "json", None)
+
+    except Exception as e:
+        print_error(str(e))
+        raise click.Abort()

direct_cli/output.py

@@ -0,0 +1,143 @@
+"""
+Output formatting module for Direct CLI
+"""
+
+import json
+import csv
+import sys
+from typing import Any, List, Dict, Optional
+from io import StringIO
+
+try:
+    from tabulate import tabulate
+except ImportError:
+    tabulate = None
+
+
+def format_output(
+    data: Any,
+    format_type: str = "json",
+    output_file: Optional[str] = None,
+    headers: Optional[List[str]] = None,
+) -> str:
+    """
+    Format data for output
+
+    Args:
+        data: Data to format
+        format_type: Output format ('json', 'table', 'csv', 'tsv')
+        output_file: Output file path (if None, print to stdout)
+        headers: Column headers for table/csv/tsv format
+
+    Returns:
+        Formatted string
+    """
+    if format_type == "json":
+        output = format_json(data)
+    elif format_type == "table":
+        output = format_table(data, headers)
+    elif format_type == "csv":
+        output = format_csv(data, headers)
+    elif format_type == "tsv":
+        output = format_tsv(data, headers)
+    else:
+        output = str(data)
+
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(output)
+    else:
+        print(output)
+
+    return output
+
+
+def format_json(data: Any, indent: int = 2) -> str:
+    """Format data as JSON"""
+    return json.dumps(data, ensure_ascii=False, indent=indent, default=str)
+
+
+def format_table(data: Any, headers: Optional[List[str]] = None) -> str:
+    """Format data as table"""
+    if not tabulate:
+        return format_json(data)
+
+    if isinstance(data, list) and len(data) > 0:
+        if isinstance(data[0], dict):
+            return tabulate(data, headers="keys", tablefmt="grid")
+        elif isinstance(data[0], list):
+            return tabulate(data, headers=headers or [], tablefmt="grid")
+    elif isinstance(data, dict):
+        # Convert dict to list of lists for table display
+        rows = [[k, v] for k, v in data.items()]
+        return tabulate(rows, headers=["Key", "Value"], tablefmt="grid")
+
+    return str(data)
+
+
+def format_csv(data: Any, headers: Optional[List[str]] = None) -> str:
+    """Format data as CSV"""
+    output = StringIO()
+
+    if isinstance(data, list) and len(data) > 0:
+        if isinstance(data[0], dict):
+            fieldnames = headers or list(data[0].keys())
+            writer = csv.DictWriter(output, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(data)
+        elif isinstance(data[0], list):
+            writer = csv.writer(output)
+            if headers:
+                writer.writerow(headers)
+            writer.writerows(data)
+    elif isinstance(data, dict):
+        writer = csv.writer(output)
+        writer.writerow(["Key", "Value"])
+        for k, v in data.items():
+            writer.writerow([k, v])
+
+    return output.getvalue()
+
+
+def format_tsv(data: Any, headers: Optional[List[str]] = None) -> str:
+    """Format data as TSV"""
+    output = StringIO()
+
+    if isinstance(data, list) and len(data) > 0:
+        if isinstance(data[0], dict):
+            fieldnames = headers or list(data[0].keys())
+            writer = csv.DictWriter(output, fieldnames=fieldnames, delimiter="\t")
+            writer.writeheader()
+            writer.writerows(data)
+        elif isinstance(data[0], list):
+            writer = csv.writer(output, delimiter="\t")
+            if headers:
+                writer.writerow(headers)
+            writer.writerows(data)
+    elif isinstance(data, dict):
+        writer = csv.writer(output, delimiter="\t")
+        writer.writerow(["Key", "Value"])
+        for k, v in data.items():
+            writer.writerow([k, v])
+
+    return output.getvalue()
+
+
+def print_success(message: str) -> None:
+    """Print success message"""
+    print(f"\033[32m✓ {message}\033[0m")
+
+
+def print_error(message: str) -> None:
+    """Print error message"""
+    print(f"\033[31m✗ {message}\033[0m", file=sys.stderr)
+
+
+def print_warning(message: str) -> None:
+    """Print warning message"""
+    print(f"\033[33m⚠ {message}\033[0m")
+
+
+def print_info(message: str) -> None:
+    """Print info message"""
+    print(f"ℹ {message}")