pygeofetch 0.1.1__py3-none-any.whl

pygeofetch/__init__.py

@@ -0,0 +1,39 @@
+"""
+pygeofetch v1.0.0 — Universal Satellite Data Pipeline.
+
+Unified access to 22+ satellite data providers with a consistent
+Python API and CLI. Supports authentication management, federated search,
+parallel downloads, pipeline orchestration, and post-processing.
+
+Quick Start::
+
+    from pygeofetch import pygeofetch
+
+    sb = pygeofetch()
+    sb.add_credentials("usgs", username="user", password="pass")
+
+    results = sb.search(
+        providers=["usgs", "copernicus", "planetary_computer"],
+        bbox=(-74.1, 40.6, -73.7, 40.9),
+        start_date="2024-01-01",
+        cloud_cover_max=20,
+    )
+
+    sb.download(results[:5], output="./data/", parallel=4)
+
+CLI::
+
+    pygeofetch auth add usgs --username user --password pass
+    pygeofetch search run --bbox "-74,40,-73,41" --providers copernicus
+    pygeofetch download run --from-search results.geojson --output ./data/
+    pygeofetch status
+    pygeofetch doctor
+"""
+
+__version__ = "1.0.0"
+__author__ = "pygeofetch Contributors"
+__license__ = "MIT"
+
+from pygeofetch.core.engine import pygeofetch  # noqa: F401
+
+__all__ = ["pygeofetch", "__version__"]

pygeofetch/cli/__init__.py

@@ -0,0 +1 @@
+"""pygeofetch CLI package."""

pygeofetch/cli/auth_commands.py

