plain 0.68.0__py3-none-any.whl → 0.101.2__py3-none-any.whl

plain/cli/scaffold.py

@@ -7,13 +7,8 @@ import plain.runtime
 
 @click.command()
 @click.argument("package_name")
-def create(package_name):
-    """
-    Create a new local package.
-
-    The PACKAGE_NAME is typically a plural noun, like "users" or "posts",
-    where you might create a "User" or "Post" model inside of the package.
-    """
+def create(package_name: str) -> None:
+    """Create a new local package"""
     package_dir = plain.runtime.APP_PATH / package_name
     package_dir.mkdir(exist_ok=True)
 

plain/cli/server.py

@@ -0,0 +1,153 @@
+import os
+
+import click
+
+from plain.cli.runtime import without_runtime_setup
+
+
+def parse_workers(ctx: click.Context, param: click.Parameter, value: str) -> int:
+    """Parse workers value - accepts int or 'auto' for CPU count."""
+    if value == "auto":
+        return os.cpu_count() or 1
+    return int(value)
+
+
+@without_runtime_setup
+@click.command()
+@click.option(
+    "--bind",
+    "-b",
+    multiple=True,
+    default=["127.0.0.1:8000"],
+    help="Address to bind to (HOST:PORT, can be used multiple times)",
+)
+@click.option(
+    "--threads",
+    type=int,
+    default=1,
+    help="Number of threads per worker",
+    show_default=True,
+)
+@click.option(
+    "--workers",
+    "-w",
+    type=str,
+    default="1",
+    envvar="WEB_CONCURRENCY",
+    callback=parse_workers,
+    help="Number of worker processes (or 'auto' for CPU count)",
+    show_default=True,
+)
+@click.option(
+    "--timeout",
+    "-t",
+    type=int,
+    default=30,
+    help="Worker timeout in seconds",
+    show_default=True,
+)
+@click.option(
+    "--certfile",
+    type=click.Path(exists=True),
+    help="SSL certificate file",
+)
+@click.option(
+    "--keyfile",
+    type=click.Path(exists=True),
+    help="SSL key file",
+)
+@click.option(
+    "--log-level",
+    default="info",
+    type=click.Choice(["debug", "info", "warning", "error", "critical"]),
+    help="Logging level",
+    show_default=True,
+)
+@click.option(
+    "--reload",
+    is_flag=True,
+    help="Restart workers when code changes (dev only)",
+)
+@click.option(
+    "--access-log",
+    default="-",
+    help="Access log file (use '-' for stdout)",
+    show_default=True,
+)
+@click.option(
+    "--error-log",
+    default="-",
+    help="Error log file (use '-' for stderr)",
+    show_default=True,
+)
+@click.option(
+    "--log-format",
+    default="%(asctime)s [%(process)d] [%(levelname)s] %(message)s",
+    help="Log format string (applies to both error and access logs)",
+    show_default=True,
+)
+@click.option(
+    "--access-log-format",
+    help="Access log format string (HTTP request details)",
+    default='%(h)s %(l)s %(u)s %(t)s "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"',
+    show_default=True,
+)
+@click.option(
+    "--max-requests",
+    type=int,
+    default=0,
+    help="Max requests before worker restart (0=disabled)",
+    show_default=True,
+)
+@click.option(
+    "--pidfile",
+    type=click.Path(),
+    help="PID file path",
+)
+def server(
+    bind: tuple[str, ...],
+    threads: int,
+    workers: int,
+    timeout: int,
+    certfile: str | None,
+    keyfile: str | None,
+    log_level: str,
+    reload: bool,
+    access_log: str,
+    error_log: str,
+    log_format: str,
+    access_log_format: str,
+    max_requests: int,
+    pidfile: str | None,
+) -> None:
+    """Production-ready WSGI server"""
+    from plain.runtime import settings
+
+    # Show settings loaded from environment
+    if env_settings := settings.get_env_settings():
+        click.secho("Settings from env:", dim=True)
+        for name, defn in env_settings:
+            click.secho(
+                f"  {defn.env_var_name} -> {name}={defn.display_value()}", dim=True
+            )
+
+    from plain.server import ServerApplication
+    from plain.server.config import Config
+
+    cfg = Config(
+        bind=list(bind),
+        threads=threads,
+        workers=workers,
+        timeout=timeout,
+        max_requests=max_requests,
+        reload=reload,
+        pidfile=pidfile,
+        certfile=certfile,
+        keyfile=keyfile,
+        loglevel=log_level,
+        accesslog=access_log,
+        errorlog=error_log,
+        log_format=log_format,
+        access_log_format=access_log_format,
+    )
+    ServerApplication(cfg=cfg).run()

plain/cli/settings.py

@@ -3,58 +3,62 @@ import click
 import plain.runtime
 
 
