plain.dev 0.38.0__tar.gz → 0.39.1__tar.gz

{plain_dev-0.38.0 → plain_dev-0.39.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.dev
-Version: 0.38.0
+Version: 0.39.1
 Summary: A single command that runs everything you need for local development.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/CHANGELOG.md

@@ -1,5 +1,25 @@
 # plain-dev changelog
 
+## [0.39.1](https://github.com/dropseed/plain/releases/plain-dev@0.39.1) (2025-10-06)
+
+### What's changed
+
+- Added comprehensive type annotations across the entire package to improve IDE support and type checking ([1d00e9f](https://github.com/dropseed/plain/commit/1d00e9f6f))
+
+### Upgrade instructions
+
+- No changes required
+
+## [0.39.0](https://github.com/dropseed/plain/releases/plain-dev@0.39.0) (2025-09-30)
+
+### What's changed
+
+- The `plain dev` command now sets both `PLAIN_LOG_LEVEL` and `PLAIN_FRAMEWORK_LOG_LEVEL` environment variables when a log level is specified, replacing the previous `APP_LOG_LEVEL` setting ([4c5f216](https://github.com/dropseed/plain/commit/4c5f2166c1))
+
+### Upgrade instructions
+
+- No changes required
+
 ## [0.38.0](https://github.com/dropseed/plain/releases/plain-dev@0.38.0) (2025-09-30)
 
 ### What's changed

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/alias.py

@@ -15,7 +15,7 @@ class AliasManager:
     ALIAS_NAME = "p"
 
     @cached_property
-    def shell(self):
+    def shell(self) -> str | None:
         """Detect the current shell."""
         shell = os.environ.get("SHELL", "")
         if "zsh" in shell:
@@ -27,7 +27,7 @@ class AliasManager:
         return None
 
     @cached_property
-    def shell_config_file(self):
+    def shell_config_file(self) -> Path | None:
         """Get the appropriate shell configuration file."""
         home = Path.home()
 
@@ -43,7 +43,7 @@ class AliasManager:
 
         return None
 
-    def _command_exists(self, command):
+    def _command_exists(self, command: str) -> bool:
         """Check if a command exists in the system."""
         try:
             result = subprocess.run(
@@ -53,7 +53,7 @@ class AliasManager:
         except Exception:
             return False
 
-    def _alias_exists(self):
+    def _alias_exists(self) -> bool:
         """Check if the 'p' alias already exists."""
         # First check if 'p' is already a command
         if self._command_exists(self.ALIAS_NAME):
@@ -73,7 +73,7 @@ class AliasManager:
         except (subprocess.TimeoutExpired, Exception):
             return False
 
-    def _add_alias_to_shell(self):
+    def _add_alias_to_shell(self) -> bool:
         """Add the alias to the shell configuration file."""
         if not self.shell_config_file or not self.shell_config_file.exists():
             return False
@@ -106,7 +106,7 @@ class AliasManager:
             )
             return False
 
-    def check_and_prompt(self):
+    def check_and_prompt(self) -> None:
         """Check if alias exists and prompt user to set it up if needed."""
         # Only suggest if project uses uv (has uv.lock file)
         if not Path("uv.lock").exists():

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/cli.py

@@ -3,6 +3,7 @@ import subprocess
 import sys
 import time
 from importlib.metadata import entry_points
+from typing import Any
 
 import click
 
@@ -17,12 +18,12 @@ from .services import ServicesProcess
 class DevGroup(click.Group):
     """Custom group that ensures *services* are running on CLI startup."""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self._auto_start_services()
 
     @staticmethod
-    def _auto_start_services():
+    def _auto_start_services() -> None:
         """Start dev *services* in the background if not already running."""
 
         # Check if we're in CI and auto-start is not explicitly enabled
@@ -118,7 +119,14 @@ class DevGroup(click.Group):
     default=False,
     help="Stop the background process",
 )
-def cli(ctx, port, hostname, log_level, start, stop):
+def cli(
+    ctx: click.Context,
+    port: str,
+    hostname: str | None,
+    log_level: str,
+    start: bool,
+    stop: bool,
+) -> None:
     """Start local development"""
     if ctx.invoked_subcommand:
         return
@@ -173,17 +181,21 @@ def cli(ctx, port, hostname, log_level, start, stop):
     # Check and prompt for alias setup
     AliasManager().check_and_prompt()
 
-    dev.setup(port=port, hostname=hostname, log_level=log_level)
+    dev.setup(
+        port=int(port) if port else None,
+        hostname=hostname,
+        log_level=log_level if log_level else None,
+    )
     returncode = dev.run()
     if returncode:
         sys.exit(returncode)
 
 
 @cli.command()
-def debug():
+def debug() -> None:
     """Connect to the remote debugger"""
 
-    def _connect():
+    def _connect() -> subprocess.CompletedProcess[bytes]:
         if subprocess.run(["which", "nc"], capture_output=True).returncode == 0:
             return subprocess.run(["nc", "-C", "localhost", "4444"])
         else:
@@ -208,7 +220,7 @@ def debug():
 @cli.command()
 @click.option("--start", is_flag=True, help="Start in the background")
 @click.option("--stop", is_flag=True, help="Stop the background process")
-def services(start, stop):
+def services(start: bool, stop: bool) -> None:
     """Start additional services defined in pyproject.toml"""
 
     if start and stop:
@@ -248,7 +260,7 @@ def services(start, stop):
 @click.option("--pid", type=int, help="PID to show logs for")
 @click.option("--path", is_flag=True, help="Output log file path")
 @click.option("--services", is_flag=True, help="Show logs for services")
-def logs(follow, pid, path, services):
+def logs(follow: bool, pid: int | None, path: bool, services: bool) -> None:
     """Show logs from recent plain dev runs."""
 
     if services:
@@ -284,7 +296,7 @@ def logs(follow, pid, path, services):
     "--list", "-l", "show_list", is_flag=True, help="List available entrypoints"
 )
 @click.argument("entrypoint", required=False)
-def entrypoint(show_list, entrypoint):
+def entrypoint(show_list: bool, entrypoint: str | None) -> None:
     """Entrypoints registered under plain.dev"""
     if not show_list and not entrypoint:
         raise click.UsageError("Please provide an entrypoint name or use --list")

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/contribute/cli.py

@@ -17,7 +17,7 @@ from plain.cli import register_cli
     "--all", "all_packages", is_flag=True, help="Link all installed plain packages"
 )
 @click.argument("packages", nargs=-1)
-def cli(packages, repo, reset, all_packages):
+def cli(packages: tuple[str, ...], repo: str, reset: bool, all_packages: bool) -> None:
     """Contribute to plain by linking packages locally."""
 
     if reset:
@@ -35,11 +35,11 @@ def cli(packages, repo, reset, all_packages):
 
         return
 
-    packages = list(packages)
+    packages_list = list(packages)
 
-    repo = Path(repo)
-    if not repo.exists():
-        click.secho(f"Repo not found at {repo}", fg="red")
+    repo_path = Path(repo)
+    if not repo_path.exists():
+        click.secho(f"Repo not found at {repo_path}", fg="red")
         return
 
     repo_branch = (
@@ -50,12 +50,12 @@ def cli(packages, repo, reset, all_packages):
                 "--abbrev-ref",
                 "HEAD",
             ],
-            cwd=repo,
+            cwd=repo_path,
         )
         .decode()
         .strip()
     )
