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

plain/cli/agent/docs.py

@@ -1,80 +0,0 @@
-import importlib.util
-import pkgutil
-from pathlib import Path
-
-import click
-
-from .llmdocs import LLMDocs
-
-
-@click.command()
-@click.argument("package", default="", required=False)
-@click.option(
-    "--list",
-    "show_list",
-    is_flag=True,
-    help="List available packages",
-)
-def docs(package, show_list):
-    """Show LLM-friendly documentation and source for a package."""
-
-    if show_list:
-        # List available packages using same discovery logic as md command
-        try:
-            available_packages = []
-
-            # Check for plain.* subpackages (including core plain)
-            try:
-                import plain
-
-                # Check core plain package (namespace package)
-                plain_spec = importlib.util.find_spec("plain")
-                if plain_spec and plain_spec.submodule_search_locations:
-                    available_packages.append("plain")
-
-                # Check other plain.* subpackages
-                for importer, modname, ispkg in pkgutil.iter_modules(
-                    plain.__path__, "plain."
-                ):
-                    if ispkg:
-                        available_packages.append(modname)
-            except Exception:
-                pass
-
-            if available_packages:
-                for pkg in sorted(available_packages):
-                    click.echo(f"- {pkg}")
-            else:
-                click.echo("No packages found.")
-        except Exception as e:
-            click.echo(f"Error listing packages: {e}")
-        return
-
-    if not package:
-        raise click.UsageError(
-            "Package name required. Usage: plain agent docs [package-name]"
-        )
-
-    # Convert hyphens to dots (e.g., plain-models -> plain.models)
-    package = package.replace("-", ".")
-
-    # Automatically prefix if we need to
-    if not package.startswith("plain"):
-        package = f"plain.{package}"
-
-    try:
-        # Get the path for this specific package
-        spec = importlib.util.find_spec(package)
-        if not spec or not spec.origin:
-            raise click.UsageError(f"Package {package} not found")
-
-        package_path = Path(spec.origin).parent
-        paths = [package_path]
-
-        # Generate docs for this specific package
-        source_docs = LLMDocs(paths)
-        source_docs.load()
-        source_docs.print(relative_to=package_path.parent)
-
-    except Exception as e:
-        raise click.UsageError(f"Error loading documentation for {package}: {e}")

plain/cli/agent/md.py

@@ -1,87 +0,0 @@
-import importlib.util
-import pkgutil
-from pathlib import Path
-
-import click
-
-from ..output import iterate_markdown
-
-
-def _get_packages_with_agents():
-    """Get dict mapping package names to AGENTS.md paths."""
-    agents_files = {}
-
-    # Check for plain.* subpackages (including core plain)
-    try:
-        import plain
-
-        # Check core plain package (namespace package)
-        plain_spec = importlib.util.find_spec("plain")
-        if plain_spec and plain_spec.submodule_search_locations:
-            # For namespace packages, use the first search location
-            plain_path = Path(plain_spec.submodule_search_locations[0])
-            agents_path = plain_path / "AGENTS.md"
-            if agents_path.exists():
-                agents_files["plain"] = agents_path
-
-        # Check other plain.* subpackages
-        for importer, modname, ispkg in pkgutil.iter_modules(plain.__path__, "plain."):
-            if ispkg:
-                try:
-                    spec = importlib.util.find_spec(modname)
-                    if spec and spec.origin:
-                        package_path = Path(spec.origin).parent
-                        # Look for AGENTS.md at package root
-                        agents_path = package_path / "AGENTS.md"
-                        if agents_path.exists():
-                            agents_files[modname] = agents_path
-                except Exception:
-                    continue
-    except Exception:
-        pass
-
-    return agents_files
-
-
-@click.command("md")
-@click.argument("package", default="", required=False)
-@click.option(
-    "--all",
-    "show_all",
-    is_flag=True,
-    help="Show AGENTS.md for all packages that have them",
-)
-@click.option(
-    "--list",
-    "show_list",
-    is_flag=True,
-    help="List packages with AGENTS.md files",
-)
-def md(package, show_all, show_list):
-    """Show AGENTS.md for a package."""
-
-    agents_files = _get_packages_with_agents()
-
-    if show_list:
-        for pkg in sorted(agents_files.keys()):
-            click.echo(f"- {pkg}")
-
-        return
-
-    if show_all:
-        for pkg in sorted(agents_files.keys()):
-            agents_path = agents_files[pkg]
-            for line in iterate_markdown(agents_path.read_text()):
-                click.echo(line, nl=False)
-            print()
-
-        return
-
-    if not package:
-        raise click.UsageError(
-            "Package name or --all required. Use --list to see available packages."
-        )
-
-    agents_path = agents_files[package]
-    for line in iterate_markdown(agents_path.read_text()):
-        click.echo(line, nl=False)

plain/cli/agent/prompt.py