-@click.command()
+@click.group()
+def settings() -> None:
+    """View and inspect settings"""
+    pass
+
+
+@settings.command()
 @click.argument("setting_name")
-def setting(setting_name):
-    """Print the value of a setting at runtime"""
+def get(setting_name: str) -> None:
+    """Get the value of a specific setting"""
     try:
-        setting = getattr(plain.runtime.settings, setting_name)
-        click.echo(setting)
+        value = getattr(plain.runtime.settings, setting_name)
+        click.echo(value)
     except AttributeError:
         click.secho(f'Setting "{setting_name}" not found', fg="red")
 
 
-# @plain_cli.command()
-# @click.option("--filter", "-f", "name_filter", help="Filter settings by name")
-# @click.option("--overridden", is_flag=True, help="Only show overridden settings")
-# def settings(name_filter, overridden):
-#     """Print Plain settings"""
-#     table = Table(box=box.MINIMAL)
-#     table.add_column("Setting")
-#     table.add_column("Default value")
-#     table.add_column("App value")
-#     table.add_column("Type")
-#     table.add_column("Module")
-
-#     for setting in dir(settings):
-#         if setting.isupper():
-#             if name_filter and name_filter.upper() not in setting:
-#                 continue
-
-#             is_overridden = settings.is_overridden(setting)
-
-#             if overridden and not is_overridden:
-#                 continue
-
-#             default_setting = settings._default_settings.get(setting)
-#             if default_setting:
-#                 default_value = default_setting.value
-#                 annotation = default_setting.annotation
-#                 module = default_setting.module
-#             else:
-#                 default_value = ""
-#                 annotation = ""
-#                 module = ""
-
-#             table.add_row(
-#                 setting,
-#                 Pretty(default_value) if default_value else "",
-#                 Pretty(getattr(settings, setting))
-#                 if is_overridden
-#                 else Text("<Default>", style="italic dim"),
-#                 Pretty(annotation) if annotation else "",
-#                 str(module.__name__) if module else "",
-#             )
-
-#     console = Console()
-#     console.print(table)
+@settings.command(name="list")
+def list_settings() -> None:
+    """List all settings with their sources"""
+    if not (items := plain.runtime.settings.get_settings()):
+        click.echo("No settings configured.")
+        return
+
+    # Calculate column widths
+    max_name = max(len(name) for name, _ in items)
+    max_source = max(len(defn.env_var_name or defn.source) for _, defn in items)
+
+    # Print header
+    header = (
+        click.style(f"{'Setting':<{max_name}}", bold=True)
+        + "  "
+        + click.style(f"{'Source':<{max_source}}", bold=True)
+        + "  "
+        + click.style("Value", bold=True)
+    )
+    click.echo(header)
+    click.secho("-" * (max_name + max_source + 10), dim=True)
+
+    # Print each setting
+    for name, defn in items:
+        source_info = defn.env_var_name or defn.source
+        value = defn.display_value()
+
+        # Style based on source
+        if defn.source == "env":
+            source_styled = click.style(f"{source_info:<{max_source}}", fg="green")
+        elif defn.source == "explicit":
+            source_styled = click.style(f"{source_info:<{max_source}}", fg="cyan")
+        else:
+            source_styled = click.style(f"{source_info:<{max_source}}", dim=True)
+
+        # Style secret values
+        if defn.is_secret:
+            value_styled = click.style(value, dim=True)
+        else:
+            value_styled = value
+
+        click.echo(f"{name:<{max_name}}  {source_styled}  {value_styled}")

plain/cli/shell.py

@@ -1,10 +1,15 @@
+from __future__ import annotations
+
 import os
 import subprocess
 import sys
 
 import click
 
+from plain.cli.runtime import common_command
+
 
+@common_command
 @click.command()
 @click.option(
     "-i",
@@ -17,11 +22,8 @@ import click
     "--command",
     help="Execute the given command and exit.",
 )
-def shell(interface, command):
-    """
-    Runs a Python interactive interpreter. Tries to use IPython or
-    bpython, if one of them is available.
-    """
+def shell(interface: str | None, command: str | None) -> None:
+    """Interactive Python shell"""
 
     if command:
         # Execute the command and exit
@@ -32,13 +34,14 @@ def shell(interface, command):
             sys.exit(result.returncode)
         return
 
+    interface_list: list[str]
     if interface:
-        interface = [interface]
+        interface_list = [interface]
     else:
 
-        def get_default_interface():
+        def get_default_interface() -> list[str]:
             try:
-                import IPython  # noqa
+                import IPython  # noqa: F401  # type: ignore[import-not-found]
 
                 return ["python", "-m", "IPython"]
             except ImportError:
@@ -46,10 +49,10 @@ def shell(interface, command):
 
             return ["python"]
 
