beamflow-cli 0.3.0__py3-none-any.whl

beamflow/core/config.py

@@ -0,0 +1,81 @@
+from typing import List
+from pydantic import Field
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any
+import yaml
+import keyring
+from pydantic import BaseModel
+
+BEAMFLOW_DIR = Path.home() / ".beamflow"
+GLOBAL_CONFIG_FILE = BEAMFLOW_DIR / "config.yaml"
+PROJECT_CONFIG_FILE = ".beamflow"
+
+SERVICE_NAME = "beamflow"
+TOKEN_KEY = "access_token"
+
+class GlobalConfig(BaseModel):
+    api_url: str = "http://localhost:8080"  # Default to local dev
+
+class EnvironmentMode(BaseModel):
+    name: str
+    managed: bool = False
+    options: Dict[str, str] = Field(default_factory=dict)
+
+class ProjectConfig(BaseModel):
+    project_name: Optional[str] = None
+    project_id: Optional[str] = None
+    tenant_id: Optional[str] = None
+    user_email: Optional[str] = None
+    environments: List[EnvironmentMode] = Field(default_factory=list)
+
+def load_global_config() -> GlobalConfig:
+    if not GLOBAL_CONFIG_FILE.exists():
+        return GlobalConfig()
+    
+    try:
+        with open(GLOBAL_CONFIG_FILE, "r") as f:
+            data = yaml.safe_load(f) or {}
+            return GlobalConfig(**data)
+    except Exception:
+        return GlobalConfig()
+
+def save_global_config(config: GlobalConfig):
+    BEAMFLOW_DIR.mkdir(parents=True, exist_ok=True)
+    with open(GLOBAL_CONFIG_FILE, "w") as f:
+        yaml.safe_dump(config.model_dump(), f)
+
+def get_access_token() -> Optional[str]:
+    return keyring.get_password(SERVICE_NAME, TOKEN_KEY)
+
+def set_access_token(token: str):
+    keyring.set_password(SERVICE_NAME, TOKEN_KEY, token)
+
+def delete_access_token():
+    try:
+        keyring.delete_password(SERVICE_NAME, TOKEN_KEY)
+    except keyring.errors.PasswordDeleteError:
+        pass
+
+def load_project_config() -> Optional[ProjectConfig]:
+    path = Path(PROJECT_CONFIG_FILE)
+    if not path.exists():
+        return None
+    
+    try:
+        with open(path, "r") as f:
+            data = yaml.safe_load(f) or {}
+            return ProjectConfig(**data)
+    except Exception:
+        return None
+
+def save_project_config(config: ProjectConfig):
+    with open(PROJECT_CONFIG_FILE, "w") as f:
+        yaml.safe_dump(config.model_dump(), f)
+
+# Legacy aliases for compatibility if needed, though we should update callers
+def load_config() -> GlobalConfig:
+    return load_global_config()
+
+def save_config(config: GlobalConfig):
+    save_global_config(config)

beamflow/core/docker_utils.py

