plain.dev 0.30.1__tar.gz → 0.32.1__tar.gz

{plain_dev-0.30.1 → plain_dev-0.32.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.dev
-Version: 0.30.1
+Version: 0.32.1
 Summary: Local development tools for Plain.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause
@@ -38,6 +38,7 @@ The `plain dev` command does several things:
 - Runs `plain preflight` to check for any issues
 - Executes any pending model migrations
 - Starts `gunicorn` with `--reload`
+- Serves HTTPS on port 8443 by default (uses the next free port if 8443 is taken and no port is specified)
 - Runs `plain tailwind build --watch`, if `plain.tailwind` is installed
 - Any custom process defined in `pyproject.toml` at `tool.plain.dev.run`
 - Necessary services (ex. Postgres) defined in `pyproject.toml` at `tool.plain.dev.services`

plain_dev-0.32.1/plain/dev/CHANGELOG.md

@@ -0,0 +1,24 @@
+# plain-dev changelog
+
+## [0.32.1](https://github.com/dropseed/plain/releases/plain-dev@0.32.1) (2025-06-27)
+
+### What's changed
+
+- Fixed an error when running `plain dev precommit` (or the `plain precommit` helper) that passed an extra `default` argument to `plain preflight --database`. The flag now correctly aligns with the current `plain preflight` CLI ([db65930](https://github.com/dropseed/plain/commit/db659304129a453676c0dcc20c13b606254ce1c2)).
+
+### Upgrade instructions
+
+- No changes required.
+
+## [0.32.0](https://github.com/dropseed/plain/releases/plain-dev@0.32.0) (2025-06-23)
+
+### What's changed
+
+- `plain dev` now writes a PID file and will refuse to start if it detects that another `plain dev` instance is already running in the same project ([75b7a50](https://github.com/dropseed/plain/commit/75b7a505ae3c60675099ffd440f35cf8f30665da)).
+- When no `--port` is provided, `plain dev` now checks if port 8443 is available and, if not, automatically selects the next free port. Supplying `--port` will error if that port is already in use ([3f5141f](https://github.com/dropseed/plain/commit/3f5141f54a65455f5784ed3f97be2d153ed10a23)).
+- The development request-log UI has been removed for now, along with its related endpoints and templates ([8ac6f71](https://github.com/dropseed/plain/commit/8ac6f7170efa72e6069bae3cc91809b5fe0f8a7d)).
+- `plain contrib --all` skips any installed `plainx-*` packages instead of erroring when it can’t locate their repository ([3a26aee](https://github.com/dropseed/plain/commit/3a26aee25e586a66e02a348aa24ee6e048ea0b71)).
+
+### Upgrade instructions
+
+- No changes required.

{plain_dev-0.30.1 → plain_dev-0.32.1}/plain/dev/README.md

@@ -20,6 +20,7 @@ The `plain dev` command does several things:
 - Runs `plain preflight` to check for any issues
 - Executes any pending model migrations
 - Starts `gunicorn` with `--reload`
+- Serves HTTPS on port 8443 by default (uses the next free port if 8443 is taken and no port is specified)
 - Runs `plain tailwind build --watch`, if `plain.tailwind` is installed
 - Any custom process defined in `pyproject.toml` at `tool.plain.dev.run`
 - Necessary services (ex. Postgres) defined in `pyproject.toml` at `tool.plain.dev.services`

{plain_dev-0.30.1 → plain_dev-0.32.1}/plain/dev/cli.py

@@ -4,6 +4,7 @@ import multiprocessing
 import os
 import platform
 import signal
+import socket
 import subprocess
 import sys
 import time
@@ -20,6 +21,7 @@ from rich.text import Text
 from plain.cli import register_cli
 from plain.runtime import APP_PATH, PLAIN_TEMP_PATH
 
+from .dev_pid import DevPid
 from .mkcert import MkcertManager
 from .poncho.manager import Manager as PonchoManager
 from .poncho.printer import Printer
@@ -35,9 +37,12 @@ ENTRYPOINT_GROUP = "plain.dev"
 @click.option(
     "--port",
     "-p",
-    default=8443,
-    type=int,
-    help="Port to run the web server on",
+    default="",
+    type=str,
+    help=(
+        "Port to run the web server on. If omitted, tries 8443 and "
+        "picks the next free port"
+    ),
 )
 @click.option(
     "--hostname",
@@ -59,6 +64,10 @@ def cli(ctx, port, hostname, log_level):
     if ctx.invoked_subcommand:
         return
 
+    if DevPid().exists():
+        click.secho("`plain dev` already running", fg="yellow")
+        sys.exit(1)
+
     if not hostname:
         project_name = os.path.basename(
             os.getcwd()
@@ -132,10 +141,21 @@ def entrypoint(show_list, entrypoint):
 
 class Dev:
     def __init__(self, *, port, hostname, log_level):
-        self.port = port
         self.hostname = hostname
         self.log_level = log_level
 
+        self.pid = DevPid()
+
+        if port:
+            self.port = int(port)
+            if not self._port_available(self.port):
+                click.secho(f"Port {self.port} in use", fg="red")
+                raise SystemExit(1)
+        else:
+            self.port = self._find_open_port(8443)
+            if self.port != 8443:
+                click.secho(f"Port 8443 in use, using {self.port}", fg="yellow")
+
         self.ssl_key_path = None
         self.ssl_cert_path = None
 
@@ -191,7 +211,20 @@ class Dev:
 
         self.poncho = PonchoManager(printer=Printer(lambda s: self.console.out(s)))
 
+    def _find_open_port(self, start_port):
+        port = start_port
+        while not self._port_available(port):
+            port += 1
+        return port
+
+    def _port_available(self, port):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(0.5)
+            result = sock.connect_ex(("127.0.0.1", port))
+        return result != 0
+
     def run(self):
+        self.pid.write()
         mkcert_manager = MkcertManager()
         mkcert_manager.setup_mkcert(install_path=Path.home() / ".plain" / "dev")
         self.ssl_cert_path, self.ssl_key_path = mkcert_manager.generate_certs(
@@ -253,6 +286,7 @@ class Dev:
             # Remove the status bar
             self.console_status.stop()
         finally:
+            self.pid.rm()
             # Make sure the services pid gets removed if we set it
             if services_pid:
                 services_pid.rm()

{plain_dev-0.30.1 → plain_dev-0.32.1}/plain/dev/contribute/cli.py

@@ -35,6 +35,8 @@ def cli(packages, repo, reset, all_packages):
 
         return
 
+    packages = list(packages)
+
     repo = Path(repo)
     if not repo.exists():
         click.secho(f"Repo not found at {repo}", fg="red")
@@ -57,6 +59,7 @@ def cli(packages, repo, reset, all_packages):
 
     plain_packages = []
     plainx_packages = []
+    skipped_plainx_packages = []
 
     if all_packages:
         # get all installed plain packages
@@ -67,11 +70,23 @@ def cli(packages, repo, reset, all_packages):
             click.secho("No installed packages found", fg="red")
             sys.exit(1)
 
-        packages = [
-            line.split("==")[0]
-            for line in installed_packages.splitlines()
-            if line.startswith("plain")
-        ]
+        packages = []
+        for line in installed_packages.splitlines():
+            if not line.startswith("plain"):
+                continue
+            package = line.split("==")[0]
+            if package.startswith("plainx-"):
+                skipped_plainx_packages.append(package)
+            else:
+                packages.append(package)
+
+        if skipped_plainx_packages:
+            click.secho(
+                "Skipping plainx packages: "
+                + ", ".join(sorted(skipped_plainx_packages))
+                + " (unknown repo)",
+                fg="yellow",
+            )
 
     for package in packages:
         package = package.replace(".", "-")

plain_dev-0.32.1/plain/dev/dev_pid.py

@@ -0,0 +1,36 @@
+import os
+
+from plain.runtime import PLAIN_TEMP_PATH
+
+
+class DevPid:
+    """Manage a pidfile for the running ``plain dev`` command."""
+
+    def __init__(self):
+        self.pidfile = PLAIN_TEMP_PATH / "dev" / "dev.pid"
+
+    def write(self):
+        pid = os.getpid()
+        self.pidfile.parent.mkdir(parents=True, exist_ok=True)
+        with self.pidfile.open("w+") as f:
+            f.write(str(pid))
+
+    def rm(self):
+        if self.pidfile.exists():
+            self.pidfile.unlink()
+
+    def exists(self):
+        if not self.pidfile.exists():
+            return False
+        try:
+            pid = int(self.pidfile.read_text())
+        except (ValueError, OSError):
+            self.rm()
+            return False
+        try:
+            os.kill(pid, 0)
+        except OSError:
+            # Stale pidfile
+            self.rm()
+            return False
+        return True

plain_dev-0.32.1/plain/dev/precommit/__init__.py

@@ -0,0 +1,3 @@
+from .cli import cli
+
+__all__ = ["cli"]

{plain_dev-0.30.1 → plain_dev-0.32.1}/plain/dev/precommit/cli.py

@@ -67,7 +67,6 @@ def cli(install):
                 "plain",
                 "preflight",
                 "--database",
-                "default",
             )
             check_short("Checking Plain migrations", "plain", "migrate", "--check")
             check_short(

{plain_dev-0.30.1 → plain_dev-0.32.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.dev"
-version = "0.30.1"
+version = "0.32.1"
 description = "Local development tools for Plain."
 authors = [{name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev"}]
 license = "BSD-3-Clause"

plain_dev-0.30.1/plain/dev/__init__.py

@@ -1,4 +0,0 @@
-from .cli import cli
-from .requests import RequestsMiddleware
-
-__all__ = ["cli", "RequestsMiddleware"]

plain_dev-0.30.1/plain/dev/requests.py

@@ -1,224 +0,0 @@
-import datetime
-import json
-import os
-import sys
-import traceback
-
-import requests
-
-from plain.runtime import PLAIN_TEMP_PATH, settings
-from plain.signals import got_request_exception
-
-
-class RequestLog:
-    def __init__(self, *, request, response, exception=None):
-        self.request = request
-        self.response = response
-        self.exception = exception
-
-    @staticmethod
-    def storage_path():
-        return str(PLAIN_TEMP_PATH / "dev" / "requestlog")
-
-    @classmethod
-    def replay_request(cls, name):
-        path = os.path.join(cls.storage_path(), f"{name}.json")
-        with open(path) as f:
-            data = json.load(f)
-
-        method = data["request"]["method"]
-
-        if method == "GET":
-            # Params are in absolute uri
-            request_data = data["request"]["body"].encode("utf-8")
-        elif method in ("POST", "PUT", "PATCH"):
-            if data["request"]["querydict"]:
-                request_data = data["request"]["querydict"]
-            else:
-                request_data = data["request"]["body"].encode("utf-8")
-
-        # Cookies need to be passed as a dict, so that
-        # they are passed through redirects
-        data["request"]["headers"].pop("Cookie", None)
-
-        # TODO???
-        if data["request"]["headers"].get("X-Forwarded-Proto", "") == "https,https":
-            data["request"]["headers"]["X-Forwarded-Proto"] = "https"
-
-        response = requests.request(
-            method,
-            data["request"]["absolute_uri"],
-            headers=data["request"]["headers"],
-            cookies=data["request"]["cookies"],
-            data=request_data,
-            timeout=5,
-        )
-        print("Replayed request", response)
-
-    @staticmethod
-    def load_json_logs():
-        storage_path = RequestLog.storage_path()
-        if not os.path.exists(storage_path):
-            return []
-
-        logs = []
-        filenames = os.listdir(storage_path)
-        sorted_filenames = sorted(filenames, reverse=True)
-        for filename in sorted_filenames:
-            path = os.path.join(storage_path, filename)
-            with open(path) as f:
-                log = json.load(f)
-                log["name"] = os.path.splitext(filename)[0]
-                # Convert timestamp back to datetime
-                log["timestamp"] = datetime.datetime.fromtimestamp(log["timestamp"])
-                try:
-                    log["request"]["body_json"] = json.dumps(
-                        json.loads(log["request"]["body"]), indent=2
-                    )
-                except json.JSONDecodeError:
-                    pass
-                logs.append(log)
-
-        return logs
-
-    @staticmethod
-    def delete_old_logs():
-        storage_path = RequestLog.storage_path()
-        if not os.path.exists(storage_path):
-            return
-
-        filenames = os.listdir(storage_path)
-        sorted_filenames = sorted(filenames, reverse=True)
-        for filename in sorted_filenames[settings.DEV_REQUESTS_MAX :]:
-            path = os.path.join(storage_path, filename)
-            try:
-                os.remove(path)
-            except FileNotFoundError:
-                pass
-
-    @staticmethod
-    def clear():
-        storage_path = RequestLog.storage_path()
-        if not os.path.exists(storage_path):
-            return
-
-        filenames = os.listdir(storage_path)
-        for filename in filenames:
-            path = os.path.join(storage_path, filename)
-            try:
-                os.remove(path)
-            except FileNotFoundError:
-                pass
-
-    def save(self):
-        storage_path = self.storage_path()
-        if not os.path.exists(storage_path):
-            os.makedirs(storage_path)
-
-        timestamp = datetime.datetime.now().timestamp()
-        filename = f"{timestamp}.json"
-        path = os.path.join(storage_path, filename)
-        with open(path, "w+") as f:
-            json.dump(self.as_dict(), f, indent=2)
-
-        self.delete_old_logs()
-
-    def as_dict(self):
-        return {
-            "timestamp": datetime.datetime.now().timestamp(),
-            "request": self.request_as_dict(self.request),
-            "response": self.response_as_dict(self.response),
-            "exception": self.exception_as_dict(self.exception),
-        }
-
-    @staticmethod
-    def request_as_dict(request):
-        return {
-            "method": request.method,
-            "path": request.path,
-            "full_path": request.get_full_path(),
-            "querydict": request.data.dict()
-            if request.method == "POST"
-            else request.query_params.dict(),
-            "cookies": request.cookies,
-            # files?
-            "absolute_uri": request.build_absolute_uri(),
-            "body": request.body.decode("utf-8"),
-            "headers": dict(request.headers),
-        }
-
-    @staticmethod
-    def response_as_dict(response):
-        try:
-            content = response.content.decode("utf-8")
-        except AttributeError:
-            content = "<streaming_content>"
-
-        return {
-            "status_code": response.status_code,
-            "headers": dict(response.headers),
-            "content": content,
-        }
-
-    @staticmethod
-    def exception_as_dict(exception):
-        if not exception:
-            return None
-
-        tb_string = "".join(traceback.format_tb(exception.__traceback__))
-
-        try:
-            args = json.dumps(exception.args)
-        except TypeError:
-            args = str(exception.args)
-
-        return {
-            "type": type(exception).__name__,
-            "str": str(exception),
-            "args": args,
-            "traceback": tb_string,
-        }
-
-
-def should_capture_request(request):
-    if not settings.DEBUG:
-        return False
-
-    if request.resolver_match and request.resolver_match.namespace == "dev":
-        return False
-
-    if request.path in settings.DEV_REQUESTS_IGNORE_PATHS:
-        return False
-
-    # This could be an attribute set on request or response
-    # or something more dynamic
-    if "querystats" in request.query_params:
-        return False
-
-    return True
-
-
-class RequestsMiddleware:
-    def __init__(self, get_response):
-        self.get_response = get_response
-        self.exception = None  # If an exception occurs, we want to remember it
-
-        got_request_exception.connect(self.store_exception)
-
-    def __call__(self, request):
-        # Process it first, so we know the resolver_match
-        response = self.get_response(request)
-
-        if should_capture_request(request):
-            RequestLog(
-                request=request, response=response, exception=self.exception
-            ).save()
-
-        return response
-
-    def store_exception(self, **kwargs):
-        """
-        The signal calls this at the right time,
-        so we can use sys.exxception to capture.
-        """
-        self.exception = sys.exception()

plain_dev-0.30.1/plain/dev/templates/dev/requests.html

@@ -1,134 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Requestlog</title>
-    {% tailwind_css %}
-</head>
-<body class="bg-zinc-900 text-zinc-200">
-
-<div class="flex">
-    <div class="overflow-auto border-r sm:w-1/2 md:2/5 border-zinc-700">
-        <table>
-            <tbody>
-                {% for log in requestlogs %}
-                <tr class="hover:bg-zinc-800 cursor-pointer text-zinc-400 {% if log.name == requestlog.name %}bg-zinc-700{% endif %}">
-                    <td class="whitespace-nowrap px-2 py-2 border-b border-zinc-700 border-l-4 {% if log.name == requestlog.name %}border-l-orange-600{% else %}border-l-transparent{% endif %}">
-                        {% if log.response.status_code >= 400 %}
-                        <span class="px-1.5 py-0.5 text-xs text-white bg-red-600 rounded-sm">{{ log.response.status_code }}</span>
-                        {% elif log.response.status_code >= 300 %}
-                        <span class="px-1.5 py-0.5 text-xs text-white bg-zinc-600 rounded-sm">{{ log.response.status_code }}</span>
-                        {% else %}
-                        <span class="px-1.5 py-0.5 text-xs text-zinc-700 bg-zinc-300 rounded-sm">{{ log.response.status_code }}</span>
-                        {% endif %}
-                    </td>
-                    <td class="px-1 py-2 border-b whitespace-nowrap border-zinc-700">
-                        <span class="font-mono text-sm text-zinc-400">{{ log.request.method }}</span>
-                    </td>
-                    <td class="w-full px-2 py-2 overflow-hidden border-b whitespace-nowrap border-zinc-700 text-ellipsis" style="max-width: 1px;">
-                        <a href="?log={{ log.name }}">
-                            <span class="font-mono text-sm text-zinc-300">{{ log.request.full_path }}</span>
-                        </a>
-                    </td>
-                    <td class="px-2 py-2 text-right border-b whitespace-nowrap border-zinc-700">
-                        <span title="{{ log.timestamp }}" class="text-xs tabular-nums whitespace-nowrap">{{ log.timestamp|strftime("%H:%M:%S") }}</span>
-                    </td>
-                </tr>
-                {% else %}
-                <tr>
-                    <td class="px-4 py-2 text-center">
-                        <span class="text-zinc-500">No logs yet!</span>
-                    </td>
-                </tr>
-                {% endfor %}
-                {% if requestlogs %}
-                <tr>
-                    <td colspan="4" class="px-1 py-3">
-                        <form method="post">
-                            {{ csrf_input }}
-                            <input type="hidden" name="action" value="clear">
-                            <button type="submit" class="flex items-center mx-auto text-xs text-red-500/75 hover:text-red-500">
-                                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="w-4 h-4 mr-2 bi bi-trash3" viewBox="0 0 16 16">
-                                    <path d="M6.5 1h3a.5.5 0 0 1 .5.5v1H6v-1a.5.5 0 0 1 .5-.5ZM11 2.5v-1A1.5 1.5 0 0 0 9.5 0h-3A1.5 1.5 0 0 0 5 1.5v1H2.506a.58.58 0 0 0-.01 0H1.5a.5.5 0 0 0 0 1h.538l.853 10.66A2 2 0 0 0 4.885 16h6.23a2 2 0 0 0 1.994-1.84l.853-10.66h.538a.5.5 0 0 0 0-1h-.995a.59.59 0 0 0-.01 0H11Zm1.958 1-.846 10.58a1 1 0 0 1-.997.92h-6.23a1 1 0 0 1-.997-.92L3.042 3.5h9.916Zm-7.487 1a.5.5 0 0 1 .528.47l.5 8.5a.5.5 0 0 1-.998.06L5 5.03a.5.5 0 0 1 .47-.53Zm5.058 0a.5.5 0 0 1 .47.53l-.5 8.5a.5.5 0 1 1-.998-.06l.5-8.5a.5.5 0 0 1 .528-.47ZM8 4.5a.5.5 0 0 1 .5.5v8.5a.5.5 0 0 1-1 0V5a.5.5 0 0 1 .5-.5Z"/>
-                                </svg>
-                                Clear all
-                            </button>
-                        </form>
-                    </td>
-                </tr>
-                {% endif %}
-            </tbody>
-        </table>
-    </div>
-
-    {% if requestlog %}
-    <div class="px-8 py-6 overflow-auto sm:w-1/2 md:w-3/5">
-        {% with request=requestlog.request %}
-        <div class="flex items-center justify-between">
-            <h3 class="text-lg font-medium">
-                {{ request.method }} <a href="{{ request.absolute_uri }}" class="font-mono hover:underline">{{ request.full_path }}</a>
-            </h3>
-            <form method="POST">
-                {{ csrf_input }}
-                <input type="hidden" name="log" value="{{ requestlog.name }}">
-                <button type="submit" class="flex items-center px-3 py-2 ml-4 text-sm rounded-full bg-zinc-600 hover:bg-zinc-500">
-                    <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 mr-2" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-refresh-cw"><polyline points="23 4 23 10 17 10"></polyline><polyline points="1 20 1 14 7 14"></polyline><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"></path></svg>
-                    replay
-                </button>
-            </form>
-        </div>
-
-        {% if requestlog.exception %}
-        <div class="p-2 mt-4 bg-red-600 rounded text-zinc-100">
-            <h3 class="text-sm font-medium">{{ requestlog.exception.type }} Exception</h3>
-            <pre class="mt-2 overflow-auto text-xs rounded bg-zinc-800 text-zinc-200 max-h-96"><code>
-            {{- requestlog.exception.str -}}
-            </code></pre>
-            <pre class="mt-2 overflow-auto text-xs rounded bg-zinc-800 text-zinc-200 max-h-96"><code>
-            {{- requestlog.exception.args -}}
-            </code></pre>
-            <pre class="mt-2 overflow-auto text-xs rounded bg-zinc-800 text-zinc-200"><code>
-            {{- requestlog.exception.traceback -}}
-            </code></pre>
-        </div>
-        {% endif %}
-
-        {% if request.querydict %}
-        <dl class="px-2 pt-1 pb-2 mt-4 rounded bg-zinc-800">
-        {% for key, value in request.querydict.items() %}
-            <dt class="mt-2 text-xs text-zinc-400">{{ key }}</dt>
-            <dd class="text-xs break-all text-zinc-300"><code>{{ value or "(Empty)" }}</code></dd>
-        {% endfor %}
-        </dl>
-        {% endif %}
-
-        <dl class="mt-4">
-        {% for key, value in request.headers.items() %}
-            <dt class="mt-2 text-xs text-zinc-400">{{ key }}</dt>
-            <dd class="text-xs break-all text-zinc-300"><code>{{ value or "(Empty)" }}</code></dd>
-        {% endfor %}
-        </dl>
-        {% if "body_json" in request %}
-        <pre class="p-2 mt-4 overflow-y-auto text-xs rounded bg-zinc-800 text-zinc-200"><code>{{ request.body_json }}</code></pre>
-        {% else %}
-        <pre class="p-2 mt-4 overflow-y-auto text-xs rounded bg-zinc-800 text-zinc-200 max-h-96"><code>{{ request.body or "(Empty)" }}</code></pre>
-        {% endif %}
-        {% endwith %}
-
-        {% with response=requestlog.response %}
-        <h3 class="mt-10 text-lg font-medium">HTTP <span class="font-mono">{{ response.status_code }}</span></h3>
-        <dl class="mt-4">
-        {% for key, value in response.headers.items() %}
-            <dt class="mt-2 text-xs text-zinc-400">{{ key }}</dt>
-            <dd class="text-xs break-all text-zinc-300"><code>{{ value or "(Empty)" }}</code></dd>
-        {% endfor %}
-        </dl>
-        <pre class="p-2 mt-4 overflow-y-auto text-xs rounded bg-zinc-800 text-zinc-200 max-h-96"><code>{{ response.content or "(Empty)" }}</code></pre>
-        {% endwith %}
-    </div>
-    {% endif %}
-</div>
-
-</body>
-</html>

plain_dev-0.30.1/plain/dev/urls.py

@@ -1,10 +0,0 @@
-from plain.urls import Router, path
-
-from . import views
-
-
-class DevRequestsRouter(Router):
-    namespace = "dev"
-    urls = [
-        path("", views.RequestsView, name="requests"),
-    ]

plain_dev-0.30.1/plain/dev/views.py

@@ -1,39 +0,0 @@
-from plain.http import ResponseRedirect
-from plain.views import TemplateView
-
-from .requests import RequestLog
-
-
-class RequestsView(TemplateView):
-    template_name = "dev/requests.html"
-
-    def get_template_context(self):
-        ctx = super().get_template_context()
-        requestlogs = RequestLog.load_json_logs()
-
-        if self.request.query_params.get("log"):
-            try:
-                requestlog = [
-                    x
-                    for x in requestlogs
-                    if x.get("name") == self.request.query_params["log"]
-                ][0]
-            except IndexError:
-                requestlog = None
-        elif requestlogs:
-            requestlog = requestlogs[0]
-        else:
-            requestlog = None
-
-        ctx["requestlogs"] = requestlogs
-        ctx["requestlog"] = requestlog
-
-        return ctx
-
-    def post(self):
-        if self.request.data.get("action") == "clear":
-            RequestLog.clear()
-            return ResponseRedirect(self.request.path)
-        else:
-            RequestLog.replay_request(self.request.data["log"])
-            return ResponseRedirect(".")