-    click.secho(f"Using repo at {repo} ({repo_branch} branch)", bold=True)
+    click.secho(f"Using repo at {repo_path} ({repo_branch} branch)", bold=True)
 
     plain_packages = []
     plainx_packages = []
@@ -70,7 +70,7 @@ def cli(packages, repo, reset, all_packages):
             click.secho("No installed packages found", fg="red")
             sys.exit(1)
 
-        packages = []
+        packages_list = []
         for line in installed_packages.splitlines():
             if not line.startswith("plain"):
                 continue
@@ -78,7 +78,7 @@ def cli(packages, repo, reset, all_packages):
             if package.startswith("plainx-"):
                 skipped_plainx_packages.append(package)
             else:
-                packages.append(package)
+                packages_list.append(package)
 
         if skipped_plainx_packages:
             click.secho(
@@ -88,13 +88,13 @@ def cli(packages, repo, reset, all_packages):
                 fg="yellow",
             )
 
-    for package in packages:
+    for package in packages_list:
         package = package.replace(".", "-")
-        click.secho(f"Linking {package} to {repo}", bold=True)
+        click.secho(f"Linking {package} to {repo_path}", bold=True)
         if package == "plain" or package.startswith("plain-"):
-            plain_packages.append(str(repo / package))
+            plain_packages.append(str(repo_path / package))
         elif package.startswith("plainx-"):