@@ -0,0 +1,33 @@
+import shutil
+import subprocess
+from typing import Tuple, Optional
+
+def check_docker_binary() -> bool:
+    return shutil.which("docker") is not None
+
+def check_docker_compose_binary() -> bool:
+    # Check for 'docker compose' (V2) or 'docker-compose' (V1)
+    if shutil.which("docker-compose"):
+        return True
+    
+    # Check if 'docker compose' works
+    try:
+        subprocess.run(["docker", "compose", "version"], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def check_docker_daemon() -> Tuple[bool, Optional[str]]:
+    """Returns (is_running, error_message)"""
+    try:
+        subprocess.run(["docker", "info"], capture_output=True, check=True)
+        return True, None
+    except subprocess.CalledProcessError as e:
+        return False, e.stderr.decode().strip()
+    except FileNotFoundError:
+        return False, "Docker binary not found"
+
+def get_docker_compose_cmd() -> list:
+    if shutil.which("docker-compose"):
+        return ["docker-compose"]
+    return ["docker", "compose"]

beamflow/main.py

@@ -0,0 +1,227 @@
+import typer
+import click
+from typing import Optional
+from .commands import auth as auth_cmds
+from .commands import project as project_cmds
+from .commands import build as build_cmds
+from .commands import deploy as deploy_cmds
+from .commands import run as run_cmds
+from rich.console import Console
+console = Console()
+
+app = typer.Typer(
+    name="beamflow",
+    help="""
+# 🚀 Beamflow CLI
+Manage your Beamflow projects and deployments with ease.
+
+## 🛠 Usage
+Run commands below to initialize, build, and deploy your integrations.
+""",
+    add_completion=False,
+    no_args_is_help=True,
+    rich_markup_mode="rich"
+)
+
+env_app = typer.Typer(
+    name="env",
+    help="Manage environments",
+    no_args_is_help=True,
+    rich_markup_mode="rich"
+)
+app.add_typer(env_app, name="env")
+
+@app.command()
+def help(ctx: typer.Context):
+    """
+    Show help information for all commands.
+    """
+    console.print(ctx.parent.get_help()) if ctx.parent else console.print(ctx.get_help())
+
+# Shortcuts / Top-level commands
+@app.command()
+def login(
+    username: Optional[str] = typer.Option(None, "--username", "-u", help="Username for manual login"),
+    password: Optional[str] = typer.Option(None, "--password", "-p", help="Password for manual login")
+):
+    """Log in to the Beamflow Managed Platform."""
+    auth_cmds.login(username=username, password=password)
+
+@app.command()
+def init(
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Project name"),
+    fix: bool = typer.Option(False, "--fix", help="Repair missing components"),
+    force: bool = typer.Option(False, "--force", help="Force overwrite existing files")
+):
+    """
+    [bold green]Initialize[/bold green] or [bold yellow]repair[/bold yellow] a Beamflow project.
+    
+    This command sets up the local structure, creates the `.beamflow` config, 
+    and lets you configure your first environments.
+    """
+    project_cmds.init(name=name, fix=fix, force=force)
+
+@app.command()
+def check():
+    """Inspect the current project structure."""
+    project_cmds.check()
+
+@env_app.command("add")
+def env_add(
+    env_name: Optional[str] = typer.Argument(None, help="Environment name to add"),
+    force: bool = typer.Option(False, "--force", help="Force overwrite existing files")
+):
+    """
+    [bold blue]Add a new environment[/bold blue] to your project.
+    
+    Choose between Local, Dev, Prod, or Custom. It will automatically filter 
+    out existing environments and scaffold necessary files.
+    """
+    project_cmds.env_add(env_name=env_name, force=force)
+
+@env_app.command("del")
+def env_del(
+    env_name: str = typer.Argument(..., help="Environment name to delete")
+):
+    """
+    [bold red]Delete an environment[/bold red] from your project.
+    
+    Requires confirmation before removal.
+    """
+    project_cmds.env_delete(env_name=env_name)
+
+@app.command()
+def run(
+    ctx: typer.Context,
+    env: str = typer.Argument("local", help="Environment to run (default: local)"),
+    build: bool = typer.Option(False, "--build", help="Build images before starting"),
+    detach: bool = typer.Option(False, "--detach", "-d", help="Run in background"),
+    logs: bool = typer.Option(False, "--logs", help="Follow logs (useful with --detach)")
+):
+    """
+    [bold magenta]Run[/bold magenta] the project locally using Docker Compose.
+    
+    Defaults to the 'local' environment.
+    
+    [yellow]Note:[/yellow] To run a specific environment, use: [bold]beamflow run <env_name>[/bold]
+    """
+    from .core.config import load_project_config
+    from rich.prompt import Confirm
+
+    if ctx.get_parameter_source("env") == click.core.ParameterSource.DEFAULT:
+        console.print(f"[dim]Env argument not specified... using [bold]{env}[/bold] as default[/dim]")
+
+    project_config = load_project_config()
+    if project_config:
+        env_mode = next((e for e in project_config.environments if e.name == env), None)
+        if not env_mode:
+            if env == "local":
+                if Confirm.ask(f"Environment '{env}' not found. Would you like to set it up now?"):
+                    project_cmds.add_environment(project_config, env_name=env)
+                else:
+                    console.print(f"[red]Aborting. Run 'beamflow env add' to create it manually.[/red]")
+                    raise typer.Exit(code=1)
+            else:
+                console.print(f"[red]Environment '{env}' not found.[/red]")
+                raise typer.Exit(code=1)
+
+    run_cmds.run(env=env, build=build, detach=detach, logs=logs)
+
+@app.command()
+def build(
+    ctx: typer.Context,
+    env: str = typer.Argument("local", help="Environment to build (default: local)"),
+    tag: str = typer.Option("latest", "--tag", "-t", help="Tag for the image")
+):
+    """
+    [bold yellow]Build[/bold yellow] project artifacts/images.
+    
+    Defaults to the 'local' environment.
+    
+    [yellow]Note:[/yellow] To build for a specific environment, use: [bold]beamflow build <env_name>[/bold]
+    """
+    if ctx.get_parameter_source("env") == click.core.ParameterSource.DEFAULT:
+        console.print(f"[dim]Env argument not specified... using [bold]{env}[/bold] as default[/dim]")
+
+    from .core.config import load_project_config
+    from rich.prompt import Confirm
+
+    project_config = load_project_config()
+    if project_config:
+        env_mode = next((e for e in project_config.environments if e.name == env), None)
+        if not env_mode:
+            if env == "local":
+                if Confirm.ask(f"Environment '{env}' not found. Would you like to set it up now?"):
+                    project_cmds.add_environment(project_config, env_name=env)
+                else:
+                    console.print(f"[red]Aborting. Run 'beamflow env add' to create it manually.[/red]")
+                    raise typer.Exit(code=1)
+            else:
+                console.print(f"[red]Environment '{env}' not found.[/red]")
+                raise typer.Exit(code=1)
+
+    build_cmds.build(env=env, tag=tag)
+
+@app.command()
+def deploy(
+    ctx: typer.Context,
+    env: str = typer.Argument("prod", help="Environment to deploy to (default: prod)"),
+    artifact: Optional[str] = typer.Option(None, "--artifact", "-a", help="Artifact ID to deploy")
+):
+    """
+    [bold cyan]Deploy[/bold cyan] your project to the Beamflow Managed Platform.
+    
+    Defaults to the 'prod' environment. If 'prod' is missing, it will prompt you to set it up.
+    
+    [yellow]Note:[/yellow] To deploy to a specific environment, use: [bold]beamflow deploy <env_name>[/bold]
+    """
+    from .core.config import load_project_config
+    from .commands.project import add_environment
+    from rich.prompt import Confirm
+
+    if ctx.get_parameter_source("env") == click.core.ParameterSource.DEFAULT:
+        console.print(f"[dim]Env argument not specified... using [bold]{env}[/bold] as default[/dim]")
+
+    project_config = load_project_config()
+    if not project_config:
+        console.print("[red]No .beamflow found. Please run 'beamflow init' first.[/red]")
+        raise typer.Exit(code=1)
+
+    # Find the requested environment
+    env_mode = next((e for e in project_config.environments if e.name == env), None)
+
+    if not env_mode:
+        if env == "prod":
+            if Confirm.ask(f"Environment '{env}' not found. Would you like to set it up now?"):
+                # We need to pass the actual project_config object to add_environment
+                # But project_cmds is a module, we should be careful about cyclic imports or just use it.
+                project_cmds.add_environment(project_config, env_name=env)
+                # Reload or refresh check
+                project_config = load_project_config()
+                env_mode = next((e for e in project_config.environments if e.name == env), None)
+                if not env_mode:
+                    console.print(f"[red]Environment '{env}' was not created. Aborting.[/red]")
+                    raise typer.Exit(code=1)
+            else:
+                console.print(f"[red]Aborting. Use 'beamflow env add' to create environments manually.[/red]")
+                raise typer.Exit(code=1)
+        else:
+            console.print(f"[red]Environment '{env}' not found.[/red]")
+            console.print(f"[yellow]Available environments: {', '.join(e.name for e in project_config.environments)}[/yellow]")
+            console.print(f"To deploy to a specific environment, use: [bold]beamflow deploy <env_name>[/bold]")
+            raise typer.Exit(code=1)
+
+    deploy_cmds.deploy(env=env, artifact=artifact)
+
+@app.command()
+def whoami():
+    """Show current login status."""
+    auth_cmds.whoami()
+
+@app.command()
+def logout():
+    """Log out from the platform."""
+    auth_cmds.logout()
+
+if __name__ == "__main__":
+    app()

beamflow/templates/_.beamflow

@@ -0,0 +1,4 @@
+project_name: {project_name}
+environments:
+  - name: dev
+    managed: false

beamflow/templates/_.dockerignore

@@ -0,0 +1,9 @@
+.git
+.venv
+__pycache__
+.pytest_cache
+*.pyc
+.beamflow
+pyproject.toml
+README.md
+tests

beamflow/templates/_README.md

@@ -0,0 +1,28 @@
+# {project_name}
+
+Beamflow application generated for {project_name}.
+
+## Local Development
+
+1. Install dependencies:
+   ```bash
+   pip install -e .
+   ```
+
+2. Run local environment:
+   ```bash
+   beamflow run dev
+   ```
+
+3. Build images:
+   ```bash
+   beamflow build dev
+   ```
+
+## Structure
+
+- `src/api`: FastAPI routes and webhooks
+- `src/worker`: Background tasks and feed consumers
+- `src/shared`: Shared models, clients, and tasks
+- `config`: Environment-specific configuration
+- `deployment`: Docker Compose and Dockerfiles

beamflow/templates/_api_main.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+from fastapi import Request
+from beamflow_lib.config.env_loader import load_config_dir
+from beamflow_runtime.ingress.app import create_fastapi_app
+
+# Load configuration relative to this file
+config = load_config_dir("config", environment="{env}")
+
+# Create FastAPI app
+app = create_fastapi_app(config, auto_import=[Path(__file__).parent / "src" / "api" / "routes" / "webhooks.py"])
+
+@app.get("/health")
+async def health():
+    """Simple status webhook."""
+    return {"status": "ok", "service": "{project_name}-api"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

beamflow/templates/_config/[env]/(backend-asyncio)/backend.yaml

@@ -0,0 +1,4 @@
+backend:
+  type: asyncio
+webhooks:
+  prefix: /webhooks

beamflow/templates/_config/[env]/(backend-dramatiq)/backend.yaml

@@ -0,0 +1,8 @@
+backend:
+  type: dramatiq
+  dramatiq:
+    redis_url: redis://redis:6380/0
+webhooks:
+  prefix: /webhooks
+
+

beamflow/templates/_config/[env]/(backend-managed)/backend.yaml

@@ -0,0 +1,6 @@
+backend:
+  type: managed
+webhooks:
+  prefix: /webhooks
+
+

beamflow/templates/_config/[env]/_backend.yaml

@@ -0,0 +1,4 @@
+# Environment-specific overrides for backend
+backend:
+  # The type of backend can be 'dramatiq', 'async_backend', or 'managed'
+  type: managed | dramatiq | asyncio

beamflow/templates/_config/shared/backend.yaml

@@ -0,0 +1,4 @@
+webhooks:
+  prefix: /webhooks
+
+

beamflow/templates/_deployment/[env]/(backend-dramatiq)/docker-compose.yaml

@@ -0,0 +1,34 @@
+version: '3.8'
+services:
+  api:
+    build:
+      context: ../..
+      dockerfile: deployment/{env}/api.Dockerfile
+    image: beamflow-{project_name}-api:latest
+    ports:
+      - "8000:8000"
+    environment:
+      - REDIS_URL=redis://redis:6379/0
+      - ENVIRONMENT={env}
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    depends_on:
+      - redis
+
+  worker:
+    build:
+      context: ../..
+      dockerfile: deployment/{env}/worker.Dockerfile
+    image: beamflow-{project_name}-worker:latest
+    environment:
+      - REDIS_URL=redis://redis:6379/0
+      - ENVIRONMENT={env}
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    depends_on:
+      - redis
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"

beamflow/templates/_deployment/[env]/.env

@@ -0,0 +1,3 @@
+# Specific Envirment Variables for this enviroment belong here
+# i.e.
+# FOO_SEVICE_BASE_URL=dev/prod.rest.domain.com/v1

beamflow/templates/_deployment/shared/.env

@@ -0,0 +1,5 @@
+# Any ENV variables that should have the same value for any enviroment bellong here
+# i.e.
+# TEST_ENV_VAR=demo-value
+# DEMO_CLIENT_ID=123
+# DEMO_CLIENT_SECRET=456

beamflow/templates/_deployment/shared/api.Dockerfile

@@ -0,0 +1,10 @@
+# API Dockerfile for {project_name}
+FROM beamflow/beamflow-base:latest
+
+WORKDIR /app
+COPY . .
+
+RUN rm -rf src/worker
+EXPOSE 8000
+ENV PYTHONPATH=/app/src:/app
+CMD ["python", "api_main.py"]

beamflow/templates/_deployment/shared/clients/demoClient.yaml

@@ -0,0 +1,39 @@
+client_id: demoClient
+baseUrl: https://jsonplaceholder.typicode.com
+timeout: 10
+handleRedirects: false
+# Authentication configuration (OAuth2 example)
+auth:
+  type: oauth2
+  client_id: "${DEMO_CLIENT_ID}"
+  client_secret: "${DEMO_CLIENT_SECRET}"
+  token_url: "https://auth.example.com/token"
+  refresh_token: null
+  scopes: []
+  extra_params: {}
+
+# Authentication Alternatives (Commented out)
+# ------------------------------------------
+# Basic Auth:
+# auth:
+#   type: basic
+#   username: "${DEMO_USERNAME}"
+#   password: "${DEMO_PASSWORD}"
+#
+# API Key Auth:
+# auth:
+#   type: api_key
+#   key: "X-API-Key"
+#   value: "${DEMO_API_KEY}"
+#   in: header # Supported values: header, query
+
+# Retry configuration
+retry:
+  maxRetries: 0
+  whitelist: [] # Keywords in response to retry (e.g., ["rate limit"])
+  blacklist: [] # Keywords in response NOT to retry (e.g., ["400"])
+
+# Extra parameters (e.g., global headers)
+extra:
+  headers:
+    User-Agent: DemoClient/1.0

beamflow/templates/_deployment/shared/worker.Dockerfile

@@ -0,0 +1,9 @@
+# Worker Dockerfile for {project_name}
+FROM beamflow/beamflow-base:latest
+
+WORKDIR /app
+COPY . .
+
+RUN rm -rf src/api
+ENV PYTHONPATH=/app/src:/app
+CMD ["python", "-u", "worker_main.py"]

beamflow/templates/_pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "{project_name}-app"
+version = "0.1.0"
+description = "Beamflow application {project_name}"
+requires-python = ">=3.11"
+
+# Base dependencies (required by both API and Worker)
+dependencies = [
+    "pyyaml>=6.0",
+]
+
+[project.optional-dependencies]
+
+# API-only dependencies
+api = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.23.0",
+]
+
+# Worker-only dependencies
+worker = [
+    "dramatiq[redis]>=1.14.0",
+]
+
+# Development dependencies (optional)
+dev = [
+    "pytest>=7.0",
+    "ipython>=8.0",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+addopts = "-v -s"
+testpaths = ["tests"]
+python_files = "test_*.py"

beamflow/templates/_src/_api/__init__.py

@@ -0,0 +1 @@
+# API package

beamflow/templates/_src/_api/_routes/webhooks.py

@@ -0,0 +1,25 @@
+from beamflow_lib import ingress
+from beamflow_lib import RecordData
+from fastapi import Request
+from beamflow_lib.pipelines.records_feed import RecordsFeed
+
+@ingress.webhook(integration="demo", pipeline="process_user", path="/demo/process_user", method="POST")
+async def process_user_webhook(request: Request):
+    """Webhook that triggers a background worker task."""
+    try:
+        data = await request.json()
+    except Exception:
+        data = {}
+        
+    user_id = data.get("user_id")
+    
+    if not user_id:
+        return {"error": "user_id required"}, 400
+
+    feed = RecordsFeed.get("test_feed")
+    await feed.publish(RecordData(record_id=user_id, record_type="user", data={"user_id": user_id}))
+    
+    return {
+        "status": "submitted",
+        "user_id": user_id
+    }

beamflow/templates/_src/_shared/__init__.py

@@ -0,0 +1 @@
+# Shared package

beamflow/templates/_src/_shared/clients/client.py

@@ -0,0 +1,18 @@
+from typing import List, Optional
+from beamflow_lib.clients import HttpClient, client
+
+@client("DemoClient")
+class DemoClient(HttpClient):
+    """
+    Client for the Demo API.
+    """
+    
+    async def get_users(self) -> List[dict]:
+        response = await self.request("GET", "/users")
+        data = response.json()
+        return data
+    
+    async def get_user(self, user_id: int) -> dict:
+        response = await self.request("GET", f"/users/{{user_id}}")
+        data = response.json()
+        return data

beamflow/templates/_src/_shared/models/models.py

@@ -0,0 +1 @@
+# Shared models for the integration

beamflow/templates/_src/_shared/tasks/sharedTasks.py

@@ -0,0 +1,10 @@
+from beamflow_lib.decorators import integration_task
+from beamflow_clients import get_client
+
+@integration_task(integration="demo", integration_pipeline="adhoc_task")
+async def adhoc_task(data: dict):
+    """
+    Ad-hoc task triggered via webhook.
+    """
+
+    print(f"Running ad-hoc task with data: {data}")

beamflow/templates/_src/_worker/__init__.py

@@ -0,0 +1 @@
+# Worker package

beamflow/templates/_src/_worker/tasks/tasks.py

@@ -0,0 +1,15 @@
+from beamflow_lib.decorators import integration_task
+from beamflow_lib.queue.backend import Schedule
+
+
+
+
+@integration_task(integration="demo", integration_pipeline="demo", default_schedule=Schedule(cron="* * * * *"))
+def demo_task(user_id: int):
+    """
+    Task to process a user by ID.
+    """
+    print(f"Processing user {user_id}...")
+    
+    
+