anysite-cli 0.1.2__py3-none-any.whl

anysite/cli/options.py

@@ -0,0 +1,249 @@
+"""Shared CLI option definitions for all platform commands."""
+
+import sys
+from enum import Enum
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from anysite.output.formatters import OutputFormat
+
+# === Phase 1 Options (extracted from individual CLI modules) ===
+
+FormatOption = Annotated[
+    OutputFormat,
+    typer.Option(
+        "--format", "-f",
+        help="Output format",
+        case_sensitive=False,
+    ),
+]
+
+FieldsOption = Annotated[
+    str | None,
+    typer.Option(
+        "--fields",
+        help="Comma-separated list of fields to include",
+    ),
+]
+
+OutputOption = Annotated[
+    Path | None,
+    typer.Option(
+        "--output", "-o",
+        help="Save output to file",
+    ),
+]
+
+QuietOption = Annotated[
+    bool,
+    typer.Option(
+        "--quiet", "-q",
+        help="Suppress non-data output",
+    ),
+]
+
+
+# === Phase 2: Enhanced Field Selection ===
+
+ExcludeOption = Annotated[
+    str | None,
+    typer.Option(
+        "--exclude",
+        help="Comma-separated list of fields to exclude",
+        rich_help_panel="Output Options",
+    ),
+]
+
+CompactOption = Annotated[
+    bool,
+    typer.Option(
+        "--compact",
+        help="Compact output (no indentation)",
+        rich_help_panel="Output Options",
+    ),
+]
+
+FieldsPresetOption = Annotated[
+    str | None,
+    typer.Option(
+        "--fields-preset",
+        help="Named field preset (minimal, contact, recruiting)",
+        rich_help_panel="Output Options",
+    ),
+]
+
+
+# === Phase 2: Streaming ===
+
+StreamOption = Annotated[
+    bool,
+    typer.Option(
+        "--stream/--no-stream",
+        help="Stream output as JSONL (one record per line)",
+        rich_help_panel="Output Options",
+    ),
+]
+
+
+# === Phase 2: Output Enhancements ===
+
+AppendOption = Annotated[
+    bool,
+    typer.Option(
+        "--append",
+        help="Append to existing output file",
+        rich_help_panel="Output Options",
+    ),
+]
+
+OutputDirOption = Annotated[
+    Path | None,
+    typer.Option(
+        "--output-dir",
+        help="Output directory (one file per record in batch mode)",
+        rich_help_panel="Output Options",
+    ),
+]
+
+FilenameTemplateOption = Annotated[
+    str,
+    typer.Option(
+        "--filename-template",
+        help="Filename template for batch output ({id}, {username}, {date}, {index})",
+        rich_help_panel="Output Options",
+    ),
+]
+
+
+# === Phase 2: Batch Input ===
+
+FromFileOption = Annotated[
+    Path | None,
+    typer.Option(
+        "--from-file",
+        help="Read inputs from file (one per line, or JSONL/CSV)",
+        rich_help_panel="Batch Input",
+    ),
+]
+
+StdinOption = Annotated[
+    bool,
+    typer.Option(
+        "--stdin",
+        help="Read inputs from stdin",
+        rich_help_panel="Batch Input",
+    ),
+]
+
+ParallelOption = Annotated[
+    int,
+    typer.Option(
+        "--parallel", "-j",
+        help="Number of parallel requests",
+        rich_help_panel="Batch Input",
+    ),
+]
+
+DelayOption = Annotated[
+    float,
+    typer.Option(
+        "--delay",
+        help="Delay between requests in seconds",
+        rich_help_panel="Batch Input",
+    ),
+]
+
+
+class ErrorHandling(str, Enum):
+    """Error handling modes for batch operations."""
+
+    STOP = "stop"
+    SKIP = "skip"
+    RETRY = "retry"
+
+
+OnErrorOption = Annotated[
+    ErrorHandling,
+    typer.Option(
+        "--on-error",
+        help="Error handling mode: stop, skip, or retry",
+        rich_help_panel="Batch Input",
+    ),
+]
+
+
+# === Phase 2: Rate Limiting ===
+
+RateLimitOption = Annotated[
+    str | None,
+    typer.Option(
+        "--rate-limit",
+        help="Rate limit (e.g., '10/s', '100/m', '1000/h')",
+        rich_help_panel="Advanced",
+    ),
+]
+
+
+# === Phase 2: Progress & Feedback ===
+
+ProgressOption = Annotated[
+    bool | None,
+    typer.Option(
+        "--progress/--no-progress",
+        help="Show progress bar",
+        rich_help_panel="Advanced",
+    ),
+]
+
+StatsOption = Annotated[
+    bool,
+    typer.Option(
+        "--stats",
+        help="Show statistics after completion",
+        rich_help_panel="Advanced",
+    ),
+]
+
+VerboseOption = Annotated[
+    bool,
+    typer.Option(
+        "--verbose",
+        help="Verbose output with debug information",
+        rich_help_panel="Advanced",
+    ),
+]
+
+
+def parse_fields(fields: str | None) -> list[str] | None:
+    """Parse comma-separated fields string.
+
+    Args:
+        fields: Comma-separated field names or None
+
+    Returns:
+        List of field names or None
+    """
+    if not fields:
+        return None
+    return [f.strip() for f in fields.split(",")]
+
+
+def parse_exclude(exclude: str | None) -> list[str] | None:
+    """Parse comma-separated exclude fields string.
+
+    Args:
+        exclude: Comma-separated field names to exclude or None
+
+    Returns:
+        List of field names or None
+    """
+    if not exclude:
+        return None
+    return [f.strip() for f in exclude.split(",")]
+
+
+def is_stdin_piped() -> bool:
+    """Check if stdin has piped data."""
+    return not sys.stdin.isatty()