-            plainx_packages.append(str(repo))
+            plainx_packages.append(str(repo_path))
         else:
             raise click.UsageError(f"Unknown package {package}")
 

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/core.py

@@ -26,7 +26,9 @@ class DevProcess(ProcessManager):
     pidfile = PLAIN_TEMP_PATH / "dev" / "dev.pid"
     log_dir = PLAIN_TEMP_PATH / "dev" / "logs" / "run"
 
-    def setup(self, *, port, hostname, log_level):
+    def setup(
+        self, *, port: int | None, hostname: str | None, log_level: str | None
+    ) -> None:
         if not hostname:
             project_name = os.path.basename(
                 os.getcwd()
@@ -70,8 +72,8 @@ class DevProcess(ProcessManager):
         }
 
         if log_level:
+            self.plain_env["PLAIN_FRAMEWORK_LOG_LEVEL"] = log_level.upper()
             self.plain_env["PLAIN_LOG_LEVEL"] = log_level.upper()
-            self.plain_env["APP_LOG_LEVEL"] = log_level.upper()
 
         self.custom_process_env = {
             **self.plain_env,
@@ -112,19 +114,19 @@ class DevProcess(ProcessManager):
 
         self.init_poncho(self.console.out)
 
-    def _find_open_port(self, start_port):
+    def _find_open_port(self, start_port: int) -> int:
         port = start_port
         while not self._port_available(port):
             port += 1
         return port
 
-    def _port_available(self, port):
+    def _port_available(self, port: int) -> bool:
         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):
+    def run(self) -> int:
         self.write_pidfile()
         mkcert_manager = MkcertManager()
         mkcert_manager.setup_mkcert(install_path=Path.home() / ".plain" / "dev")
@@ -181,9 +183,12 @@ class DevProcess(ProcessManager):
 
         return self.poncho.returncode
 
-    def symlink_plain_src(self):
+    def symlink_plain_src(self) -> None:
         """Symlink the plain package into .plain so we can look at it easily"""
-        plain_path = Path(find_spec("plain.runtime").origin).parent.parent
+        spec = find_spec("plain.runtime")
+        if spec is None or spec.origin is None:
+            return None
+        plain_path = Path(spec.origin).parent.parent
         if not PLAIN_TEMP_PATH.exists():
             PLAIN_TEMP_PATH.mkdir()
 
@@ -204,7 +209,7 @@ class DevProcess(ProcessManager):
         if plain_path.exists() and not symlink_path.exists():
             symlink_path.symlink_to(plain_path)
 
-    def modify_hosts_file(self):
+    def modify_hosts_file(self) -> None:
         """Modify the hosts file to map the custom domain to 127.0.0.1."""
         entry_identifier = "# Added by plain"
         hosts_entry = f"127.0.0.1 {self.hostname}  {entry_identifier}"