@@ -1,45 +0,0 @@
-import os
-import shlex
-import subprocess
-
-import click
-
-
-def is_agent_environment():
-    """Check if we're running inside a coding agent."""
-    return bool(
-        os.environ.get("CLAUDECODE")
-        or os.environ.get("CODEX_SANDBOX")
-        or os.environ.get("CURSOR_ENVIRONMENT")
-    )
-
-
-def prompt_agent(
-    prompt: str, agent_command: str | None = None, print_only: bool = False
-) -> bool:
-    if is_agent_environment():
-        click.echo(prompt)
-        return True
-
-    if print_only or not agent_command:
-        click.echo(prompt)
-        if not print_only:
-            click.secho(
-                "\nCopy the prompt above to a coding agent. To run an agent automatically, use --agent-command or set the PLAIN_AGENT_COMMAND environment variable.",
-                dim=True,
-                italic=True,
-                err=True,
-            )
-        return True
-    else:
-        cmd = shlex.split(agent_command)
-        cmd.append(prompt)
-        result = subprocess.run(cmd, check=False)
-        if result.returncode != 0:
-            click.secho(
-                f"Agent command failed with exit code {result.returncode}",
-                fg="red",
-                err=True,
-            )
-            return False
-        return True

plain/cli/agent/request.py

@@ -1,181 +0,0 @@
-import json
-
-import click
-
-from plain.runtime import settings
-from plain.test import Client
-
-
-@click.command()
-@click.argument("path")
-@click.option(
-    "--method",
-    default="GET",
-    help="HTTP method (GET, POST, PUT, PATCH, DELETE, etc.)",
-)
-@click.option(
-    "--data",
-    help="Request data (JSON string for POST/PUT/PATCH)",
-)
-@click.option(
-    "--user",
-    "user_id",
-    help="User ID to authenticate as (skips normal authentication)",
-)
-@click.option(
-    "--follow/--no-follow",
-    default=True,
-    help="Follow redirects (default: True)",
-)
-@click.option(
-    "--content-type",
-    help="Content-Type header for request data",
-)
-@click.option(
-    "--header",
-    "headers",
-    multiple=True,
-    help="Additional headers (format: 'Name: Value')",
-)
-def request(path, method, data, user_id, follow, content_type, headers):
-    """Make an HTTP request using the test client against the development database."""
-
-    try:
-        # Only allow in DEBUG mode for security
-        if not settings.DEBUG:
-            click.secho("This command only works when DEBUG=True", fg="red", err=True)
-            return
-
-        # Temporarily add testserver to ALLOWED_HOSTS so the test client can make requests
-        original_allowed_hosts = settings.ALLOWED_HOSTS
-        settings.ALLOWED_HOSTS = ["*"]
-
-        try:
-            # Create test client
-            client = Client()
-
-            # If user_id provided, force login
-            if user_id:
-                try:
-                    # Get the User model using plain.auth utility
-                    from plain.auth import get_user_model
-
-                    User = get_user_model()
-
-                    # Get the user
-                    try:
-                        user = User.query.get(id=user_id)
-                        client.force_login(user)
-                        click.secho(
-                            f"Authenticated as user {user_id}", fg="green", dim=True
-                        )
-                    except User.DoesNotExist:
-                        click.secho(f"User {user_id} not found", fg="red", err=True)
-                        return
-
-                except Exception as e:
-                    click.secho(f"Authentication error: {e}", fg="red", err=True)
-                    return
-
-            # Parse additional headers
-            header_dict = {}
-            for header in headers:
-                if ":" in header:
-                    key, value = header.split(":", 1)
-                    header_dict[key.strip()] = value.strip()
-
-            # Prepare request data
-            if data and content_type and "json" in content_type.lower():
-                try:
-                    # Validate JSON
-                    json.loads(data)
-                except json.JSONDecodeError as e:
-                    click.secho(f"Invalid JSON data: {e}", fg="red", err=True)
-                    return
-
-            # Make the request
-            method = method.upper()
-            kwargs = {
-                "path": path,
-                "follow": follow,
-                "headers": header_dict or None,
-            }
-
-            if method in ("POST", "PUT", "PATCH") and data:
-                kwargs["data"] = data
-                if content_type:
-                    kwargs["content_type"] = content_type
-
-            # Call the appropriate client method
-            if method == "GET":
-                response = client.get(**kwargs)
-            elif method == "POST":
-                response = client.post(**kwargs)
-            elif method == "PUT":
-                response = client.put(**kwargs)
-            elif method == "PATCH":
-                response = client.patch(**kwargs)
-            elif method == "DELETE":
-                response = client.delete(**kwargs)
-            elif method == "HEAD":
-                response = client.head(**kwargs)
-            elif method == "OPTIONS":
-                response = client.options(**kwargs)
-            elif method == "TRACE":
-                response = client.trace(**kwargs)
-            else:
-                click.secho(f"Unsupported HTTP method: {method}", fg="red", err=True)
-                return
-
-            # Display response information
-            click.secho(
-                f"HTTP {response.status_code}",
-                fg="green" if response.status_code < 400 else "red",
-                bold=True,
-            )
-
-            # Show additional response info first
-            if hasattr(response, "user"):
-                click.secho(f"Authenticated user: {response.user}", fg="blue", dim=True)
-
-            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)
-
-            # Show headers
-            if response.headers:
-                click.secho("Response Headers:", fg="yellow", bold=True)
-                for key, value in response.headers.items():
-                    click.echo(f"  {key}: {value}")
-                click.echo()
-
-            # Show response content last
-            if response.content:
-                content_type = response.headers.get("Content-Type", "")
-
-                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))
-                    except Exception:
-                        click.secho("Response Body:", fg="yellow", bold=True)
-                        click.echo(response.content.decode("utf-8", errors="replace"))
-                elif "html" in content_type.lower():
-                    click.secho("Response Body (HTML):", fg="yellow", bold=True)
-                    content = response.content.decode("utf-8", errors="replace")
-                    click.echo(content)
-                else:
-                    click.secho("Response Body:", fg="yellow", bold=True)
-                    content = response.content.decode("utf-8", errors="replace")
-                    click.echo(content)
-            else:
-                click.secho("(No response body)", fg="yellow", dim=True)
-
-        finally:
-            # Restore original ALLOWED_HOSTS
-            settings.ALLOWED_HOSTS = original_allowed_hosts
-
-    except Exception as e:
-        click.secho(f"Request failed: {e}", fg="red", err=True)