anysite/config/__init__.py

@@ -0,0 +1,11 @@
+"""Configuration module."""
+
+from anysite.config.paths import get_config_dir, get_config_path
+from anysite.config.settings import Settings, get_settings
+
+__all__ = [
+    "Settings",
+    "get_settings",
+    "get_config_dir",
+    "get_config_path",
+]

anysite/config/paths.py

@@ -0,0 +1,46 @@
+"""Configuration file paths."""
+
+import os
+from pathlib import Path
+
+
+def get_config_dir() -> Path:
+    """Get the configuration directory path.
+
+    Returns:
+        Path to ~/.anysite/ on Unix or %APPDATA%/anysite/ on Windows.
+    """
+    if os.name == "nt":  # Windows
+        base = Path(os.environ.get("APPDATA", str(Path.home())))
+        return base / "anysite"
+    else:  # Unix-like (Linux, macOS)
+        return Path.home() / ".anysite"
+
+
+def get_config_path() -> Path:
+    """Get the configuration file path.
+
+    Returns:
+        Path to config.yaml in the config directory.
+    """
+    return get_config_dir() / "config.yaml"
+
+
+def get_schema_cache_path() -> Path:
+    """Get the schema cache file path.
+
+    Returns:
+        Path to schema.json in the config directory.
+    """
+    return get_config_dir() / "schema.json"
+
+
+def ensure_config_dir() -> Path:
+    """Ensure the configuration directory exists.
+
+    Returns:
+        Path to the config directory.
+    """
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir

anysite/config/settings.py