@@ -259,14 +264,14 @@ class DevProcess(ProcessManager):
                 )
                 sys.exit(1)
 
-    def run_preflight(self):
+    def run_preflight(self) -> None:
         if subprocess.run(
             ["plain", "preflight", "check", "--quiet"], env=self.plain_env
         ).returncode:
             click.secho("Preflight check failed!", fg="red")
             sys.exit(1)
 
-    def add_gunicorn(self):
+    def add_gunicorn(self) -> None:
         # Watch .env files for reload
         extra_watch_files = []
         for f in os.listdir(APP_PATH.parent):
@@ -306,7 +311,7 @@ class DevProcess(ProcessManager):
 
         self.poncho.add_process("plain", gunicorn, env=self.plain_env)
 
-    def add_entrypoints(self):
+    def add_entrypoints(self) -> None:
         for entry_point in entry_points().select(group=ENTRYPOINT_GROUP):
             self.poncho.add_process(
                 entry_point.name,
@@ -314,7 +319,7 @@ class DevProcess(ProcessManager):
                 env=self.plain_env,
             )
 
-    def add_pyproject_run(self):
+    def add_pyproject_run(self) -> None:
         """Additional processes that only run during `plain dev`."""
         if not has_pyproject_toml(APP_PATH.parent):
             return

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/debug.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from . import pdb
 
 
-def set_breakpoint_hook():
+def set_breakpoint_hook() -> None:
     """
     If a `plain dev` process is running, set a
     breakpoint hook to trigger a remote debugger.
@@ -18,7 +18,7 @@ def set_breakpoint_hook():
         # we're in a process managed by `plain dev`
         return
 
-    def _breakpoint():
+    def _breakpoint() -> None:
         system = platform.system()
 
         if system == "Darwin":
@@ -38,4 +38,4 @@ def set_breakpoint_hook():
             frame=sys._getframe().f_back,
         )
 
-    sys.breakpointhook = _breakpoint
+    sys.breakpointhook = _breakpoint  # type: ignore[assignment]

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/entrypoints.py

@@ -5,7 +5,7 @@ from dotenv import load_dotenv
 from .debug import set_breakpoint_hook
 
 
-def setup():
+def setup() -> None:
     # Make sure our clis are registered
     # since this isn't an installed app
     from .cli import cli  # noqa

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/mkcert.py

@@ -4,15 +4,16 @@ import subprocess
 import sys
 import time
 import urllib.request
+from pathlib import Path
 
 import click
 
 
 class MkcertManager:
-    def __init__(self):
+    def __init__(self) -> None:
         self.mkcert_bin = None
 
-    def setup_mkcert(self, install_path):
+    def setup_mkcert(self, install_path: Path) -> None:
         """Set up mkcert by checking if it's installed or downloading the binary and installing the local CA."""
         if mkcert_path := shutil.which("mkcert"):
             # mkcert is already installed somewhere
@@ -59,7 +60,7 @@ class MkcertManager:
             )
             subprocess.run([self.mkcert_bin, "-install"], check=True)
 
-    def is_mkcert_ca_installed(self):
+    def is_mkcert_ca_installed(self) -> bool:
         """Check if mkcert local CA is already installed using mkcert -check."""
         try:
             result = subprocess.run([self.mkcert_bin, "-check"], capture_output=True)
@@ -71,7 +72,7 @@ class MkcertManager:
             click.secho(f"Error checking mkcert CA installation: {e}", fg="red")
             return False
 
-    def generate_certs(self, domain, storage_path):
+    def generate_certs(self, domain: str, storage_path: Path) -> tuple[Path, Path]:
         cert_path = storage_path / f"{domain}-cert.pem"
         key_path = storage_path / f"{domain}-key.pem"
         timestamp_path = storage_path / f"{domain}.timestamp"

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/pdb.py

@@ -3,19 +3,22 @@ import logging
 import re
 import socket
 import sys
