plain 0.69.0__py3-none-any.whl → 0.70.0__py3-none-any.whl

plain/cli/agent/request.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import json
+from typing import Any
 
 import click
 
@@ -37,7 +40,15 @@ from plain.test import Client
     multiple=True,
     help="Additional headers (format: 'Name: Value')",
 )
-def request(path, method, data, user_id, follow, content_type, headers):
+def request(
+    path: str,
+    method: str,
+    data: str | None,
+    user_id: str | None,
+    follow: bool,
+    content_type: str | None,
+    headers: tuple[str, ...],
+) -> None:
     """Make an HTTP request using the test client against the development database."""
 
     try:
@@ -90,11 +101,11 @@ def request(path, method, data, user_id, follow, content_type, headers):
 
         # Make the request
         method = method.upper()
-        kwargs = {
-            "path": path,
+        kwargs: dict[str, object] = {
             "follow": follow,
-            "headers": header_dict or None,
         }
+        if header_dict:
+            kwargs["headers"] = header_dict
 
         if method in ("POST", "PUT", "PATCH") and data:
             kwargs["data"] = data
@@ -103,21 +114,21 @@ def request(path, method, data, user_id, follow, content_type, headers):
 
         # Call the appropriate client method
         if method == "GET":
-            response = client.get(**kwargs)
+            response = client.get(path, **kwargs)
         elif method == "POST":
-            response = client.post(**kwargs)
+            response = client.post(path, **kwargs)
         elif method == "PUT":
-            response = client.put(**kwargs)
+            response = client.put(path, **kwargs)
         elif method == "PATCH":
-            response = client.patch(**kwargs)
+            response = client.patch(path, **kwargs)
         elif method == "DELETE":
-            response = client.delete(**kwargs)
+            response = client.delete(path, **kwargs)
         elif method == "HEAD":
-            response = client.head(**kwargs)
+            response = client.head(path, **kwargs)
         elif method == "OPTIONS":
-            response = client.options(**kwargs)
+            response = client.options(path, **kwargs)
         elif method == "TRACE":
-            response = client.trace(**kwargs)
+            response = client.trace(path, **kwargs)
         else:
             click.secho(f"Unsupported HTTP method: {method}", fg="red", err=True)
             return
@@ -135,8 +146,11 @@ def request(path, method, data, user_id, follow, content_type, headers):
 
         if hasattr(response, "resolver_match") and response.resolver_match:
             match = response.resolver_match
-            url_name = match.namespaced_url_name or match.url_name or "unnamed"
-            click.secho(f"URL pattern matched: {url_name}", fg="blue", dim=True)
+            namespaced_url_name = getattr(match, "namespaced_url_name", None)
+            url_name_attr = getattr(match, "url_name", None)
+            url_name = namespaced_url_name or url_name_attr
+            if url_name:
+                click.secho(f"URL pattern matched: {url_name}", fg="blue", dim=True)
 
         # Show headers
         if response.headers:
@@ -151,9 +165,15 @@ def request(path, method, data, user_id, follow, content_type, headers):
 
             if "json" in content_type.lower():
                 try:
-                    json_data = response.json()
-                    click.secho("Response Body (JSON):", fg="yellow", bold=True)
-                    click.echo(json.dumps(json_data, indent=2))
+                    # The test client adds a json() method to the response
+                    json_method = getattr(response, "json", None)
+                    if json_method and callable(json_method):
+                        json_data: Any = json_method()
+                        click.secho("Response Body (JSON):", fg="yellow", bold=True)
+                        click.echo(json.dumps(json_data, indent=2))
+                    else:
+                        click.secho("Response Body:", fg="yellow", bold=True)
+                        click.echo(response.content.decode("utf-8", errors="replace"))
                 except Exception:
                     click.secho("Response Body:", fg="yellow", bold=True)
                     click.echo(response.content.decode("utf-8", errors="replace"))

plain/cli/build.py

@@ -33,7 +33,7 @@ from plain.assets.compile import compile_assets, get_compiled_path
     default=True,
     help="Compress the assets",
 )
-def build(keep_original, fingerprint, compress):
+def build(keep_original: bool, fingerprint: bool, compress: bool) -> None:
     """Pre-deployment build step (compile assets, css, js, etc.)"""
 
     if not keep_original and not fingerprint:
