redis-flags 0.1.0__tar.gz

redis_flags-0.1.0/.gitignore

@@ -0,0 +1 @@
+~/.redis-flags.toml

redis_flags-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: redis-flags
+Version: 0.1.0
+Summary: CLI for redis-feature-flags — manage feature flags from your terminal.
+License: MIT
+Keywords: cli,feature-flags,redis
+Requires-Python: >=3.9
+Requires-Dist: redis-feature-flags>=0.1.0
+Requires-Dist: redis>=4.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: tomli-w
+Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: fakeredis>=2.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: typer[testing]>=0.9.0; extra == 'dev'

redis_flags-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "redis-flags"
+version = "0.1.0"
+description = "CLI for redis-feature-flags — manage feature flags from your terminal."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["redis", "feature-flags", "cli"]
+dependencies = [
+    "redis>=4.0.0",
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "tomli>=2.0.0; python_version < '3.11'",
+    "tomli-w",
+    "redis-feature-flags>=0.1.0",
+]
+
+[project.scripts]
+redis-flags = "redis_flags.main:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["redis_flags"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "fakeredis>=2.0",
+    "typer[testing]>=0.9.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=redis_flags --cov-report=term-missing --cov-fail-under=90"
+
+[tool.coverage.run]
+source = ["redis_flags"]
+omit = ["tests/*"]

redis_flags-0.1.0/redis_flags/commands/__init__.py

@@ -0,0 +1 @@
+from . import flag, user, cohort, history