+from collections.abc import Iterator
 from pdb import Pdb
+from types import FrameType
+from typing import Any
 
 log = logging.getLogger(__name__)
 
 
-def cry(message, stderr=sys.__stderr__):
+def cry(message: str, stderr: Any = sys.__stderr__) -> None:
     log.critical(message)
     print(message, file=stderr)
-    stderr.flush()
+    stderr.flush()  # type: ignore[possibly-unbound]
 
 
 class LF2CRLF_FileWrapper:
-    def __init__(self, connection):
+    def __init__(self, connection: socket.socket) -> None:
         self.connection = connection
         self.stream = fh = connection.makefile("rw")
         self.read = fh.read
@@ -30,17 +33,19 @@ class LF2CRLF_FileWrapper:
             self._send = connection.sendall
 
     @property
-    def encoding(self):
+    def encoding(self) -> str | None:
         return self.stream.encoding
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[str]:
         return self.stream.__iter__()
 
-    def write(self, data, nl_rex=re.compile("\r?\n")):
+    def write(self, data: str, nl_rex: re.Pattern[str] = re.compile("\r?\n")) -> None:
         data = nl_rex.sub("\r\n", data)
         self._send(data)
 
-    def writelines(self, lines, nl_rex=re.compile("\r?\n")):
+    def writelines(
+        self, lines: list[str], nl_rex: re.Pattern[str] = re.compile("\r?\n")
+    ) -> None:
         for line in lines:
             self.write(line, nl_rex)
 
@@ -62,7 +67,9 @@ class DevPdb(Pdb):
 
     active_instance = None
 
-    def __init__(self, host, port, patch_stdstreams=False, quiet=False):
+    def __init__(
+        self, host: str, port: int, patch_stdstreams: bool = False, quiet: bool = False
+    ) -> None:
         self._quiet = quiet
         listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
@@ -93,7 +100,7 @@ class DevPdb(Pdb):
                 setattr(sys, name, self.handle)
         DevPdb.active_instance = self
 
-    def __restore(self):
+    def __restore(self) -> None:
         if self.backup and not self._quiet:
             cry(f"Restoring streams: {self.backup} ...")
         for name, fh in self.backup:
@@ -101,13 +108,13 @@ class DevPdb(Pdb):
         self.handle.close()
         DevPdb.active_instance = None
 
-    def do_quit(self, arg):
+    def do_quit(self, arg: str) -> Any:
         self.__restore()
         return Pdb.do_quit(self, arg)
 
     do_q = do_exit = do_quit
 
-    def set_trace(self, frame=None):
+    def set_trace(self, frame: FrameType | None = None) -> None:
         if frame is None:
             frame = sys._getframe().f_back
         try:
@@ -118,8 +125,12 @@ class DevPdb(Pdb):
 
 
 def set_trace(
-    frame=None, host="127.0.0.1", port=4444, patch_stdstreams=False, quiet=False
-):
+    frame: FrameType | None = None,
+    host: str = "127.0.0.1",
+    port: int = 4444,
+    patch_stdstreams: bool = False,
+    quiet: bool = False,
+) -> None:
     """
     Opens a remote PDB over a host:port.
     """

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/poncho/color.py

@@ -1,3 +1,5 @@
+from collections.abc import Iterator
+
 ANSI_COLOURS = ["grey", "red", "green", "yellow", "blue", "magenta", "cyan", "white"]
 
 for i, name in enumerate(ANSI_COLOURS):
@@ -5,7 +7,7 @@ for i, name in enumerate(ANSI_COLOURS):
     globals()["intense_" + name] = str(30 + i) + ";1"
 
 