plain/csrf/views.py

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

plain/logs/utils.py

@@ -1,46 +0,0 @@
-import logging
-
-request_logger = logging.getLogger("plain.request")
-
-
-def log_response(
-    message,
-    *args,
-    response=None,
-    request=None,
-    logger=request_logger,
-    level=None,
-    exception=None,
-):
-    """
-    Log errors based on Response status.
-
-    Log 5xx responses as errors and 4xx responses as warnings (unless a level
-    is given as a keyword argument). The Response status_code and the
-    request are passed to the logger's extra parameter.
-    """
-    # Check if the response has already been logged. Multiple requests to log
-    # the same response can be received in some cases, e.g., when the
-    # response is the result of an exception and is logged when the exception
-    # is caught, to record the exception.
-    if getattr(response, "_has_been_logged", False):
-        return
-
-    if level is None:
-        if response.status_code >= 500:
-            level = "error"
-        elif response.status_code >= 400:
-            level = "warning"
-        else:
-            level = "info"
-
-    getattr(logger, level)(
-        message,
-        *args,
-        extra={
-            "status_code": response.status_code,
-            "request": request,
-        },
-        exc_info=exception,
-    )
-    response._has_been_logged = True

plain/preflight/messages.py

@@ -1,81 +0,0 @@
-# Levels
-DEBUG = 10
-INFO = 20
-WARNING = 30
-ERROR = 40
-CRITICAL = 50
-
-
-class CheckMessage:
-    def __init__(self, level, msg, hint=None, obj=None, id=None):
-        if not isinstance(level, int):
-            raise TypeError("The first argument should be level.")
-        self.level = level
-        self.msg = msg
-        self.hint = hint
-        self.obj = obj
-        self.id = id
-
-    def __eq__(self, other):
-        return isinstance(other, self.__class__) and all(
-            getattr(self, attr) == getattr(other, attr)
-            for attr in ["level", "msg", "hint", "obj", "id"]
-        )
-
-    def __str__(self):
-        try:
-            from plain import models
-
-            ModelBase = models.base.ModelBase
-            using_db = True
-        except ImportError:
-            using_db = False
-            ModelBase = object
-
-        if self.obj is None:
-            obj = "?"
-        elif using_db and isinstance(self.obj, ModelBase):
-            # We need to hardcode ModelBase and Field cases because its __str__
-            # method doesn't return "applabel.modellabel" and cannot be changed.
-            obj = self.obj._meta.label
-        else:
-            obj = str(self.obj)
-        id = f"({self.id}) " if self.id else ""
-        hint = f"\n\tHINT: {self.hint}" if self.hint else ""
-        return f"{obj}: {id}{self.msg}{hint}"
-
-    def __repr__(self):
-        return f"<{self.__class__.__name__}: level={self.level!r}, msg={self.msg!r}, hint={self.hint!r}, obj={self.obj!r}, id={self.id!r}>"
-
-    def is_serious(self, level=ERROR):
-        return self.level >= level
-
-    def is_silenced(self):
-        from plain.runtime import settings
-
-        return self.id in settings.PREFLIGHT_SILENCED_CHECKS
-
-
-class Debug(CheckMessage):
-    def __init__(self, *args, **kwargs):
-        super().__init__(DEBUG, *args, **kwargs)
-
-
-class Info(CheckMessage):
-    def __init__(self, *args, **kwargs):
-        super().__init__(INFO, *args, **kwargs)
-
-
-class Warning(CheckMessage):
-    def __init__(self, *args, **kwargs):
-        super().__init__(WARNING, *args, **kwargs)
-
-
-class Error(CheckMessage):
-    def __init__(self, *args, **kwargs):
-        super().__init__(ERROR, *args, **kwargs)
-
-
-class Critical(CheckMessage):
-    def __init__(self, *args, **kwargs):
-        super().__init__(CRITICAL, *args, **kwargs)

plain/templates/AGENTS.md

@@ -1,3 +0,0 @@
-# Plain Templates AGENTS.md
-
-- Plain templates use Jinja2.