@@ -79,7 +79,7 @@ def build(keep_original, fingerprint, compress):
     total_compiled = 0
 
     for url_path, resolved_url_path, compiled_paths in compile_assets(
-        target_dir=target_dir,
+        target_dir=str(target_dir),
         keep_original=keep_original,
         fingerprint=fingerprint,
         compress=compress,

plain/cli/changelog.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 from importlib.util import find_spec
 from pathlib import Path
@@ -7,7 +9,7 @@ import click
 from .output import style_markdown
 
 
-def parse_version(version_str):
+def parse_version(version_str: str) -> tuple[int, ...]:
     """Parse a version string into a tuple of integers for comparison."""
     # Remove 'v' prefix if present and split by dots
     clean_version = version_str.lstrip("v")
@@ -22,7 +24,7 @@ def parse_version(version_str):
     return tuple(parts)
 
 
-def compare_versions(v1, v2):
+def compare_versions(v1: str, v2: str) -> int:
     """Compare two version strings. Returns -1 if v1 < v2, 0 if equal, 1 if v1 > v2."""
     parsed_v1 = parse_version(v1)
     parsed_v2 = parse_version(v2)
@@ -44,7 +46,9 @@ def compare_versions(v1, v2):
 @click.argument("package_label")
 @click.option("--from", "from_version", help="Show entries from this version onwards")
 @click.option("--to", "to_version", help="Show entries up to this version")
-def changelog(package_label, from_version, to_version):
+def changelog(
+    package_label: str, from_version: str | None, to_version: str | None
+) -> None:
     """Show changelog entries for a package."""
     module_name = package_label.replace("-", ".")
     spec = find_spec(module_name)
@@ -85,7 +89,7 @@ def changelog(package_label, from_version, to_version):
     if current_version is not None:
         entries.append((current_version, current_lines))
 
-    def version_found(version):
+    def version_found(version: str) -> bool:
         return any(compare_versions(v, version) == 0 for v, _ in entries)
 
     if from_version and not version_found(from_version):

plain/cli/chores.py

@@ -7,7 +7,7 @@ logger = logging.getLogger("plain.chores")
 
 
 @click.group()
-def chores():
+def chores() -> None:
     """Routine maintenance tasks"""
     pass
 
@@ -17,7 +17,7 @@ def chores():
 @click.option(
     "--name", default=None, type=str, help="Name of the chore to run", multiple=True
 )
-def list_chores(group, name):
+def list_chores(group: tuple[str, ...], name: tuple[str, ...]) -> None:
     """
     List all registered chores.
     """
@@ -50,7 +50,7 @@ def list_chores(group, name):
 @click.option(
     "--dry-run", is_flag=True, help="Show what would be done without executing"
 )
-def run_chores(group, name, dry_run):
+def run_chores(group: tuple[str, ...], name: tuple[str, ...], dry_run: bool) -> None:
     """
     Run the specified chores.
     """
@@ -72,7 +72,7 @@ def run_chores(group, name, dry_run):
     for chore in chores:
         click.echo(f"{chore.name}:", nl=False)
         if dry_run:
-            click.echo(" (dry run)", fg="yellow")
+            click.secho(" (dry run)", fg="yellow", nl=False)
         else:
             try:
                 result = chore.run()

plain/cli/core.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import traceback
+from typing import Any
 
 import click
 from click.core import Command, Context
@@ -24,7 +27,7 @@ from .utils import utils
 
 
 @click.group()
-def plain_cli():
+def plain_cli() -> None:
     pass
 
 
@@ -49,14 +52,14 @@ class CLIRegistryGroup(click.Group):
     Click Group that exposes commands from the CLI registry.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any):
         super().__init__(*args, **kwargs)
         cli_registry.import_modules()
 
-    def list_commands(self, ctx):
+    def list_commands(self, ctx: Context) -> list[str]:
         return sorted(cli_registry.get_commands().keys())
 
-    def get_command(self, ctx, name):
+    def get_command(self, ctx: Context, name: str) -> Command | None:
         commands = cli_registry.get_commands()
         return commands.get(name)
 
@@ -64,7 +67,7 @@ class CLIRegistryGroup(click.Group):
 class PlainCommandCollection(click.CommandCollection):
     context_class = PlainContext
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any):
         sources = []
 
         try:

plain/cli/docs.py

@@ -7,9 +7,9 @@ from .output import iterate_markdown
 
 
 @click.command()
-@click.option("--open")
+@click.option("--open", is_flag=True, help="Open the README in your default editor")
 @click.argument("module", default="")
