google-analytics-cli 0.1.0rc1__py3-none-any.whl

ga_cli/commands/channel_groups.py

@@ -0,0 +1,223 @@
+"""Channel group management commands."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import questionary
+import typer
+
+from ..api.client import get_admin_alpha_client
+from ..config.store import get_effective_value
+from ..utils import handle_error, info, output, require_options, resolve_output_format, success
+from ..utils.pagination import paginate_all
+
+channel_groups_app = typer.Typer(
+    name="channel-groups",
+    help="Manage channel groups",
+    no_args_is_help=True,
+)
+
+
+def _load_json_config(config_file: str) -> dict:
+    """Load and parse a JSON config file."""
+    config_path = Path(config_file)
+    if not config_path.exists():
+        raise typer.BadParameter(f"Config file not found: {config_file}")
+    try:
+        return json.loads(config_path.read_text())
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"Invalid JSON in config file: {exc}")
+
+
+@channel_groups_app.command("list")
+def list_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """List channel groups for a property."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        admin = get_admin_alpha_client()
+        groups = paginate_all(
+            lambda **kw: admin.properties()
+            .channelGroups()
+            .list(parent=f"properties/{effective_property}", **kw)
+            .execute(),
+            "channelGroups",
+            pageSize=200,
+        )
+
+        output(
+            groups,
+            effective_format,
+            columns=[
+                "name",
+                "displayName",
+                "description",
+                "systemDefined",
+            ],
+            headers=[
+                "Resource Name",
+                "Display Name",
+                "Description",
+                "System Defined",
+            ],
+        )
+    except Exception as e:
+        handle_error(e)
+
+
+@channel_groups_app.command("get")
+def get_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    channel_group_id: str = typer.Option(
+        ..., "--channel-group-id", "-g", help="Channel group ID"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Get details for a channel group."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        admin = get_admin_alpha_client()
+        group = (
+            admin.properties()
+            .channelGroups()
+            .get(
+                name=f"properties/{effective_property}/channelGroups/{channel_group_id}"
+            )
+            .execute()
+        )
+        output(group, effective_format)
+    except Exception as e:
+        handle_error(e)
+
+
+@channel_groups_app.command("create")
+def create_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    config_file: str = typer.Option(
+        ..., "--config", "-c", help="Path to JSON channel group config file"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Create a channel group from a JSON config file."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        body = _load_json_config(config_file)
+
+        admin = get_admin_alpha_client()
+        group = (
+            admin.properties()
+            .channelGroups()
+            .create(parent=f"properties/{effective_property}", body=body)
+            .execute()
+        )
+        output(group, effective_format)
+    except typer.BadParameter:
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@channel_groups_app.command("update")
+def update_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    channel_group_id: str = typer.Option(
+        ..., "--channel-group-id", "-g", help="Channel group ID"
+    ),
+    config_file: str = typer.Option(
+        ..., "--config", "-c", help="Path to JSON file with fields to update"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Update a channel group from a JSON config file."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        body = _load_json_config(config_file)
+
+        if not body:
+            raise typer.BadParameter("Config file must contain at least one field to update.")
+
+        update_mask = ",".join(body.keys())
+
+        admin = get_admin_alpha_client()
+        resource_name = f"properties/{effective_property}/channelGroups/{channel_group_id}"
+        group = (
+            admin.properties()
+            .channelGroups()
+            .patch(
+                name=resource_name,
+                body=body,
+                updateMask=update_mask,
+            )
+            .execute()
+        )
+        output(group, effective_format)
+    except typer.BadParameter:
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@channel_groups_app.command("delete")
+def delete_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    channel_group_id: str = typer.Option(
+        ..., "--channel-group-id", "-g", help="Channel group ID"
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """Delete a channel group."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+
+        if not yes:
+            confirmed = questionary.confirm(
+                f"Delete channel group {channel_group_id}? This cannot be undone."
+            ).ask()
+            if not confirmed:
+                info("Cancelled.")
+                raise typer.Exit()
+
+        admin = get_admin_alpha_client()
+        resource_name = f"properties/{effective_property}/channelGroups/{channel_group_id}"
+        admin.properties().channelGroups().delete(
+            name=resource_name
+        ).execute()
+        success(f"Channel group {channel_group_id} deleted.")
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(e)

ga_cli/commands/completions_cmd.py

@@ -0,0 +1,55 @@
+"""Shell completion script generation."""
+
+from __future__ import annotations
+
+import typer
+from click.shell_completion import (
+    BashComplete,
+    FishComplete,
+    ZshComplete,
+)
+
+completions_app = typer.Typer(
+    name="completions", help="Generate shell completion scripts", no_args_is_help=True
+)
+
+# The prog_name used by the installed entry point
+_PROG_NAME = "ga"
+
+
+def _get_source_vars() -> dict[str, str]:
+    """Build the template vars that Click's completion classes need."""
+    func_name = f"_{_PROG_NAME}_completion"
+    complete_var = f"_{_PROG_NAME.upper()}_COMPLETE"
+    return {
+        "complete_func": func_name,
+        "complete_var": complete_var,
+        "prog_name": _PROG_NAME,
+    }
+
+
+@completions_app.command("bash")
+def bash_cmd():
+    """Generate bash completion script.
+
+    Usage: ga completions bash > ~/.bash_completion.d/ga
+    """
+    print(BashComplete.source_template % _get_source_vars())
+
+
+@completions_app.command("zsh")
+def zsh_cmd():
+    """Generate zsh completion script.
+
+    Usage: ga completions zsh > ~/.zsh/completions/_ga
+    """
+    print(ZshComplete.source_template % _get_source_vars())
+
+
+@completions_app.command("fish")
+def fish_cmd():
+    """Generate fish completion script.
+
+    Usage: ga completions fish > ~/.config/fish/completions/ga.fish
+    """
+    print(FishComplete.source_template % _get_source_vars())

ga_cli/commands/config_cmd.py

@@ -0,0 +1,113 @@
+"""Configuration management commands.
+
+Equivalent to GTM CLI's commands/config.ts.
+"""
+
+from typing import Optional
+
+import typer
+
+from ..config.store import (
+    VALID_CONFIG_KEYS,
+    UserConfig,
+    clear_config,
+    get_config_path,
+    get_config_value,
+    load_config,
+    save_config,
+    set_config_value,
+    unset_config_value,
+)
+from ..utils import error, info, output, success
+
+config_app = typer.Typer(name="config", help="Manage CLI configuration", no_args_is_help=True)
+
+
+@config_app.command("setup")
+def setup():
+    """Interactive configuration wizard."""
+    import questionary
+
+    info("GA CLI Configuration Setup")
+    print()
+
+    account_id = questionary.text(
+        "Default Account ID (leave empty to skip):"
+    ).ask()
+
+    property_id = questionary.text(
+        "Default Property ID (leave empty to skip):"
+    ).ask()
+
+    output_format = questionary.select(
+        "Default output format:",
+        choices=["table", "json", "compact"],
+        default="table",
+    ).ask()
+
+    config = UserConfig(
+        default_account_id=account_id or None,
+        default_property_id=property_id or None,
+        output_format=output_format or "table",
+    )
+    save_config(config)
+    success("Configuration saved.")
+
+
+@config_app.command("get")
+def get_cmd(key: Optional[str] = typer.Argument(None, help="Config key to retrieve")):
+    """Get configuration values."""
+    if key:
+        if key not in VALID_CONFIG_KEYS:
+            error(f"Unknown config key: {key}. Valid keys: {', '.join(VALID_CONFIG_KEYS)}")
+            raise typer.Exit(1)
+        value = get_config_value(key)
+        if value is not None:
+            print(value)
+        else:
+            error(f"Config key '{key}' is not set.")
+            raise typer.Exit(1)
+    else:
+        from dataclasses import asdict
+        config = load_config()
+        output(asdict(config), "json")
+
+
+@config_app.command("set")
+def set_cmd(
+    key: str = typer.Argument(help="Config key"),
+    value: str = typer.Argument(help="Config value"),
+):
+    """Set a configuration value."""
+    if key not in VALID_CONFIG_KEYS:
+        error(f"Unknown config key: {key}. Valid keys: {', '.join(VALID_CONFIG_KEYS)}")
+        raise typer.Exit(1)
+    set_config_value(key, value)
+    success(f"Set {key} = {value}")
+
+
+@config_app.command("unset")
+def unset(key: str = typer.Argument(help="Config key to remove")):
+    """Remove a configuration value."""
+    if key not in VALID_CONFIG_KEYS:
+        error(f"Unknown config key: {key}. Valid keys: {', '.join(VALID_CONFIG_KEYS)}")
+        raise typer.Exit(1)
+    unset_config_value(key)
+    success(f"Unset {key}")
+
+
+@config_app.command("path")
+def path():
+    """Show configuration file path."""
+    print(get_config_path())
+
+
+@config_app.command("reset")
+def reset():
+    """Reset all configuration to defaults."""
+    import questionary
+    if questionary.confirm("Reset all configuration to defaults?", default=False).ask():
+        clear_config()
+        success("Configuration reset.")
+    else:
+        info("Reset cancelled.")

ga_cli/commands/custom_dimensions.py

@@ -0,0 +1,272 @@
+"""Custom dimension management commands."""
+
+from typing import Optional
+
+import questionary
+import typer
+
+from ..api.client import get_admin_client
+from ..config.store import get_effective_value
+from ..utils import (
+    handle_dry_run,
+    handle_error,
+    info,
+    output,
+    require_options,
+    resolve_output_format,
+    success,
+)
+from ..utils.pagination import paginate_all
+
+custom_dimensions_app = typer.Typer(
+    name="custom-dimensions",
+    help="Manage custom dimensions",
+    no_args_is_help=True,
+)
+
+_VALID_SCOPES = ("EVENT", "USER", "ITEM")
+
+
+@custom_dimensions_app.command("list")
+def list_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """List custom dimensions for a property."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        admin = get_admin_client()
+        dimensions = paginate_all(
+            lambda **kw: admin.properties()
+            .customDimensions()
+            .list(parent=f"properties/{effective_property}", **kw)
+            .execute(),
+            "customDimensions",
+            pageSize=200,
+        )
+
+        output(
+            dimensions,
+            effective_format,
+            columns=[
+                "name",
+                "parameterName",
+                "displayName",
+                "scope",
+                "description",
+                "disallowAdsPersonalization",
+            ],
+            headers=[
+                "Resource Name",
+                "Parameter Name",
+                "Display Name",
+                "Scope",
+                "Description",
+                "Disallow Ads",
+            ],
+        )
+    except Exception as e:
+        handle_error(e)
+
+
+@custom_dimensions_app.command("get")
+def get_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    dimension_id: str = typer.Option(
+        ..., "--dimension-id", "-d", help="Custom dimension ID"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Get details for a custom dimension."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        admin = get_admin_client()
+        dimension = (
+            admin.properties()
+            .customDimensions()
+            .get(
+                name=f"properties/{effective_property}/customDimensions/{dimension_id}"
+            )
+            .execute()
+        )
+        output(dimension, effective_format)
+    except Exception as e:
+        handle_error(e)
+
+
+@custom_dimensions_app.command("create")
+def create_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    parameter_name: str = typer.Option(
+        ..., "--parameter-name", help="Event parameter name"
+    ),
+    display_name: str = typer.Option(..., "--display-name", help="Display name in GA4 UI"),
+    scope: str = typer.Option(..., "--scope", help="Scope: EVENT, USER, or ITEM"),
+    description: str = typer.Option("", "--description", help="Description"),
+    disallow_ads: bool = typer.Option(
+        False, "--disallow-ads", help="Disallow ads personalization"
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Preview the request without executing"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Create a custom dimension."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        scope_upper = scope.upper()
+        if scope_upper not in _VALID_SCOPES:
+            raise typer.BadParameter(
+                f"Invalid scope '{scope}'. Must be one of: {', '.join(_VALID_SCOPES)}"
+            )
+
+        body = {
+            "parameterName": parameter_name,
+            "displayName": display_name,
+            "scope": scope_upper,
+            "description": description,
+            "disallowAdsPersonalization": disallow_ads,
+        }
+        if dry_run:
+            handle_dry_run("create", "POST", f"properties/{effective_property}", body)
+
+        admin = get_admin_client()
+        dimension = (
+            admin.properties()
+            .customDimensions()
+            .create(parent=f"properties/{effective_property}", body=body)
+            .execute()
+        )
+        output(dimension, effective_format)
+    except (typer.BadParameter, typer.Exit):
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@custom_dimensions_app.command("update")
+def update_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    dimension_id: str = typer.Option(
+        ..., "--dimension-id", "-d", help="Custom dimension ID"
+    ),
+    display_name: Optional[str] = typer.Option(None, "--display-name", help="New display name"),
+    description: Optional[str] = typer.Option(None, "--description", help="New description"),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Preview the request without executing"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Update a custom dimension."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        body = {}
+        mask_fields = []
+        if display_name is not None:
+            body["displayName"] = display_name
+            mask_fields.append("displayName")
+        if description is not None:
+            body["description"] = description
+            mask_fields.append("description")
+
+        if not mask_fields:
+            raise typer.BadParameter(
+                "At least one field must be specified: --display-name, --description"
+            )
+
+        resource_name = f"properties/{effective_property}/customDimensions/{dimension_id}"
+        if dry_run:
+            handle_dry_run(
+                "update", "PATCH", resource_name,
+                body, update_mask=",".join(mask_fields),
+            )
+
+        admin = get_admin_client()
+        dimension = (
+            admin.properties()
+            .customDimensions()
+            .patch(
+                name=resource_name,
+                body=body,
+                updateMask=",".join(mask_fields),
+            )
+            .execute()
+        )
+        output(dimension, effective_format)
+    except (typer.BadParameter, typer.Exit):
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@custom_dimensions_app.command("archive")
+def archive_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    dimension_id: str = typer.Option(
+        ..., "--dimension-id", "-d", help="Custom dimension ID"
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Preview the request without executing"
+    ),
+):
+    """Archive a custom dimension."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+
+        if dry_run:
+            handle_dry_run(
+                "archive", "POST",
+                f"properties/{effective_property}/customDimensions/{dimension_id}",
+                None,
+            )
+
+        if not yes:
+            confirmed = questionary.confirm(
+                f"Archive custom dimension {dimension_id}? This cannot be undone."
+            ).ask()
+            if not confirmed:
+                info("Cancelled.")
+                raise typer.Exit()
+
+        admin = get_admin_client()
+        resource_name = f"properties/{effective_property}/customDimensions/{dimension_id}"
+        admin.properties().customDimensions().archive(
+            name=resource_name, body={}
+        ).execute()
+        success(f"Custom dimension {dimension_id} archived.")
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(e)