secure-fl 2026.2.20.dev5__tar.gz → 2026.2.22.dev1__tar.gz

{secure_fl-2026.2.20.dev5 → secure_fl-2026.2.22.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: secure-fl
-Version: 2026.2.20.dev5
+Version: 2026.2.22.dev1
 Summary: Dual-Verifiable Framework for Federated Learning using Zero-Knowledge Proofs
 Project-URL: Homepage, https://github.com/krishantt/secure-fl
 Project-URL: Bug Reports, https://github.com/krishantt/secure-fl/issues
@@ -311,9 +311,9 @@ secure-fl/
 │   ├── core/            # Types, config, exceptions, versioning
 │   ├── cli/             # CLI commands and setup helpers
 │   └── utils/           # Logging and helper utilities
-├── proofs/              # ZKP circuits
-│   ├── client_circuits/ # zk-STARK (Cairo)
-│   └── server/          # zk-SNARK (Circom)
+│   ├── proofs/          # ZKP circuits and proving assets
+│   │   ├── client_circuits/ # zk-STARK/PySNARK client circuits
+│   │   └── server/      # zk-SNARK (Circom) server circuits
 ├── experiments/         # Research experiments
 ├── tests/               # Test suite
 └── docs/                # Documentation

{secure_fl-2026.2.20.dev5 → secure_fl-2026.2.22.dev1}/README.md

@@ -255,9 +255,9 @@ secure-fl/
 │   ├── core/            # Types, config, exceptions, versioning
 │   ├── cli/             # CLI commands and setup helpers
 │   └── utils/           # Logging and helper utilities
-├── proofs/              # ZKP circuits
-│   ├── client_circuits/ # zk-STARK (Cairo)
-│   └── server/          # zk-SNARK (Circom)
+│   ├── proofs/          # ZKP circuits and proving assets
+│   │   ├── client_circuits/ # zk-STARK/PySNARK client circuits
+│   │   └── server/      # zk-SNARK (Circom) server circuits
 ├── experiments/         # Research experiments
 ├── tests/               # Test suite
 └── docs/                # Documentation

{secure_fl-2026.2.20.dev5 → secure_fl-2026.2.22.dev1}/pyproject.toml

@@ -108,7 +108,6 @@ packages = ["src/secure_fl"]
 [tool.hatch.build]
 include = [
     "src/",
-    "proofs/",
     "README.md",
     "LICENSE",
 ]

secure_fl-2026.2.22.dev1/src/secure_fl/.build_number

@@ -0,0 +1 @@
+2026.02.22:1

{secure_fl-2026.2.20.dev5 → secure_fl-2026.2.22.dev1}/src/secure_fl/cli/__init__.py

@@ -6,12 +6,12 @@ with the Secure FL framework, including commands for running servers,
 clients, configuration management, and system validation.
 """
 
-from .main import check_zkp
-from .main import check_zkp_tools
 from .main import client
 from .main import create_config
 from .main import main
 from .main import server
+from .zkp_check import check_zkp
+from .zkp_check import check_zkp_tools
 
 
 def print_system_info() -> None:

secure_fl-2026.2.22.dev1/src/secure_fl/cli/handlers.py

@@ -0,0 +1,270 @@
+"""Command handlers for the Secure FL CLI."""
+
+import logging
+import os
+import shutil
+import subprocess
+from typing import TYPE_CHECKING
+from typing import Union
+
+import click
+from rich import print as rprint
+from rich.console import Console
+from rich.progress import Progress
+from rich.progress import SpinnerColumn
+from rich.progress import TextColumn
+from rich.table import Table
+
+from secure_fl.core.config import create_example_config
+from secure_fl.models import CIFAR10Model
+from secure_fl.models import MNISTModel
+from secure_fl.models import SimpleModel
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+logger = logging.getLogger(__name__)
+
+
+def run_server(
+    *,
+    config: str | None,
+    host: str,
+    port: int,
+    rounds: int,
+    min_clients: int,
+    enable_zkp: bool,
+    proof_rigor: str,
+    momentum: float,
+    blockchain: bool,
+    model: str,
+    console: Console,
+) -> None:
+    from secure_fl.core import get_default_config
+    from secure_fl.federation.server import SecureFlowerServer
+    from secure_fl.federation.server import create_server_strategy
+
+    if config:
+        import yaml
+
+        with open(config) as f:
+            cfg = yaml.safe_load(f)
+    else:
+        cfg = get_default_config()
+
+    cfg["server"].update({"host": host, "port": port, "num_rounds": rounds})
+
+    strategy_config = {**cfg["strategy"], **cfg["aggregation"], **cfg["zkp"]}
+    strategy_config.update(
+        {
+            "min_available_clients": min_clients,
+            "min_fit_clients": min_clients,
+            "min_evaluate_clients": min_clients,
+            "momentum": momentum,
+            "enable_zkp": enable_zkp,
+            "proof_rigor": proof_rigor,
+            "blockchain_verification": blockchain,
+        }
+    )
+
+    model_fn: Callable[[], Union[MNISTModel, CIFAR10Model, SimpleModel]]
+    if model == "mnist":
+
+        def model_fn() -> MNISTModel:
+            return MNISTModel()
+    elif model == "cifar10":
+
+        def model_fn() -> CIFAR10Model:
+            return CIFAR10Model()
+    elif model == "simple":
+
+        def model_fn() -> SimpleModel:
+            return SimpleModel(input_dim=784, output_dim=10)
+    else:
+        raise click.ClickException(
+            f"Unknown model '{model}'. Available: mnist, cifar10, simple"
+        )
+
+    strategy = create_server_strategy(model_fn=model_fn, **strategy_config)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Starting Secure FL Server...", total=None)
+        server = SecureFlowerServer(strategy=strategy, **cfg["server"])
+        progress.update(task, description="Server ready! Waiting for clients...")
+
+        table = Table(title="Server Configuration")
+        table.add_column("Parameter", style="cyan")
+        table.add_column("Value", style="green")
+        table.add_row("Host", f"{host}:{port}")
+        table.add_row("Rounds", str(rounds))
+        table.add_row("Min Clients", str(min_clients))
+        table.add_row("ZKP Enabled", "✓" if enable_zkp else "✗")
+        table.add_row("Proof Rigor", proof_rigor)
+        table.add_row("Momentum", str(momentum))
+        table.add_row("Blockchain", "✓" if blockchain else "✗")
+        console.print(table)
+        server.start()
+
+
+def run_client(
+    *,
+    server_address: str,
+    client_id: str,
+    dataset: str,
+    data_path: str | None,
+    partition: int | None,
+    enable_zkp: bool,
+    epochs: int,
+    batch_size: int,
+    learning_rate: float,
+    proof_rigor: str,
+    console: Console,
+) -> None:
+    from secure_fl.data import FederatedDataLoader
+    from secure_fl.federation.client import create_client
+    from secure_fl.federation.client import start_client
+
+    if data_path:
+        data_loader = FederatedDataLoader(
+            dataset_name="synthetic",
+            num_clients=1,
+            batch_size=batch_size,
+        )
+        loaders = data_loader.create_client_dataloaders(client_id=0)
+        train_loader, val_loader = (
+            loaders if not isinstance(loaders, list) else loaders[0]
+        )
+        train_data = train_loader.dataset
+        val_data = val_loader.dataset if val_loader else None
+    else:
+        data_loader = FederatedDataLoader(
+            dataset_name=dataset,
+            num_clients=max(1, partition + 1) if partition is not None else 5,
+            batch_size=batch_size,
+        )
+        client_partition = partition or 0
+        loaders = data_loader.create_client_dataloaders(client_id=client_partition)
+        train_loader, val_loader = (
+            loaders if not isinstance(loaders, list) else loaders[0]
+        )
+        train_data = train_loader.dataset
+        val_data = val_loader.dataset if val_loader else None
+
+    if dataset in ["mnist", "synthetic"] and dataset != "custom":
+        model_fn: Callable[[], Union[MNISTModel, CIFAR10Model, SimpleModel]]
+        if dataset == "mnist":
+
+            def model_fn() -> MNISTModel:
+                return MNISTModel()
+        elif dataset == "cifar10":
+
+            def model_fn() -> CIFAR10Model:
+                return CIFAR10Model()
+        else:
+
+            def model_fn() -> SimpleModel:
+                return SimpleModel()
+    else:
+
+        def model_fn() -> SimpleModel:
+            return SimpleModel()
+
+    client = create_client(
+        client_id=client_id,
+        model_fn=model_fn,
+        train_data=train_data,
+        val_data=val_data,
+        enable_zkp=enable_zkp,
+        local_epochs=epochs,
+        batch_size=batch_size,
+        learning_rate=learning_rate,
+        proof_rigor=proof_rigor,
+    )
+
+    table = Table(title=f"Client {client_id} Configuration")
+    table.add_column("Parameter", style="cyan")
+    table.add_column("Value", style="green")
+    table.add_row("Server", server_address)
+    table.add_row("Dataset", dataset)
+    table.add_row("ZKP Enabled", "✓" if enable_zkp else "✗")
+    table.add_row("Epochs", str(epochs))
+    table.add_row("Batch Size", str(batch_size))
+    table.add_row("Learning Rate", str(learning_rate))
+    console.print(table)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        progress.add_task("Connecting to server...", total=None)
+        start_client(client, server_address)
+
+
+def run_setup(*, action: str, skip_zkp: bool) -> None:
+    from secure_fl.cli.setup import print_setup_status
+    from secure_fl.cli.setup import setup_environment
+
+    if action == "check":
+        rprint("[bold]🔍 Checking System Requirements[/bold]")
+        print_setup_status()
+    elif action == "install":
+        rprint("[bold]📦 Installing Python Dependencies[/bold]")
+        success = setup_environment()
+        if success:
+            rprint("[green]✓ Python dependencies installed successfully[/green]")
+        else:
+            rprint("[red]✗ Failed to install some dependencies[/red]")
+    elif action == "zkp":
+        if skip_zkp:
+            rprint("[yellow]⚠ Skipping ZKP tools installation[/yellow]")
+            return
+        rprint("[bold]🔐 Setting up ZKP Tools[/bold]")
+        from secure_fl.cli.setup import install_zkp_tools
+
+        success = install_zkp_tools()
+        if success:
+            rprint("[green]✓ ZKP tools setup completed[/green]")
+        else:
+            rprint("[yellow]⚠ ZKP tools setup completed with warnings[/yellow]")
+    elif action == "clean":
+        rprint("[bold]🧹 Cleaning temporary files[/bold]")
+        for cache_dir in [".ruff_cache", ".mypy_cache", "__pycache__"]:
+            if os.path.exists(cache_dir):
+                shutil.rmtree(cache_dir)
+        rprint("[green]✓ Cleanup completed[/green]")
+    elif action == "full":
+        rprint("[bold]🚀 Full Setup[/bold]")
+        rprint("1. Installing Python dependencies...")
+        success = setup_environment()
+        if not skip_zkp:
+            rprint("2. Setting up ZKP tools...")
+            from secure_fl.cli.setup import install_zkp_tools
+
+            install_zkp_tools()
+        else:
+            rprint("2. Skipping ZKP tools...")
+
+        rprint("3. Creating configuration...")
+        create_example_config("config.yaml")
+        rprint("4. Running tests...")
+        try:
+            subprocess.run(["uv", "run", "pytest", "--tb=short"], check=True)
+            test_success = True
+        except subprocess.CalledProcessError:
+            test_success = False
+
+        if success and test_success:
+            rprint("[green]✓ Full setup completed successfully![/green]")
+            rprint("\n[bold]Next steps:[/bold]")
+            rprint(
+                "1. Run a demo: [cyan]secure-fl experiment --dataset synthetic --rounds 3[/cyan]"
+            )
+            rprint("2. Start a server: [cyan]secure-fl server --rounds 5[/cyan]")
+            rprint("3. Connect clients: [cyan]secure-fl client -i client_1[/cyan]")
+        else:
+            rprint("[yellow]⚠ Setup completed with test failures[/yellow]")

secure_fl-2026.2.22.dev1/src/secure_fl/cli/main.py

@@ -0,0 +1,258 @@
+"""
+Command Line Interface for Secure FL
+
+This module provides command-line interfaces for running the Secure FL framework,
+including server, client, experiment, and setup commands.
+"""
+
+import logging
+import sys
+
+import click
+from rich import print as rprint
+from rich.console import Console
+from rich.logging import RichHandler
+
+from secure_fl.cli.handlers import run_client
+from secure_fl.cli.handlers import run_server
+from secure_fl.cli.handlers import run_setup
+from secure_fl.cli.zkp_check import check_zkp
+from secure_fl.core.config import create_example_config
+
+# Setup rich console and logging
+console = Console()
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(console=console, rich_tracebacks=True)],
+)
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+@click.version_option(version="0.1.0")
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging")
+@click.option("--quiet", "-q", is_flag=True, help="Suppress output")
+def main(verbose: bool, quiet: bool) -> None:
+    """
+    🔐 Secure FL: Dual-Verifiable Federated Learning with Zero-Knowledge Proofs
+
+    A complete framework for federated learning with ZKP verification using
+    client-side zk-STARKs and server-side zk-SNARKs.
+    """
+    if verbose:
+        logging.getLogger().setLevel(logging.DEBUG)
+    elif quiet:
+        logging.getLogger().setLevel(logging.ERROR)
+
+    # Display banner
+    if not quiet:
+        rprint(
+            """
+[bold blue]🔐 Secure FL Framework[/bold blue]
+[dim]Dual-Verifiable Federated Learning with Zero-Knowledge Proofs[/dim]
+        """
+        )
+
+
+@main.command()
+@click.option(
+    "--config", "-c", type=click.Path(exists=True), help="Configuration file path"
+)
+@click.option("--host", default="localhost", help="Server host address")
+@click.option("--port", default=8080, type=int, help="Server port")
+@click.option("--rounds", "-r", default=10, type=int, help="Number of training rounds")
+@click.option(
+    "--min-clients", default=2, type=int, help="Minimum number of clients required"
+)
+@click.option(
+    "--enable-zkp/--disable-zkp",
+    default=True,
+    help="Enable/disable zero-knowledge proofs",
+)
+@click.option(
+    "--proof-rigor",
+    type=click.Choice(["low", "medium", "high"]),
+    default="high",
+    help="ZKP rigor level",
+)
+@click.option(
+    "--momentum", default=0.9, type=float, help="FedJSCM momentum coefficient"
+)
+@click.option(
+    "--blockchain/--no-blockchain", default=False, help="Enable blockchain verification"
+)
+@click.option(
+    "--model",
+    type=click.Choice(["mnist", "cifar10", "simple", "custom"]),
+    default="mnist",
+    help="Model type to use",
+)
+def server(
+    config: str | None,
+    host: str,
+    port: int,
+    rounds: int,
+    min_clients: int,
+    enable_zkp: bool,
+    proof_rigor: str,
+    momentum: float,
+    blockchain: bool,
+    model: str,
+) -> None:
+    """Start the Secure FL server"""
+    try:
+        run_server(
+            config=config,
+            host=host,
+            port=port,
+            rounds=rounds,
+            min_clients=min_clients,
+            enable_zkp=enable_zkp,
+            proof_rigor=proof_rigor,
+            momentum=momentum,
+            blockchain=blockchain,
+            model=model,
+            console=console,
+        )
+
+    except ImportError as e:
+        raise click.ClickException(f"Missing dependencies: {e}") from e
+    except Exception as e:
+        logger.error(f"Server failed to start: {e}")
+        raise click.ClickException(f"Server error: {e}") from e
+
+
+@main.command()
+@click.option(
+    "--server-address",
+    "-s",
+    default="localhost:8080",
+    help="Server address (host:port)",
+)
+@click.option("--client-id", "-i", required=True, help="Unique client identifier")
+@click.option(
+    "--dataset",
+    type=click.Choice(["mnist", "cifar10", "synthetic"]),
+    default="mnist",
+    help="Dataset to use for training",
+)
+@click.option("--data-path", type=click.Path(), help="Path to custom dataset")
+@click.option("--partition", type=int, help="Data partition index")
+@click.option(
+    "--enable-zkp/--disable-zkp",
+    default=True,
+    help="Enable/disable zero-knowledge proof generation",
+)
+@click.option(
+    "--epochs", "-e", default=5, type=int, help="Local training epochs per round"
+)
+@click.option("--batch-size", "-b", default=32, type=int, help="Training batch size")
+@click.option(
+    "--learning-rate", "-lr", default=0.01, type=float, help="Local learning rate"
+)
+@click.option(
+    "--proof-rigor",
+    type=click.Choice(["high", "medium", "low"]),
+    default="high",
+    help="ZKP proof rigor level",
+)
+def client(
+    server_address: str,
+    client_id: str,
+    dataset: str,
+    data_path: str | None,
+    partition: int | None,
+    enable_zkp: bool,
+    epochs: int,
+    batch_size: int,
+    learning_rate: float,
+    proof_rigor: str,
+) -> None:
+    """Start a Secure FL client"""
+    try:
+        run_client(
+            server_address=server_address,
+            client_id=client_id,
+            dataset=dataset,
+            data_path=data_path,
+            partition=partition,
+            enable_zkp=enable_zkp,
+            epochs=epochs,
+            batch_size=batch_size,
+            learning_rate=learning_rate,
+            proof_rigor=proof_rigor,
+            console=console,
+        )
+
+    except ImportError as e:
+        raise click.ClickException(f"Missing dependencies: {e}") from e
+    except Exception as e:
+        logger.error(f"Client failed to start: {e}")
+        raise click.ClickException(f"Client error: {e}") from e
+
+
+@main.command()
+@click.option(
+    "--action",
+    type=click.Choice(["install", "zkp", "check", "clean", "full"]),
+    default="check",
+    help="Setup action to perform",
+)
+@click.option("--force", is_flag=True, help="Force reinstallation")
+@click.option("--skip-zkp", is_flag=True, help="Skip ZKP tools installation")
+def setup(action: str, force: bool, skip_zkp: bool) -> None:
+    """Setup and configure Secure FL environment"""
+    try:
+        _ = force
+        run_setup(action=action, skip_zkp=skip_zkp)
+
+    except Exception as e:
+        logger.error(f"Setup failed: {e}")
+        raise click.ClickException(f"Setup error: {e}") from e
+
+
+@main.command()
+def info() -> None:
+    """Display system information and component status"""
+
+    from . import print_system_info
+
+    print_system_info()
+
+
+def server_command() -> None:
+    """Entry point for secure-fl-server command"""
+    server.main(args=sys.argv[1:], prog_name="secure-fl-server")
+
+
+def client_command() -> None:
+    """Entry point for secure-fl-client command"""
+    client.main(args=sys.argv[1:], prog_name="secure-fl-client")
+
+
+def setup_command() -> None:
+    """Entry point for secure-fl-setup command"""
+    setup.main(args=sys.argv[1:], prog_name="secure-fl-setup")
+
+
+@main.command()
+@click.option("--output", "-o", default="config.yaml", help="Output file path")
+def create_config(output: str) -> None:
+    """Create an example configuration file."""
+    try:
+        create_example_config(output)
+        console.print(f"✅ Example configuration created at [bold]{output}[/bold]")
+        console.print("Edit the file to customize your settings.")
+    except Exception as e:
+        console.print(f"❌ Error creating configuration: {e}", style="red")
+        raise click.Abort() from e
+
+
+# Add check-zkp command to main CLI
+main.add_command(check_zkp, name="check-zkp")
+
+
+if __name__ == "__main__":
+    main()

secure_fl-2026.2.22.dev1/src/secure_fl/cli/zkp_check.py

@@ -0,0 +1,78 @@
+"""ZKP tool availability checks and CLI command."""
+
+import subprocess
+import sys
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+
+def check_zkp_tools() -> dict[str, tuple[bool, str]]:
+    """Check availability and version information of required ZKP tools."""
+    tools: dict[str, tuple[bool, str]] = {}
+
+    tool_checks = {
+        "rust": ["rustc", "--version"],
+        "circom": ["circom", "--version"],
+        "snarkjs": ["snarkjs", "--version"],
+        "nodejs": ["node", "--version"],
+    }
+
+    for tool_name, cmd in tool_checks.items():
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+            if result.returncode == 0:
+                tools[tool_name] = (True, result.stdout.strip())
+            else:
+                tools[tool_name] = (False, "Installation failed")
+        except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+            tools[tool_name] = (False, "Not found")
+
+    return tools
+
+
+@click.command()
+def check_zkp() -> None:
+    """Check ZKP tools installation and versions."""
+    console = Console()
+
+    with console.status("Checking ZKP tools..."):
+        tools = check_zkp_tools()
+
+    table = Table(title="ZKP Tools Status", show_header=True)
+    table.add_column("Tool", style="bold")
+    table.add_column("Status", justify="center")
+    table.add_column("Version/Info", style="dim")
+
+    for tool_name, (available, version_info) in tools.items():
+        if available:
+            status = "[green]✓ Available[/green]"
+            table.add_row(tool_name.title(), status, version_info)
+        else:
+            status = "[red]✗ Missing[/red]"
+            table.add_row(tool_name.title(), status, version_info)
+
+    console.print(table)
+
+    required_tools = ["rust", "circom", "snarkjs", "nodejs"]
+    missing_tools = [
+        tool for tool in required_tools if not tools.get(tool, (False, ""))[0]
+    ]
+
+    if missing_tools:
+        console.print("\n[yellow]⚠️ Missing required ZKP tools:[/yellow]")
+        for tool in missing_tools:
+            console.print(f"  • {tool.title()}")
+
+        console.print("\n[blue]Installation instructions:[/blue]")
+        console.print(
+            "1. Install Rust: curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh"
+        )
+        console.print("2. Install Node.js: https://nodejs.org/")
+        console.print("3. Install Circom: cargo install circom")
+        console.print("4. Install SnarkJS: npm install -g snarkjs")
+
+        sys.exit(1)
+
+    console.print("\n[green]✅ All ZKP tools are properly installed![/green]")

{secure_fl-2026.2.20.dev5 → secure_fl-2026.2.22.dev1}/src/secure_fl/federation/__init__.py

@@ -9,8 +9,8 @@ algorithm with zero-knowledge proof integration.
 
 from .aggregation import FedJSCMAggregator
 from .client import SecureFlowerClient
-from .client import create_client
-from .client import start_client
+from .client_runtime import create_client
+from .client_runtime import start_client
 from .server import SecureFlowerServer
 from .server import SecureFlowerStrategy
 from .server import create_server_strategy