-        interface = get_default_interface()
+        interface_list = get_default_interface()
 
     result = subprocess.run(
-        interface,
+        interface_list,
         env={
             "PYTHONSTARTUP": os.path.join(os.path.dirname(__file__), "startup.py"),
             **os.environ,
@@ -61,8 +64,8 @@ def shell(interface, command):
 
 @click.command()
 @click.argument("script", nargs=1, type=click.Path(exists=True))
-def run(script):
-    """Run a Python script in the context of your app"""
+def run(script: str) -> None:
+    """Execute Python scripts with app context"""
     before_script = "import plain.runtime; plain.runtime.setup()"
     command = f"{before_script}; exec(open('{script}').read())"
     result = subprocess.run(["python", "-c", command])

plain/cli/startup.py

@@ -3,19 +3,19 @@ import plain.runtime
 plain.runtime.setup()
 
 
-def print_bold(s):
+def print_bold(s: str) -> None:
     print("\033[1m", end="")
     print(s)
     print("\033[0m", end="")
 
 
-def print_italic(s):
+def print_italic(s: str) -> None:
     print("\x1b[3m", end="")
     print(s)
     print("\x1b[0m", end="")
 
 
-def print_dim(s):
+def print_dim(s: str) -> None:
     print("\x1b[2m", end="")
     print(s)
     print("\x1b[0m", end="")
@@ -29,12 +29,13 @@ if shell_import := plain.runtime.settings.SHELL_IMPORT:
     print_bold(f"Importing {shell_import}")
     module = import_module(shell_import)
 
-    with open(module.__file__) as f:
-        contents = f.read()
-        for line in contents.splitlines():
-            print_dim(f"{line}")
+    if module.__file__:
+        with open(module.__file__) as f:
+            contents = f.read()
+            for line in contents.splitlines():
+                print_dim(f"{line}")
 
-    print()
+        print()
 
     # Emulate `from module import *`
     names = getattr(

plain/cli/upgrade.py

@@ -5,68 +5,42 @@ from pathlib import Path
 
 import click
 
-from .agent.prompt import prompt_agent
+from .runtime import without_runtime_setup
 
 LOCK_FILE = Path("uv.lock")
 
 
+@without_runtime_setup
 @click.command()
 @click.argument("packages", nargs=-1)
-@click.option(
-    "--diff", is_flag=True, help="Read versions from unstaged uv.lock changes"
-)
-@click.option(
-    "--agent-command",
-    envvar="PLAIN_AGENT_COMMAND",
-    help="Run command with generated prompt",
-)
-@click.option(
-    "--print",
-    "print_only",
-    is_flag=True,
-    help="Print the prompt without running the agent",
-)
-def upgrade(
-    packages: tuple[str, ...],
-    diff: bool,
-    agent_command: str | None = None,
-    print_only: bool = False,
-) -> None:
-    """Upgrade Plain packages with the help of an agent."""
+def upgrade(packages: tuple[str, ...]) -> None:
+    """Upgrade Plain packages"""
     if not packages:
-        click.secho("Getting installed packages...", bold=True, err=True)
+        click.secho("Getting installed packages...", bold=True)
         packages = tuple(sorted(get_installed_plain_packages()))
         for pkg in packages:
-            click.secho(f"- {click.style(pkg, fg='yellow')}", err=True)
-        click.echo(err=True)
+            click.secho(f"- {click.style(pkg, fg='yellow')}")
+        click.echo()
 
     if not packages:
         raise click.UsageError("No plain packages found or specified.")
 
-    if diff:
-        before_after = versions_from_diff(packages)
-    else:
-        before_after = upgrade_packages(packages)
+    before_after = upgrade_packages(packages)
 
-    # Remove all packages that were not upgraded
-    before_after = {
+    # Show what was upgraded
+    upgraded = {
         pkg: versions
         for pkg, versions in before_after.items()
         if versions[0] != versions[1]
     }
 
-    if not before_after:
-        click.secho(
-            "No packages were upgraded. If uv.lock has already been updated, use --diff instead.",
-            fg="green",
-            err=True,
-        )
+    if not upgraded:
+        click.secho("All packages already at latest version.", fg="green")
         return
 
-    prompt = build_prompt(before_after)
-    success = prompt_agent(prompt, agent_command, print_only)
-    if not success:
-        raise click.Abort()
+    click.secho("Upgraded packages:", bold=True)
+    for pkg, (before, after) in upgraded.items():
+        click.echo(f"  {pkg}: {before} -> {after}")
 
 
 def get_installed_plain_packages() -> list[str]:
@@ -90,29 +64,6 @@ def parse_lock_versions(lock_text: str, packages: set[str]) -> dict[str, str]:
     return versions
 
 
-def versions_from_diff(
-    packages: tuple[str, ...],
-) -> dict[str, tuple[str | None, str | None]]:
-    result = subprocess.run(
-        ["git", "status", "--porcelain", str(LOCK_FILE)], capture_output=True, text=True
-    )
-    if not result.stdout.strip():
-        raise click.UsageError(
-            "--diff specified but uv.lock has no uncommitted changes"
-        )
-
-    prev_text = subprocess.run(
-        ["git", "show", f"HEAD:{LOCK_FILE}"], capture_output=True, text=True, check=True
-    ).stdout
-    current_text = LOCK_FILE.read_text()
-
-    packages_set = set(packages)
-    before = parse_lock_versions(prev_text, packages_set)
-    after = parse_lock_versions(current_text, packages_set)
-
-    return {pkg: (before.get(pkg), after.get(pkg)) for pkg in packages}
-
-
 def upgrade_packages(
     packages: tuple[str, ...],
 ) -> dict[str, tuple[str | None, str | None]]:
@@ -122,47 +73,9 @@ def upgrade_packages(
     for pkg in packages:
         upgrade_args.extend(["--upgrade-package", pkg])
 
-    click.secho("Upgrading with uv sync...", bold=True, err=True)
+    click.secho("Upgrading with uv sync...", bold=True)
     subprocess.run(upgrade_args, check=True, stdout=sys.stderr)
-    click.echo(err=True)
+    click.echo()
 
     after = parse_lock_versions(LOCK_FILE.read_text(), set(packages))
     return {pkg: (before.get(pkg), after.get(pkg)) for pkg in packages}
-
-
-def build_prompt(before_after: dict[str, tuple[str | None, str | None]]) -> str:
-    lines = [
-        "These packages have been updated and may require additional changes to the code:",
-        "",
-    ]
-    for pkg, (before, after) in before_after.items():
-        lines.append(f"- {pkg}: {before} -> {after}")
-
-    lines.extend(
-        [
-            "",
-            "## Instructions",
-            "",
-            "1. **Process each package systematically:**",
-            "   - For each package, run: `uv run plain-changelog {package} --from {before} --to {after}`",
-            "   - Read the 'Upgrade instructions' section carefully",
-            "   - If it says 'No changes required', skip to the next package",
-            "   - Apply any required code changes as specified",
-            "",
-            "2. **Important guidelines:**",
-            "   - Process ALL packages before testing or validation",
-            "   - After all packages are updated, run `uv run plain fix --unsafe-fixes` and `uv run plain pre-commit` to check results",
-            "   - DO NOT commit any changes",
-            "   - Keep code changes minimal and focused - avoid unnecessary comments",
-            "",
-            "3. **Available tools:**",
-            "   - Python shell: `uv run python`",
-            "   - If you have a subagents feature and there are more than three packages here, use subagents",
-            "",
-            "4. **Workflow:**",
-            "   - Review changelog for each package → Apply changes → Move to next package",
-            "   - Only after all packages: run pre-commit checks",
-            "   - Report any issues or conflicts encountered",
-        ]
-    )
-    return "\n".join(lines)

plain/cli/urls.py

@@ -1,16 +1,19 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+
 import click
 
 
 @click.group()
-def urls():
-    """URL related commands"""
-    pass
+def urls() -> None:
+    """URL configuration commands"""
 
 
 @urls.command("list")
 @click.option("--flat", is_flag=True, help="List all URLs in a flat list")
-def list_urls(flat):
-    """Print all URL patterns under settings.URLS_ROUTER"""
+def list_urls(flat: bool) -> None:
+    """List all URL patterns"""
     from plain.runtime import settings
     from plain.urls import URLResolver, get_resolver
 
@@ -20,7 +23,9 @@ def list_urls(flat):
     resolver = get_resolver(settings.URLS_ROUTER)
     if flat:
 
-        def flat_list(patterns, prefix="", curr_ns=""):
+        def flat_list(
+            patterns: list, prefix: str = "", curr_ns: str = ""
+        ) -> Iterator[str]:
             for pattern in patterns:
                 full_pattern = f"{prefix}{pattern.pattern}"
                 if isinstance(pattern, URLResolver):
@@ -50,7 +55,7 @@ def list_urls(flat):
             click.echo(p)
     else:
 
-        def print_tree(patterns, prefix="", curr_ns=""):
+        def print_tree(patterns: list, prefix: str = "", curr_ns: str = "") -> None:
             count = len(patterns)
             for idx, pattern in enumerate(patterns):
                 is_last = idx == (count - 1)

plain/cli/utils.py

@@ -4,12 +4,12 @@ from plain.utils.crypto import get_random_string
 
 
 @click.group()
-def utils():
-    pass
+def utils() -> None:
+    """Utility commands"""
 
 
 @utils.command()
-def generate_secret_key():
+def generate_secret_key() -> None:
     """Generate a new secret key"""
     new_secret_key = get_random_string(50)
     click.echo(new_secret_key)