redis_flags-0.1.0/redis_flags/commands/cohort.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ..config import get_env, get_redis_url
+from ..connection import get_client
+from ..output import (
+    print_cohorts_table, print_cohort_panel,
+    print_success, print_error
+)
+from redis_feature_flags import FeatureFlags
+from redis_feature_flags.exceptions import FlagNotFoundError
+
+app = typer.Typer()
+
+
+def get_flags(env: Optional[str], redis_url: Optional[str]) -> FeatureFlags:
+    resolved_env = get_env(env)
+    resolved_url = get_redis_url(redis_url)
+    client = get_client(resolved_url)
+    return FeatureFlags(client, env=resolved_env)
+
+
+@app.command("create-cohort")
+def create_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Create a new cohort.
+
+    Example:
+        redis-flags create-cohort beta-testers
+    """
+    flags = get_flags(env, redis_url)
+    flags.create_cohort(cohort_name)
+    print_success(f"Created cohort [bold]{cohort_name}[/bold]")
+
+
+@app.command("delete-cohort")
+def delete_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """
+    Delete a cohort and clean up all member reverse index entries.
+
+    Example:
+        redis-flags delete-cohort beta-testers
+        redis-flags delete-cohort beta-testers --yes
+    """
+    if not confirm:
+        typer.confirm(
+            f"Delete cohort '{cohort_name}'? This cannot be undone.",
+            abort=True,
+        )
+    flags = get_flags(env, redis_url)
+    flags._cohorts.delete(cohort_name)
+    print_success(f"Deleted cohort [bold]{cohort_name}[/bold]")
+
+
+@app.command("add-to-cohort")
+def add_to_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    user_id: str = typer.Argument(..., help="User ID to add"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Add a user to a cohort.
+
+    Example:
+        redis-flags add-to-cohort beta-testers alice
+    """
+    flags = get_flags(env, redis_url)
+    flags.add_to_cohort(cohort_name, user_id)
+    print_success(f"Added [bold]{user_id}[/bold] to cohort [bold]{cohort_name}[/bold]")
+
+
+@app.command("remove-from-cohort")
+def remove_from_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    user_id: str = typer.Argument(..., help="User ID to remove"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Remove a user from a cohort.
+
+    Example:
+        redis-flags remove-from-cohort beta-testers alice
+    """
+    flags = get_flags(env, redis_url)
+    flags.remove_from_cohort(cohort_name, user_id)
+    print_success(f"Removed [bold]{user_id}[/bold] from cohort [bold]{cohort_name}[/bold]")
+
+
+@app.command("list-cohorts")
+def list_cohorts(
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    List all cohorts.
+
+    Example:
+        redis-flags list-cohorts
+    """
+    flags = get_flags(env, redis_url)
+    cohorts = flags._cohorts.list_cohorts()
+    print_cohorts_table(cohorts)
+
+
+@app.command("inspect-cohort")
+def inspect_cohort(
+    cohort_name: str = typer.Argument(..., help="Cohort name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Show all members of a cohort.
+
+    Example:
+        redis-flags inspect-cohort beta-testers
+    """
+    flags = get_flags(env, redis_url)
+    members = flags._cohorts.get_members(cohort_name)
+    print_cohort_panel(cohort_name, list(members))

redis_flags-0.1.0/redis_flags/commands/flag.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..config import get_env, get_redis_url
+from ..connection import get_client
+from ..output import (
+    print_flags_table, print_flag_panel,
+    print_success, print_error
+)
+from redis_feature_flags import FeatureFlags
+from redis_feature_flags.exceptions import (
+    FlagNotFoundError, InvalidRolloutError
+)
+
+import getpass
+
+app = typer.Typer()
+console = Console()
+
+
+def get_flags(env: Optional[str], redis_url: Optional[str]) -> FeatureFlags:
+    """Build FeatureFlags instance from CLI options."""
+    resolved_env = get_env(env)
+    resolved_url = get_redis_url(redis_url)
+    client = get_client(resolved_url)
+    return FeatureFlags(client, env=resolved_env)
+
+
+@app.command("create")
+def create(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    rollout: int = typer.Option(0, "--rollout", "-r", help="Rollout percentage 0-100"),
+    created_by: str = typer.Option(getpass.getuser(), "--created-by", help="Who is creating this flag"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Create a new feature flag.
+
+    Example:
+        redis-flags create dark_mode
+        redis-flags create dark_mode --rollout 10
+        redis-flags create dark_mode --rollout 10 --created-by alice
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.create(flag_name, rollout=rollout, created_by=created_by)
+        print_success(f"Created flag [bold]{flag_name}[/bold] (rollout: {rollout}%)")
+    except InvalidRolloutError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("enable")
+def enable(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    updated_by: str = typer.Option(getpass.getuser(), "--updated-by", help="Who is enabling this flag"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Enable a feature flag.
+
+    Example:
+        redis-flags enable dark_mode
+        redis-flags enable dark_mode --updated-by alice
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.enable(flag_name, updated_by=updated_by)
+        print_success(f"Enabled [bold]{flag_name}[/bold]")
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("disable")
+def disable(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    updated_by: str = typer.Option(getpass.getuser(), "--updated-by", help="Who is disabling this flag"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Disable a feature flag — instant kill switch.
+
+    Example:
+        redis-flags disable dark_mode
+        redis-flags disable dark_mode --updated-by alice
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.disable(flag_name, updated_by=updated_by)
+        print_success(f"Disabled [bold]{flag_name}[/bold]")
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("set-rollout")
+def set_rollout(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    percent: int = typer.Argument(..., help="Rollout percentage 0-100"),
+    updated_by: str = typer.Option(getpass.getuser(), "--updated-by", help="Who is updating this flag"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Set the rollout percentage for a flag.
+
+    Example:
+        redis-flags set-rollout dark_mode 50
+        redis-flags set-rollout dark_mode 100
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.set_rollout(flag_name, percent, updated_by=updated_by)
+        print_success(f"Rollout for [bold]{flag_name}[/bold] set to {percent}%")
+    except (FlagNotFoundError, InvalidRolloutError) as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """
+    Delete a feature flag permanently.
+
+    Example:
+        redis-flags delete dark_mode
+        redis-flags delete dark_mode --yes
+    """
+    if not confirm:
+        typer.confirm(
+            f"Delete flag '{flag_name}'? This cannot be undone.",
+            abort=True,
+        )
+    try:
+        flags = get_flags(env, redis_url)
+        flags.delete(flag_name)
+        print_success(f"Deleted flag [bold]{flag_name}[/bold]")
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_flags(
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    List all feature flags.
+
+    Example:
+        redis-flags list
+        redis-flags --env prod list
+    """
+    flags = get_flags(env, redis_url)
+    flag_names = flags.list_flags()
+    flag_data = []
+    for name in flag_names:
+        data = flags.get(name)
+        data["name"] = name
+        flag_data.append(data)
+    print_flags_table(flag_data)
+
+
+@app.command("inspect")
+def inspect(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Show detailed information about a flag including users and cohorts.
+
+    Example:
+        redis-flags inspect dark_mode
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        resolved_env = get_env(env)
+        resolved_url = get_redis_url(redis_url)
+        client = get_client(resolved_url)
+
+        from redis_feature_flags.schema import SchemaKeys
+        schema = SchemaKeys(env=resolved_env)
+
+        data = flags.get(flag_name)
+        data["name"] = flag_name
+
+        users = [
+            u.decode() for u in
+            client.smembers(schema.flag_users(flag_name))
+        ]
+        cohorts = [
+            c.decode() for c in
+            client.smembers(schema.flag_cohorts(flag_name))
+        ]
+        print_flag_panel(data, users, cohorts)
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)

redis_flags-0.1.0/redis_flags/commands/history.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command("history")
+def history(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Show version history for a flag.
+
+    Example:
+        redis-flags history dark_mode
+    """
+    console.print("[yellow]History coming in v1.1[/yellow]")
+
+
+@app.command("rollback")
+def rollback(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    version: int = typer.Option(..., "--version", "-v", help="Version to roll back to"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Roll back a flag to a previous version.
+
+    Example:
+        redis-flags rollback dark_mode --version 2
+    """
+    console.print("[yellow]Rollback coming in v1.1[/yellow]")

redis_flags-0.1.0/redis_flags/commands/user.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ..config import get_env, get_redis_url
+from ..connection import get_client
+from ..output import print_success, print_error
+from redis_feature_flags import FeatureFlags
+from redis_feature_flags.exceptions import FlagNotFoundError
+
+app = typer.Typer()
+
+
+def get_flags(env: Optional[str], redis_url: Optional[str]) -> FeatureFlags:
+    resolved_env = get_env(env)
+    resolved_url = get_redis_url(redis_url)
+    client = get_client(resolved_url)
+    return FeatureFlags(client, env=resolved_env)
+
+
+@app.command("add-user")
+def add_user(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    user_id: str = typer.Argument(..., help="User ID to add"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Add a user to a flag's allowlist.
+
+    Example:
+        redis-flags add-user dark_mode alice
+    """
+    try:
+        flags = get_flags(env, redis_url)
+        flags.add_user(flag_name, user_id)
+        print_success(f"Added [bold]{user_id}[/bold] to flag [bold]{flag_name}[/bold]")
+    except FlagNotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("remove-user")
+def remove_user(
+    flag_name: str = typer.Argument(..., help="Flag name"),
+    user_id: str = typer.Argument(..., help="User ID to remove"),
+    env: Optional[str] = typer.Option(None, "--env", help="Environment override"),
+    redis_url: Optional[str] = typer.Option(None, "--redis-url", help="Redis URL override"),
+):
+    """
+    Remove a user from a flag's allowlist.
+
+    Example:
+        redis-flags remove-user dark_mode alice
+    """
+    flags = get_flags(env, redis_url)
+    flags.remove_user(flag_name, user_id)
+    print_success(f"Removed [bold]{user_id}[/bold] from flag [bold]{flag_name}[/bold]")

redis_flags-0.1.0/redis_flags/config.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+import tomli_w
+
+CONFIG_PATH = Path.home() / ".redis-flags.toml"
+
+
+def read_config() -> dict:
+    """
+    Read config from ~/.redis-flags.toml.
+    Returns empty dict if file does not exist.
+    """
+    if not CONFIG_PATH.exists():
+        return {}
+    with open(CONFIG_PATH, "rb") as f:
+        return tomllib.load(f)
+
+
+def write_config(data: dict) -> None:
+    """
+    Write config to ~/.redis-flags.toml.
+    Creates the file if it does not exist.
+    """
+    with open(CONFIG_PATH, "wb") as f:
+        tomli_w.dump(data, f)
+
+
+def get_env(env_override: Optional[str] = None) -> str:
+    """
+    Resolve the active environment.
+
+    Priority:
+        1. --env flag passed directly to command
+        2. env saved in ~/.redis-flags.toml
+        3. Neither set → raise error with helpful message
+
+    Args:
+        env_override: value from --env flag. None if not passed.
+
+    Returns:
+        The active environment string e.g. "prod", "staging", "dev"
+
+    Raises:
+        SystemExit: if no environment is set anywhere.
+    """
+    if env_override:
+        return env_override
+
+    config = read_config()
+    env = config.get("env")
+
+    if not env:
+        from rich.console import Console
+        console = Console()
+        console.print("\n[red]Error:[/red] No environment set.\n")
+        console.print("  Set a default environment:")
+        console.print("    [cyan]redis-flags use prod[/cyan]")
+        console.print("    [cyan]redis-flags use staging[/cyan]")
+        console.print("    [cyan]redis-flags use dev[/cyan]\n")
+        console.print("  Or specify for this command:")
+        console.print("    [cyan]redis-flags --env prod list[/cyan]\n")
+        raise SystemExit(1)
+
+    return env
+
+
+def get_redis_url(url_override: Optional[str] = None) -> str:
+    """
+    Resolve the Redis URL.
+
+    Priority:
+        1. --redis-url flag passed directly to command
+        2. redis_url saved in ~/.redis-flags.toml
+        3. Default: redis://localhost:6379
+
+    Args:
+        url_override: value from --redis-url flag. None if not passed.
+
+    Returns:
+        Redis URL string.
+    """
+    if url_override:
+        return url_override
+
+    config = read_config()
+    return config.get("redis_url", "redis://localhost:6379")

redis_flags-0.1.0/redis_flags/connection.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import redis
+from rich.console import Console
+
+console = Console()
+
+
+def get_client(redis_url: str) -> redis.Redis:
+    """
+    Create and verify a Redis client connection.
+
+    Args:
+        redis_url: Full Redis URL e.g. redis://localhost:6379
+                   Supports auth: redis://:password@host:6379
+
+    Returns:
+        Connected Redis client.
+
+    Raises:
+        SystemExit: if Redis is unreachable.
+    """
+    try:
+        client = redis.Redis.from_url(redis_url, decode_responses=False)
+        client.ping()
+        return client
+    except redis.ConnectionError:
+        console.print(f"\n[red]Error:[/red] Cannot connect to Redis at {redis_url}\n")
+        console.print("  Start Redis locally:")
+        console.print("    [cyan]brew services start redis[/cyan]       (macOS)")
+        console.print("    [cyan]sudo systemctl start redis[/cyan]      (Linux)")
+        console.print("    [cyan]docker run -p 6379:6379 redis[/cyan]   (Docker)\n")
+        console.print("  Or set a custom Redis URL:")
+        console.print("    [cyan]redis-flags --redis-url redis://your-host:6379 list[/cyan]\n")
+        raise SystemExit(1)
+    except redis.AuthenticationError:
+        console.print(f"\n[red]Error:[/red] Redis authentication failed.\n")
+        console.print("  Provide credentials in the URL:")
+        console.print("    [cyan]redis-flags --redis-url redis://:password@host:6379 list[/cyan]\n")
+        raise SystemExit(1)