-def docs(module, open):
+def docs(module: str, open: bool) -> None:
     if not module:
         raise click.UsageError(
             "You must specify a module. For LLM-friendly docs, use `plain agent docs`."

plain/cli/formatting.py

@@ -1,24 +1,27 @@
+from __future__ import annotations
+
 import os
+from typing import Any
 
 import click
 from click.formatting import iter_rows, measure_table, term_len, wrap_text
 
 
 class PlainHelpFormatter(click.HelpFormatter):
-    def write_heading(self, heading):
+    def write_heading(self, heading: str) -> None:
         styled_heading = click.style(heading, underline=True)
         self.write(f"{'':>{self.current_indent}}{styled_heading}\n")
 
-    def write_usage(self, prog, args, prefix="Usage: "):
+    def write_usage(self, prog: str, args: str = "", prefix: str = "Usage: ") -> None:
         prefix_styled = click.style(prefix, italic=True)
         super().write_usage(prog, args, prefix=prefix_styled)
 
     def write_dl(
         self,
-        rows,
-        col_max=30,
-        col_spacing=2,
-    ):
+        rows: list[tuple[str, str]],
+        col_max: int = 30,
+        col_spacing: int = 2,
+    ) -> None:
         """Writes a definition list into the buffer.  This is how options
         and commands are usually formatted.
 
@@ -62,7 +65,7 @@ class PlainHelpFormatter(click.HelpFormatter):
 class PlainContext(click.Context):
     formatter_class = PlainHelpFormatter
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any):
         super().__init__(*args, **kwargs)
 
         # Force colors in CI environments

plain/cli/output.py

@@ -1,11 +1,15 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+
 import click
 
 
-def style_markdown(content):
+def style_markdown(content: str) -> str:
     return "".join(iterate_markdown(content))
 
 
-def iterate_markdown(content):
+def iterate_markdown(content: str) -> Iterator[str]:
     """
     Iterator that does basic markdown for a Click pager.
 

plain/cli/preflight.py

@@ -10,7 +10,7 @@ from plain.runtime import settings
 
 
 @click.group("preflight")
-def preflight_cli():
+def preflight_cli() -> None:
     """Run or manage preflight checks."""
     pass
 
@@ -32,7 +32,7 @@ def preflight_cli():
     is_flag=True,
     help="Hide progress output and warnings, only show errors.",
 )
-def check_command(deploy, format, quiet):
+def check_command(deploy: bool, format: str, quiet: bool) -> None:
     """
     Use the system check framework to validate entire Plain project.
     Exit with error code if any errors are found. Warnings do not cause failure.
@@ -203,7 +203,7 @@ def check_command(deploy, format, quiet):
 
 
 @preflight_cli.command("list")
-def list_checks():
+def list_checks() -> None:
     """List all available preflight checks."""
     packages_registry.autodiscover_modules("preflight", include_app=True)
 

plain/cli/print.py

@@ -1,7 +1,7 @@
 import click
 
 
-def print_event(msg, newline=True):
+def print_event(msg: str, newline: bool = True) -> None:
     arrow = click.style("-->", fg=214, bold=True)
     message = str(msg)
     if not newline:

plain/cli/registry.py

@@ -1,23 +1,27 @@
+from __future__ import annotations
+
+from typing import Any
+
 from plain.packages import packages_registry
 
 
 class CLIRegistry:
     def __init__(self):
-        self._commands = {}
+        self._commands: dict[str, Any] = {}
 
-    def register_command(self, cmd, name):
+    def register_command(self, cmd: Any, name: str) -> None:
         """
         Register a CLI command or group with the specified name.
         """
         self._commands[name] = cmd
 
-    def import_modules(self):
+    def import_modules(self) -> None:
         """
         Import modules from installed packages and app to trigger registration.
         """
         packages_registry.autodiscover_modules("cli", include_app=True)
 
-    def get_commands(self):
+    def get_commands(self) -> dict[str, Any]:
         """
         Get all registered commands.
         """
@@ -27,7 +31,7 @@ class CLIRegistry:
 cli_registry = CLIRegistry()
 
 
-def register_cli(name):
+def register_cli(name: str) -> Any:
     """
     Register a CLI command or group with the given name.
 
@@ -38,7 +42,7 @@ def register_cli(name):
             pass
     """
 
-    def wrapper(cmd):
+    def wrapper(cmd: Any) -> Any:
         cli_registry.register_command(cmd, name)
         return cmd
 

plain/cli/scaffold.py

@@ -7,7 +7,7 @@ import plain.runtime
 
 @click.command()
 @click.argument("package_name")
-def create(package_name):
+def create(package_name: str) -> None:
     """
     Create a new local package.
 

plain/cli/settings.py

@@ -5,7 +5,7 @@ import plain.runtime
 
 @click.command()
 @click.argument("setting_name")