-def get_colors():
+def get_colors() -> Iterator[str]:
     cs = [
         "cyan",
         "yellow",

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/poncho/compat.py

@@ -18,15 +18,15 @@ if ON_WINDOWS:
 class ProcessManager:
     if ON_WINDOWS:
 
-        def terminate(self, pid):
+        def terminate(self, pid: int) -> None:
             # The first argument to OpenProcess represents the desired access
             # to the process. 1 represents the PROCESS_TERMINATE access right.
-            handle = ctypes.windll.kernel32.OpenProcess(1, False, pid)
-            ctypes.windll.kernel32.TerminateProcess(handle, -1)
-            ctypes.windll.kernel32.CloseHandle(handle)
+            handle = ctypes.windll.kernel32.OpenProcess(1, False, pid)  # type: ignore[attr-defined]
+            ctypes.windll.kernel32.TerminateProcess(handle, -1)  # type: ignore[attr-defined]
+            ctypes.windll.kernel32.CloseHandle(handle)  # type: ignore[attr-defined]
     else:
 
-        def terminate(self, pid):
+        def terminate(self, pid: int) -> None:
             try:
                 os.killpg(pid, signal.SIGTERM)
             except OSError as e:
@@ -35,12 +35,12 @@ class ProcessManager:
 
     if ON_WINDOWS:
 
-        def kill(self, pid):
+        def kill(self, pid: int) -> None:
             # There's no SIGKILL on Win32...
             self.terminate(pid)
     else:
 
-        def kill(self, pid):
+        def kill(self, pid: int) -> None:
             try:
                 os.killpg(pid, signal.SIGKILL)
             except OSError as e:

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/poncho/manager.py

@@ -2,6 +2,7 @@ import datetime
 import multiprocessing
 import queue
 import signal
+from types import FrameType
 
 from .color import get_colors
 from .compat import ProcessManager
@@ -45,7 +46,7 @@ class Manager:
     #: this will contain a return code that can be used with `sys.exit`.
     returncode = None
 
-    def __init__(self, printer=None):
+    def __init__(self, printer: Printer | None = None) -> None:
         self.events = multiprocessing.Queue()
         self.returncode = None
 
@@ -61,7 +62,14 @@ class Manager:
 
         self._terminating = False
 
-    def add_process(self, name, cmd, quiet=False, env=None, cwd=None):
+    def add_process(
+        self,
+        name: str,
+        cmd: str,
+        quiet: bool = False,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+    ) -> Process:
         """
         Add a process to this manager instance. The process will not be started
         until :func:`~poncho.manager.Manager.loop` is called.
@@ -82,13 +90,13 @@ class Manager:
 
         return proc
 
-    def num_processes(self):
+    def num_processes(self) -> int:
         """
         Return the number of processes managed by this instance.
         """
         return len(self._processes)
 
-    def loop(self):
+    def loop(self) -> None:
         """
         Start all the added processes and multiplex their output onto the bound
         printer (which by default will print to STDOUT).
@@ -99,7 +107,7 @@ class Manager:
         This method will block until all the processes have terminated.
         """
 
-        def _terminate(signum, frame):
+        def _terminate(signum: int, frame: FrameType | None) -> None:
             self._system_print("{} received\n".format(SIGNALS[signum]["name"]))
             self.returncode = SIGNALS[signum]["rc"]
             self.terminate()
@@ -149,7 +157,7 @@ class Manager:
                 if waiting > datetime.timedelta(seconds=KILL_WAIT):
                     self.kill()
 
-    def terminate(self):
+    def terminate(self) -> None:
         """
         Terminate all processes managed by this ProcessManager.
         """
@@ -158,13 +166,13 @@ class Manager:
         self._terminating = True
         self._killall()
 
-    def kill(self):
+    def kill(self) -> None:
         """
         Kill all processes managed by this ProcessManager.
         """
         self._killall(force=True)
 
-    def _killall(self, force=False):
+    def _killall(self, force: bool = False) -> None:
         """Kill all remaining processes, forcefully if requested."""
         for_termination = []
 
@@ -183,26 +191,26 @@ class Manager:
             else:
                 self._procmgr.terminate(p["pid"])
 
-    def _start_process(self, name):
+    def _start_process(self, name: str) -> None:
         p = self._processes[name]
         p["process"] = multiprocessing.Process(
             name=name, target=p["obj"].run, args=(self.events, True)
         )
         p["process"].start()
 
-    def _is_running(self):
+    def _is_running(self) -> bool:
         return any(p.get("pid") is not None for _, p in self._processes.items())
 
-    def _all_started(self):
+    def _all_started(self) -> bool:
         return all(p.get("pid") is not None for _, p in self._processes.items())
 
-    def _all_stopped(self):
+    def _all_stopped(self) -> bool:
         return all(p.get("returncode") is not None for _, p in self._processes.items())
 
-    def _any_stopped(self):
+    def _any_stopped(self) -> bool:
         return any(p.get("returncode") is not None for _, p in self._processes.items())
 
-    def _system_print(self, data):
+    def _system_print(self, data: str) -> None:
         self._printer.write(
             Message(
                 type="line",

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/poncho/printer.py

@@ -1,6 +1,7 @@
 import re
 from collections import namedtuple
 from pathlib import Path
+from typing import Any
 
 Message = namedtuple("Message", "type data time name color")
 
@@ -14,13 +15,13 @@ class Printer:
 
     def __init__(
         self,
-        print_func,
-        time_format="%H:%M:%S",
-        width=0,
-        color=True,
-        prefix=True,
-        log_file=None,
-    ):
+        print_func: Any,
+        time_format: str = "%H:%M:%S",
+        width: int = 0,
+        color: bool = True,
+        prefix: bool = True,
+        log_file: Path | str | None = None,
+    ) -> None:
         self.print_func = print_func
         self.time_format = time_format
         self.width = width
@@ -33,7 +34,7 @@ class Printer:
         else:
             self.log_file = None
 
-    def write(self, message):
+    def write(self, message: Message) -> None:
         if message.type != "line":
             raise RuntimeError('Printer can only process messages of type "line"')
 
@@ -72,13 +73,13 @@ class Printer:
                 self.log_file.write(plain + "\n")
                 self.log_file.flush()
 
-    def close(self):
+    def close(self) -> None:
         if self.log_file and hasattr(self.log_file, "close"):
             self.log_file.close()
 
 
-def _color_string(color, s):
-    def _ansi(code):
+def _color_string(color: str, s: str) -> str:
+    def _ansi(code: str | int) -> str:
         return f"\033[{code}m"
 
     return f"{_ansi(0)}{_ansi(color)}{s}{_ansi(0)}"

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/poncho/process.py

@@ -2,6 +2,8 @@ import datetime
 import os
 import signal
 import subprocess
+from queue import Queue
+from typing import Any
 
 from .compat import ON_WINDOWS
 from .printer import Message
@@ -14,7 +16,15 @@ class Process:
     lifecycle events and output to a queue.
     """
 
-    def __init__(self, cmd, name=None, color=None, quiet=False, env=None, cwd=None):
+    def __init__(
+        self,
+        cmd: str,
+        name: str | None = None,
+        color: str | None = None,
+        quiet: bool = False,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+    ) -> None:
         self.cmd = cmd
         self.color = color
         self.quiet = quiet
@@ -26,7 +36,9 @@ class Process:
         self._child = None
         self._child_ctor = Popen
 
-    def run(self, events=None, ignore_signals=False):
+    def run(
+        self, events: Queue[Message] | None = None, ignore_signals: bool = False
+    ) -> None:
         self._events = events
         self._child = self._child_ctor(self.cmd, env=self.env, cwd=self.cwd)
         self._send_message({"pid": self._child.pid}, type="start")
@@ -46,7 +58,7 @@ class Process:
 
         self._send_message({"returncode": self._child.returncode}, type="stop")
 
-    def _send_message(self, data, type="line"):
+    def _send_message(self, data: bytes | dict[str, Any], type: str = "line") -> None:
         if self._events is not None:
             self._events.put(
                 Message(
@@ -60,7 +72,7 @@ class Process:
 
 
 class Popen(subprocess.Popen):
-    def __init__(self, cmd, **kwargs):
+    def __init__(self, cmd: str, **kwargs: Any) -> None:
         start_new_session = kwargs.pop("start_new_session", True)
         options = {
             "stdout": subprocess.PIPE,

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/precommit/cli.py

@@ -11,7 +11,7 @@ from plain.cli import register_cli
 from plain.cli.print import print_event
 
 
-def install_git_hook():
+def install_git_hook() -> None:
     hook_path = os.path.join(".git", "hooks", "pre-commit")
     if os.path.exists(hook_path):
         print("pre-commit hook already exists")
@@ -28,7 +28,7 @@ plain pre-commit"""
 @register_cli("pre-commit")
 @click.command()
 @click.option("--install", is_flag=True)
-def cli(install):
+def cli(install: bool) -> None:
     """Git pre-commit checks"""
     if install:
         install_git_hook()
@@ -96,7 +96,7 @@ def cli(install):
             sys.exit(result.returncode)
 
 
-def plain_db_connected():
+def plain_db_connected() -> bool:
     result = subprocess.run(
         [
             "plain",
@@ -109,7 +109,7 @@ def plain_db_connected():
     return result.returncode == 0
 
 
-def check_short(message, *args):
+def check_short(message: str, *args: str) -> None:
     print_event(message, newline=False)
     result = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
     if result.returncode != 0:

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/process.py

@@ -1,6 +1,7 @@
 import os
 import time
 from pathlib import Path
+from typing import Any
 
 from .poncho.manager import Manager as PonchoManager
 from .poncho.printer import Printer
@@ -110,7 +111,7 @@ class ProcessManager:
         self.log_path = self.log_dir / f"{self.pid}.log"
         return self.log_path
 
-    def init_poncho(self, print_func) -> PonchoManager:  # noqa: D401
+    def init_poncho(self, print_func: Any) -> PonchoManager:  # noqa: D401
         """Return a :class:`~plain.dev.poncho.manager.Manager` instance."""
         if self.log_path is None:
             self.prepare_log()

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/services.py

@@ -1,6 +1,7 @@
 import os
 import tomllib
 from pathlib import Path
+from typing import Any
 
 from plain.runtime import APP_PATH, PLAIN_TEMP_PATH
 
@@ -13,7 +14,7 @@ class ServicesProcess(ProcessManager):
     log_dir = PLAIN_TEMP_PATH / "dev" / "logs" / "services"
 
     @staticmethod
-    def get_services(root):
+    def get_services(root: str | Path) -> dict[str, Any]:
         if not has_pyproject_toml(root):
             return {}
 
@@ -27,7 +28,7 @@ class ServicesProcess(ProcessManager):
             .get("services", {})
         )
 
-    def run(self):
+    def run(self) -> None:
         self.write_pidfile()
         self.prepare_log()
         self.init_poncho(print)

{plain_dev-0.38.0 → plain_dev-0.39.1}/plain/dev/utils.py

@@ -1,5 +1,5 @@
 from pathlib import Path
 
 
-def has_pyproject_toml(target_path):
+def has_pyproject_toml(target_path: str | Path) -> bool:
     return (Path(target_path) / "pyproject.toml").exists()

{plain_dev-0.38.0 → plain_dev-0.39.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.dev"
-version = "0.38.0"
+version = "0.39.1"
 description = "A single command that runs everything you need for local development."
 authors = [{name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev"}]
 license = "BSD-3-Clause"

plain_dev-0.38.0/plain/dev/poncho/__init__.py

@@ -1,4 +0,0 @@
-try:
-    from ._version import __version__
-except ImportError:
-    __version__ = "0.0.0+unknown"