@@ -0,0 +1,187 @@
+"""Application settings using Pydantic Settings."""
+
+from functools import lru_cache
+from typing import Any
+
+import yaml
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from anysite.config.paths import get_config_path
+
+
+def load_yaml_config() -> dict[str, Any]:
+    """Load configuration from YAML file."""
+    config_path = get_config_path()
+    if config_path.exists():
+        with open(config_path) as f:
+            return yaml.safe_load(f) or {}
+    return {}
+
+
+class Settings(BaseSettings):
+    """Application settings.
+
+    Priority (highest to lowest):
+    1. CLI arguments (handled separately)
+    2. Environment variables (ANYSITE_*)
+    3. Config file (~/.anysite/config.yaml)
+    4. Default values
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="ANYSITE_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    # API settings
+    api_key: str | None = Field(
+        default=None,
+        description="Anysite API key",
+    )
+    base_url: str = Field(
+        default="https://api.anysite.io",
+        description="Anysite API base URL",
+    )
+    timeout: int = Field(
+        default=300,
+        ge=20,
+        le=1500,
+        description="API request timeout in seconds",
+    )
+
+    # CLI defaults
+    default_format: str = Field(
+        default="json",
+        description="Default output format (json, jsonl, csv, table)",
+    )
+    default_count: int = Field(
+        default=10,
+        ge=1,
+        le=1000,
+        description="Default count for search results",
+    )
+
+    # Phase 2: Batch defaults
+    default_parallel: int = Field(
+        default=1,
+        ge=1,
+        le=50,
+        description="Default parallel concurrency for batch operations",
+    )
+    default_rate_limit: str | None = Field(
+        default=None,
+        description="Default rate limit (e.g., '10/s', '60/m')",
+    )
+    auto_stream_threshold: int = Field(
+        default=100,
+        ge=1,
+        le=1000,
+        description="Auto-enable streaming when count exceeds this threshold",
+    )
+
+    # Debug
+    debug: bool = Field(
+        default=False,
+        description="Enable debug mode",
+    )
+
+    def __init__(self, **kwargs: Any) -> None:
+        # Load YAML config first
+        yaml_config = load_yaml_config()
+
+        # Handle nested 'defaults' key from YAML
+        if "defaults" in yaml_config:
+            defaults = yaml_config.pop("defaults")
+            if "format" in defaults:
+                yaml_config.setdefault("default_format", defaults["format"])
+            if "count" in defaults:
+                yaml_config.setdefault("default_count", defaults["count"])
+            if "timeout" in defaults:
+                yaml_config.setdefault("timeout", defaults["timeout"])
+            if "parallel" in defaults:
+                yaml_config.setdefault("default_parallel", defaults["parallel"])
+            if "rate_limit" in defaults:
+                yaml_config.setdefault("default_rate_limit", defaults["rate_limit"])
+            if "auto_stream_threshold" in defaults:
+                yaml_config.setdefault("auto_stream_threshold", defaults["auto_stream_threshold"])
+
+        # Merge: kwargs (CLI) > env > yaml > defaults
+        merged = {**yaml_config, **kwargs}
+        super().__init__(**merged)
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """Get cached settings instance."""
+    return Settings()
+
+
+def save_config(key: str, value: Any) -> None:
+    """Save a configuration value to the YAML config file.
+
+    Args:
+        key: Configuration key (e.g., 'api_key', 'defaults.format')
+        value: Value to save
+    """
+    from anysite.config.paths import ensure_config_dir, get_config_path
+
+    ensure_config_dir()
+    config_path = get_config_path()
+
+    # Load existing config
+    config: dict[str, Any] = {}
+    if config_path.exists():
+        with open(config_path) as f:
+            config = yaml.safe_load(f) or {}
+
+    # Handle nested keys (e.g., 'defaults.format')
+    if "." in key:
+        parts = key.split(".")
+        current = config
+        for part in parts[:-1]:
+            if part not in current:
+                current[part] = {}
+            current = current[part]
+        current[parts[-1]] = value
+    else:
+        config[key] = value
+
+    # Save config
+    with open(config_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
+
+    # Clear settings cache
+    get_settings.cache_clear()
+
+
+def get_config_value(key: str) -> Any:
+    """Get a configuration value from the YAML config file.
+
+    Args:
+        key: Configuration key (e.g., 'api_key', 'defaults.format')
+
+    Returns:
+        The configuration value or None if not found.
+    """
+    config = load_yaml_config()
+
+    # Handle nested keys
+    if "." in key:
+        parts = key.split(".")
+        current: Any = config
+        for part in parts:
+            if isinstance(current, dict) and part in current:
+                current = current[part]
+            else:
+                return None
+        return current
+
+    return config.get(key)
+
+
+def list_config() -> dict[str, Any]:
+    """List all configuration values."""
+    return load_yaml_config()

anysite/dataset/__init__.py

@@ -0,0 +1,37 @@
+"""Dataset subsystem for multi-source data collection and analysis."""
+
+from typing import NoReturn
+
+
+def check_data_deps() -> None:
+    """Check that optional data dependencies are installed.
+
+    Raises:
+        SystemExit: If duckdb or pyarrow are not installed.
+    """
+    missing: list[str] = []
+
+    try:
+        import duckdb  # noqa: F401
+    except ImportError:
+        missing.append("duckdb")
+
+    try:
+        import pyarrow  # noqa: F401
+    except ImportError:
+        missing.append("pyarrow")
+
+    if missing:
+        _missing_deps_error(missing)
+
+
+def _missing_deps_error(missing: list[str]) -> NoReturn:
+    import typer
+
+    names = ", ".join(missing)
+    typer.echo(
+        f"Error: Missing required packages: {names}\n"
+        f"Install with: pip install anysite-cli[data]",
+        err=True,
+    )
+    raise typer.Exit(1)