-def setting(setting_name):
+def setting(setting_name: str) -> None:
     """Print the value of a setting at runtime"""
     try:
         setting = getattr(plain.runtime.settings, setting_name)

plain/cli/shell.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import subprocess
 import sys
@@ -17,7 +19,7 @@ import click
     "--command",
     help="Execute the given command and exit.",
 )
-def shell(interface, command):
+def shell(interface: str | None, command: str | None) -> None:
     """
     Runs a Python interactive interpreter. Tries to use IPython or
     bpython, if one of them is available.
@@ -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,7 +64,7 @@ def shell(interface, command):
 
 @click.command()
 @click.argument("script", nargs=1, type=click.Path(exists=True))
-def run(script):
+def run(script: str) -> None:
     """Run a Python script in the context of your app"""
     before_script = "import plain.runtime; plain.runtime.setup()"
     command = f"{before_script}; exec(open('{script}').read())"

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="")

plain/cli/urls.py

@@ -1,15 +1,19 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+
 import click
 
 
 @click.group()
-def urls():
+def urls() -> None:
     """URL related commands"""
     pass
 
 
 @urls.command("list")
 @click.option("--flat", is_flag=True, help="List all URLs in a flat list")
-def list_urls(flat):
+def list_urls(flat: bool) -> None:
     """Print all URL patterns under settings.URLS_ROUTER"""
     from plain.runtime import settings
     from plain.urls import URLResolver, get_resolver
@@ -20,7 +24,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 +56,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():
+def utils() -> None:
     pass
 
 
 @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)

plain/csrf/middleware.py

@@ -1,5 +1,9 @@
+from __future__ import annotations
+
 import logging
 import re
+from collections.abc import Callable
+from typing import TYPE_CHECKING
 from urllib.parse import urlparse
 
 from plain.logs.utils import log_response
@@ -7,6 +11,10 @@ from plain.runtime import settings
 
 from .views import CsrfFailureView
 
+if TYPE_CHECKING:
+    from plain.http import Response
+    from plain.http.request import HttpRequest
+
 logger = logging.getLogger("plain.security.csrf")
 
 
@@ -19,13 +27,15 @@ class CsrfViewMiddleware:
     like subdomains can have different trust levels and are rejected.
     """
 
-    def __init__(self, get_response):
+    def __init__(self, get_response: Callable[[HttpRequest], Response]):
         self.get_response = get_response
 
         # Compile CSRF exempt patterns once for performance
-        self.csrf_exempt_patterns = [re.compile(r) for r in settings.CSRF_EXEMPT_PATHS]
+        self.csrf_exempt_patterns: list[re.Pattern[str]] = [
+            re.compile(r) for r in settings.CSRF_EXEMPT_PATHS
+        ]
 
-    def __call__(self, request):
+    def __call__(self, request: HttpRequest) -> Response:
         allowed, reason = self.should_allow_request(request)
 
         if allowed:
@@ -33,7 +43,7 @@ class CsrfViewMiddleware:
         else:
             return self.reject(request, reason)
 
-    def should_allow_request(self, request) -> tuple[bool, str]:
+    def should_allow_request(self, request: HttpRequest) -> tuple[bool, str]:
         # 1. Allow safe methods (GET, HEAD, OPTIONS)
         if request.method in ("GET", "HEAD", "OPTIONS"):
             return True, f"Safe HTTP method: {request.method}"
@@ -118,7 +128,7 @@ class CsrfViewMiddleware:
             f"Cross-origin request detected - Origin {origin} does not match Host",
         )
 
-    def reject(self, request, reason):
+    def reject(self, request: HttpRequest, reason: str) -> Response:
         """Reject a request with a 403 Forbidden response."""
 
         response = CsrfFailureView.as_view()(request, reason=reason)

plain/csrf/views.py

@@ -1,31 +1,34 @@
+from __future__ import annotations
+
+from plain.http import Response
 from plain.views import TemplateView
 
 
 class CsrfFailureView(TemplateView):
     template_name = "403.html"
 
-    def get_response(self):
+    def get_response(self) -> Response:
         response = super().get_response()
         response.status_code = 403
         return response
 
-    def post(self):
+    def post(self) -> Response:
         return self.get()
 
-    def put(self):
+    def put(self) -> Response:
         return self.get()
 
-    def patch(self):
+    def patch(self) -> Response:
         return self.get()
 
-    def delete(self):
+    def delete(self) -> Response:
         return self.get()
 
-    def head(self):
+    def head(self) -> Response:
         return self.get()
 
-    def options(self):
+    def options(self) -> Response:
         return self.get()
 
-    def trace(self):
+    def trace(self) -> Response:
         return self.get()