@@ -0,0 +1,257 @@
+"""
+Authentication CLI commands for pygeofetch.
+
+Provides the ``pygeofetch auth`` command group for managing provider
+credentials: adding, listing, removing, testing, and exporting them.
+
+Usage::
+
+    pygeofetch auth add usgs --username user --password pass
+    pygeofetch auth add planet --api-key PL_KEY
+    pygeofetch auth login copernicus        # interactive prompt
+    pygeofetch auth list
+    pygeofetch auth test usgs
+    pygeofetch auth remove planet
+    pygeofetch auth export --output creds_backup.json
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+@click.group()
+def auth() -> None:
+    """Manage provider authentication credentials."""
+
+
+@auth.command(name="add")
+@click.argument("provider")
+@click.option("--username", "-u", default=None, help="Username or email.")
+@click.option("--password", "-p", default=None, help="Password (prompted if omitted).")
+@click.option("--api-key", "-k", default=None, help="API key (alternative to username/password).")
+@click.option("--client-id", default=None, help="OAuth2 client ID.")
+@click.option("--client-secret", default=None, help="OAuth2 client secret.")
+@click.option("--token", default=None, help="Bearer token.")
+@click.option(
+    "--store",
+    default="keyring",
+    type=click.Choice(["keyring", "file"]),
+    show_default=True,
+    help="Credential storage backend.",
+)
+
+def auth_add(
+    provider: str,
+    username: str | None,
+    password: str | None,
+    api_key: str | None,
+    client_id: str | None,
+    client_secret: str | None,
+    token: str | None,
+    store: str,
+) -> None:
+    """
+    Add credentials for PROVIDER.
+
+    \b
+    Examples:
+      pygeofetch auth add usgs --username samuelyamforo --password USGS@sak@2001server
+      pygeofetch auth add planet --api-key PL_KEY
+      pygeofetch auth add copernicus --username me@example.com
+    """
+    from pygeofetch.core.authenticator import AuthManager
+
+    creds: dict = {}
+
+    if api_key:
+        creds["api_key"] = api_key
+    if client_id:
+        creds["client_id"] = client_id
+    if client_secret:
+        creds["client_secret"] = client_secret
+    if token:
+        creds["token"] = token
+
+    if not creds and not username:
+        username = click.prompt(f"Username for {provider}")
+
+    if username:
+        creds["username"] = username
+        if not password and not api_key:
+            password = click.prompt(f"Password for {provider}", hide_input=True)
+        if password:
+            creds["password"] = password
+
+    if not creds:
+        console.print("[red]No credentials provided.[/]")
+        sys.exit(1)
+
+    mgr = AuthManager(storage_backend='file')
+    mgr.add_credentials(provider, **creds)
+    console.print(f"[green]Credentials for [bold]{provider}[/] saved.[/]")
+
+
+@auth.command(name="login")
+@click.argument("provider")
+def auth_login(provider: str) -> None:
+    """
+    Interactive login for PROVIDER (prompts for all required fields).
+
+    \b
+    Example:
+      pygeofetch auth login copernicus
+    """
+    from pygeofetch.core.authenticator import AuthManager
+    from pygeofetch.providers import get_provider
+
+    prov = get_provider(provider)
+    caps = prov.get_capabilities()
+
+    console.print(f"\n[bold]Logging in to {caps.name}[/]\n")
+
+    creds: dict = {}
+
+    # Determine what to prompt based on auth type
+    auth_type = caps.auth_type if hasattr(caps, "auth_type") else "username_password"
+
+    if auth_type in ("api_key",):
+        creds["api_key"] = click.prompt("API Key", hide_input=True)
+    elif auth_type in ("oauth2_client",):
+        creds["client_id"] = click.prompt("Client ID")
+        creds["client_secret"] = click.prompt("Client Secret", hide_input=True)
+    else:
+        creds["username"] = click.prompt("Username")
+        creds["password"] = click.prompt("Password", hide_input=True)
+
+    mgr = AuthManager(storage_backend='file')
+    mgr.add_credentials(provider, creds)
+
+    console.print(f"\n[green]Credentials for [bold]{provider}[/] saved.[/]")
+
+    # Optionally verify
+    if click.confirm("Verify credentials now?", default=True):
+        try:
+            session = mgr.authenticate(provider)
+            console.print(f"[green]Authentication successful![/] Session expires: {session.expires_at}")
+        except Exception as exc:
+            console.print(f"[red]Authentication failed: {exc}[/]")
+
+
+@auth.command(name="list")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def auth_list(as_json: bool) -> None:
+    """List all stored provider credentials."""
+    from pygeofetch.core.authenticator import AuthManager
+
+    mgr = AuthManager(storage_backend='file')
+    entries = mgr.list()
+
+    if as_json:
+        click.echo(json.dumps(entries, indent=2, default=str))
+        return
+
+    if not entries:
+        console.print("[dim]No credentials stored.[/]")
+        return
+
+    table = Table(title="Stored Credentials", header_style="bold blue")
+    table.add_column("Provider", style="cyan")
+    table.add_column("Has Username", justify="center")
+    table.add_column("Has API Key", justify="center")
+    table.add_column("Has Token", justify="center")
+
+    for entry in entries:
+        table.add_row(
+            entry["provider"],
+            "[green]✓[/]" if entry.get("has_username") else "—",
+            "[green]✓[/]" if entry.get("has_api_key") else "—",
+            "[green]✓[/]" if entry.get("has_token") else "—",
+        )
+
+    console.print(table)
+
+
+@auth.command(name="test")
+@click.argument("provider")
+def auth_test(provider: str) -> None:
+    """
+    Test stored credentials for PROVIDER by attempting authentication.
+
+    \b
+    Example:
+      pygeofetch auth test usgs
+    """
+    from pygeofetch.core.authenticator import AuthManager
+
+    console.print(f"Testing credentials for [bold]{provider}[/]...")
+    mgr = AuthManager(storage_backend='file')
+    try:
+        session = mgr.authenticate(provider)
+        console.print(f"[green]Success![/] Session valid until: {session.expires_at}")
+    except Exception as exc:
+        console.print(f"[red]Failed: {exc}[/]")
+        sys.exit(1)
+
+
+@auth.command(name="remove")
+@click.argument("provider")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt.")
+def auth_remove(provider: str, yes: bool) -> None:
+    """
+    Remove stored credentials for PROVIDER.
+
+    \b
+    Example:
+      pygeofetch auth remove planet
+    """
+    from pygeofetch.core.authenticator import AuthManager
+
+    if not yes:
+        click.confirm(f"Remove credentials for {provider!r}?", abort=True)
+
+    mgr = AuthManager(storage_backend='file')
+    mgr.remove_credentials(provider)
+    console.print(f"[green]Credentials for [bold]{provider}[/] removed.[/]")
+
+
+@auth.command(name="export")
+@click.option("--provider", default=None, help="Export only this provider (default: all).")
+@click.option(
+    "--output",
+    "-o",
+    default="credentials_backup.json",
+    show_default=True,
+    help="Output file path.",
+)
+def auth_export(provider: str | None, output: str) -> None:
+    """
+    Export stored credentials to a JSON file for backup.
+
+    WARNING: Exported file contains sensitive credentials — store securely.
+
+    \b
+    Example:
+      pygeofetch auth export --output backup.json
+      pygeofetch auth export --provider usgs --output usgs_creds.json
+    """
+    from pygeofetch.core.authenticator import AuthManager
+
+    mgr = AuthManager(storage_backend='file')
+    data = mgr.export_credentials(provider_filter=provider)
+
+    with open(output, "w") as f:
+        json.dump(data, f, indent=2, default=str)
+
+    console.print(
+        f"[yellow]WARNING: {output} contains sensitive credentials. "
+        "Store it securely and delete after use.[/]\n"
+        f"[green]Exported {len(data)} provider(s) to {output}[/]"
+    )

pygeofetch/cli/config_commands.py

@@ -0,0 +1,143 @@
+"""
+Configuration CLI commands for pygeofetch.
+
+Usage::
+
+    pygeofetch config show
+    pygeofetch config get download.parallel
+    pygeofetch config set download.parallel 4
+    pygeofetch config path
+"""
+
+from __future__ import annotations
+
+import sys
+
+import click
+from rich.console import Console
+from rich.syntax import Syntax
+
+console = Console()
+
+
+@click.group()
+def config() -> None:
+    """Inspect and modify pygeofetch configuration."""
+
+
+@config.command(name="show")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def config_show(as_json: bool) -> None:
+    """Show the effective configuration (all layers merged)."""
+    import json
+    from pygeofetch.config.settings import get_settings
+
+    settings = get_settings()
+    data = settings.model_dump()
+
+    if as_json:
+        click.echo(json.dumps(data, indent=2, default=str))
+        return
+
+    import yaml
+    rendered = yaml.dump(data, default_flow_style=False, sort_keys=True)
+    console.print(Syntax(rendered, "yaml", theme="monokai"))
+
+
+@config.command(name="get")
+@click.argument("key")
+def config_get(key: str) -> None:
+    """
+    Get a single configuration value by dotted KEY path.
+
+    \b
+    Example:
+      pygeofetch config get download.parallel
+    """
+    from pygeofetch.config.settings import get_settings
+
+    settings = get_settings()
+    data = settings.model_dump()
+
+    parts = key.split(".")
+    value = data
+    for part in parts:
+        if isinstance(value, dict) and part in value:
+            value = value[part]
+        else:
+            console.print(f"[red]Key not found: {key!r}[/]")
+            sys.exit(1)
+
+    console.print(f"{key} = {value!r}")
+
+
+@config.command(name="set")
+@click.argument("key")
+@click.argument("value")
+def config_set(key: str, value: str) -> None:
+    """
+    Set a configuration value in the user config file.
+
+    The value is cast to int/float/bool if it looks like one; otherwise stored as string.
+
+    \b
+    Example:
+      pygeofetch config set download.parallel 4
+      pygeofetch config set cache.ttl_seconds 7200
+    """
+    from pygeofetch.config.settings import get_settings, save_user_config
+
+    # Try to coerce to typed value
+    typed_value: object = value
+    if value.lower() in ("true", "yes"):
+        typed_value = True
+    elif value.lower() in ("false", "no"):
+        typed_value = False
+    else:
+        try:
+            typed_value = int(value)
+        except ValueError:
+            try:
+                typed_value = float(value)
+            except ValueError:
+                pass  # keep as string
+
+    # Build nested dict from dotted key
+    parts = key.split(".")
+    nested: dict = {}
+    current = nested
+    for i, part in enumerate(parts):
+        if i == len(parts) - 1:
+            current[part] = typed_value
+        else:
+            current[part] = {}
+            current = current[part]
+
+    save_user_config(nested)
+    console.print(f"[green]Set[/] {key} = {typed_value!r}")
+
+
+@config.command(name="path")
+def config_path() -> None:
+    """Show the location of configuration files."""
+    from pygeofetch.config.settings import get_config_dir
+
+    cfg_dir = get_config_dir()
+    console.print(f"Config directory: [cyan]{cfg_dir}[/]")
+    console.print(f"User config:      [cyan]{cfg_dir / 'config.yaml'}[/]")
+    console.print(f"Credentials:      [cyan]{cfg_dir / 'credentials.json'}[/]")
+    console.print(f"Cache:            [cyan]{cfg_dir / 'cache'}[/]")
+
+
+@config.command(name="reset")
+@click.confirmation_option(prompt="Reset user config to defaults?")
+def config_reset() -> None:
+    """Remove the user configuration file, restoring defaults."""
+    from pygeofetch.config.settings import get_config_dir
+
+    cfg_path = get_config_dir() / "config.yaml"
+    if cfg_path.exists():
+        cfg_path.unlink()
+        console.print(f"[green]Removed {cfg_path}[/]")
+    else:
+        console.print("[dim]No user config file found.[/]")