plain.dev 0.5.0__tar.gz → 0.7.0__tar.gz

{plain_dev-0.5.0 → plain_dev-0.7.0}/LICENSE

@@ -1,3 +1,5 @@
+## Plain is released under the BSD 3-Clause License
+
 BSD 3-Clause License
 
 Copyright (c) 2023, Dropseed, LLC
@@ -26,3 +28,26 @@ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+## This package contains code forked from github.com/nickstenning/honcho
+
+Copyright (c) 2012-2024 Nick Stenning, https://whiteink.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{plain_dev-0.5.0 → plain_dev-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plain.dev
-Version: 0.5.0
+Version: 0.7.0
 Summary: Local development tools for Plain.
 Home-page: https://plainframework.com
 License: BSD-3-Clause
@@ -14,11 +14,9 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: click (>=8.0.0)
 Requires-Dist: debugpy (>=1.6.3,<2.0.0)
 Requires-Dist: gunicorn (>20)
-Requires-Dist: honcho (>=1.1.0,<2.0.0)
 Requires-Dist: plain (<1.0.0)
 Requires-Dist: psycopg[binary] (>=3.2.2,<4.0.0)
 Requires-Dist: requests (>=2.0.0)
-Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
 Project-URL: Documentation, https://plainframework.com/docs/
 Project-URL: Repository, https://github.com/dropseed/plain
 Description-Content-Type: text/markdown

plain_dev-0.7.0/plain/dev/cli.py

@@ -0,0 +1,288 @@
+import json
+import os
+import platform
+import subprocess
+import sys
+from importlib.metadata import entry_points
+from importlib.util import find_spec
+from pathlib import Path
+
+import click
+import tomllib
+
+from plain.runtime import APP_PATH, settings
+
+from .db import cli as db_cli
+from .mkcert import MkcertManager
+from .pid import Pid
+from .poncho.manager import Manager as PonchoManager
+from .services import Services
+from .utils import has_pyproject_toml
+
+ENTRYPOINT_GROUP = "plain.dev"
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+@click.option(
+    "--port",
+    "-p",
+    default=8443,
+    type=int,
+    help="Port to run the web server on",
+    envvar="PORT",
+)
+def cli(ctx, port):
+    """Start local development"""
+
+    if ctx.invoked_subcommand:
+        return
+
+    returncode = Dev(port=port).run()
+    if returncode:
+        sys.exit(returncode)
+
+
+@cli.command()
+def services():
+    """Start additional services defined in pyproject.toml"""
+    Services().run()
+
+
+@cli.command()
+@click.option(
+    "--list", "-l", "show_list", is_flag=True, help="List available entrypoints"
+)
+@click.argument("entrypoint", required=False)
+def entrypoint(show_list, entrypoint):
+    f"""Entrypoints registered under {ENTRYPOINT_GROUP}"""
+    if not show_list and not entrypoint:
+        click.secho("Please provide an entrypoint name or use --list", fg="red")
+        sys.exit(1)
+
+    for entry_point in entry_points().select(group=ENTRYPOINT_GROUP):
+        if show_list:
+            click.echo(entry_point.name)
+        elif entrypoint == entry_point.name:
+            entry_point.load()()
+
+
+class Dev:
+    def __init__(self, *, port):
+        self.poncho = PonchoManager()
+        self.port = port
+        self.plain_env = {
+            **os.environ,
+            "PYTHONUNBUFFERED": "true",
+        }
+        self.custom_process_env = {
+            **self.plain_env,
+            "PORT": str(self.port),
+            "PYTHONPATH": os.path.join(APP_PATH.parent, "app"),
+        }
+        self.project_name = os.path.basename(os.getcwd())
+        self.domain = f"{self.project_name}.localhost"
+        self.ssl_cert_path = None
+        self.ssl_key_path = None
+
+    def run(self):
+        pid = Pid()
+        pid.write()
+
+        try:
+            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(
+                domain=self.domain,
+                storage_path=Path(settings.PLAIN_TEMP_PATH) / "dev" / "certs",
+            )
+            self.modify_hosts_file()
+            self.set_csrf_trusted_origins()
+            self.set_allowed_hosts()
+            self.run_preflight()
+
+            # Processes for poncho to run simultaneously
+            self.add_gunicorn()
+            self.add_entrypoints()
+            self.add_pyproject_run()
+            self.add_services()
+
+            # Output the clickable link before starting the manager loop
+            url = f"https://{self.domain}:{self.port}/"
+            click.secho(
+                f"\nYour application is running at: {click.style(url, fg='green', underline=True)}\n",
+                bold=True,
+            )
+
+            self.poncho.loop()
+
+            return self.poncho.returncode
+        finally:
+            pid.rm()
+
+    def modify_hosts_file(self):
+        """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.domain}  {entry_identifier}"
+
+        if platform.system() == "Windows":
+            hosts_path = Path(r"C:\Windows\System32\drivers\etc\hosts")
+            try:
+                with hosts_path.open("r") as f:
+                    content = f.read()
+
+                if hosts_entry in content:
+                    return  # Entry already exists; no action needed
+
+                # Entry does not exist; add it
+                with hosts_path.open("a") as f:
+                    f.write(f"{hosts_entry}\n")
+                click.secho(f"Added {self.domain} to {hosts_path}", bold=True)
+            except PermissionError:
+                click.secho(
+                    "Permission denied while modifying hosts file. Please run the script as an administrator.",
+                    fg="red",
+                )
+                sys.exit(1)
+        else:
+            # For macOS and Linux
+            hosts_path = Path("/etc/hosts")
+            try:
+                with hosts_path.open("r") as f:
+                    content = f.read()
+
+                if hosts_entry in content:
+                    return  # Entry already exists; no action needed
+
+                # Entry does not exist; append it using sudo
+                click.secho(
+                    "Modifying /etc/hosts file. You may be prompted for your password.",
+                    bold=True,
+                )
+                cmd = f"echo '{hosts_entry}' | sudo tee -a {hosts_path} >/dev/null"
+                subprocess.run(cmd, shell=True, check=True)
+                click.secho(f"Added {self.domain} to {hosts_path}", bold=True)
+            except PermissionError:
+                click.secho(
+                    "Permission denied while accessing hosts file.",
+                    fg="red",
+                )
+                sys.exit(1)
+            except subprocess.CalledProcessError:
+                click.secho(
+                    "Failed to modify hosts file. Please ensure you have sudo privileges.",
+                    fg="red",
+                )
+                sys.exit(1)
+
+    def set_csrf_trusted_origins(self):
+        csrf_trusted_origins = json.dumps(
+            [
+                f"https://{self.domain}:{self.port}",
+            ]
+        )
+
+        click.secho(
+            f"Automatically set PLAIN_CSRF_TRUSTED_ORIGINS={click.style(csrf_trusted_origins, underline=True)}",
+            bold=True,
+        )
+
+        # Set environment variables
+        self.plain_env["PLAIN_CSRF_TRUSTED_ORIGINS"] = csrf_trusted_origins
+        self.custom_process_env["PLAIN_CSRF_TRUSTED_ORIGINS"] = csrf_trusted_origins
+
+    def set_allowed_hosts(self):
+        allowed_hosts = json.dumps([self.domain])
+
+        click.secho(
+            f"Automatically set PLAIN_ALLOWED_HOSTS={click.style(allowed_hosts, underline=True)}",
+            bold=True,
+        )
+
+        # Set environment variables
+        self.plain_env["PLAIN_ALLOWED_HOSTS"] = allowed_hosts
+        self.custom_process_env["PLAIN_ALLOWED_HOSTS"] = allowed_hosts
+
+    def run_preflight(self):
+        if subprocess.run(["plain", "preflight"], env=self.plain_env).returncode:
+            click.secho("Preflight check failed!", fg="red")
+            sys.exit(1)
+
+    def add_gunicorn(self):
+        plain_db_installed = find_spec("plain.models") is not None
+
+        # Watch .env files for reload
+        extra_watch_files = []
+        for f in os.listdir(APP_PATH.parent):
+            if f.startswith(".env"):
+                extra_watch_files.append(f)
+
+        reload_extra = " ".join(f"--reload-extra-file {f}" for f in extra_watch_files)
+        gunicorn_cmd = [
+            "gunicorn",
+            "--bind",
+            f"{self.domain}:{self.port}",
+            "--certfile",
+            str(self.ssl_cert_path),
+            "--keyfile",
+            str(self.ssl_key_path),
+            "--reload",
+            "plain.wsgi:app",
+            "--timeout",
+            "60",
+            "--access-logfile",
+            "-",
+            "--error-logfile",
+            "-",
+            *reload_extra.split(),
+            "--access-logformat",
+            "'\"%(r)s\" status=%(s)s length=%(b)s dur=%(M)sms'",
+        ]
+        gunicorn = " ".join(gunicorn_cmd)
+
+        if plain_db_installed:
+            runserver_cmd = f"plain models db-wait && plain migrate && {gunicorn}"
+        else:
+            runserver_cmd = gunicorn
+
+        if "WEB_CONCURRENCY" not in self.plain_env:
+            # Default to two workers to prevent lockups
+            self.plain_env["WEB_CONCURRENCY"] = "2"
+
+        self.poncho.add_process("plain", runserver_cmd, env=self.plain_env)
+
+    def add_entrypoints(self):
+        for entry_point in entry_points().select(group=ENTRYPOINT_GROUP):
+            self.poncho.add_process(
+                f"plain dev entrypoint {entry_point.name}", env=self.plain_env
+            )
+
+    def add_pyproject_run(self):
+        if not has_pyproject_toml(APP_PATH.parent):
+            return
+
+        with open(Path(APP_PATH.parent, "pyproject.toml"), "rb") as f:
+            pyproject = tomllib.load(f)
+
+        run_commands = (
+            pyproject.get("tool", {}).get("plain", {}).get("dev", {}).get("run", {})
+        )
+        for name, data in run_commands.items():
+            env = {
+                **self.custom_process_env,
+                **data.get("env", {}),
+            }
+            self.poncho.add_process(name, data["cmd"], env=env)
+
+    def add_services(self):
+        services = Services.get_services(APP_PATH.parent)
+        for name, data in services.items():
+            env = {
+                **os.environ,
+                "PYTHONUNBUFFERED": "true",
+                **data.get("env", {}),
+            }
+            self.poncho.add_process(name, data["cmd"], env=env)
+
+
+cli.add_command(db_cli)

plain_dev-0.7.0/plain/dev/mkcert.py

@@ -0,0 +1,96 @@
+import platform
+import shutil
+import subprocess
+import sys
+import urllib.request
+
+import click
+
+
+class MkcertManager:
+    def __init__(self):
+        self.mkcert_bin = None
+
+    def setup_mkcert(self, install_path):
+        """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
+            self.mkcert_bin = mkcert_path
+        else:
+            self.mkcert_bin = install_path / "mkcert"
+            install_path.mkdir(parents=True, exist_ok=True)
+            if not self.mkcert_bin.exists():
+                system = platform.system()
+                arch = platform.machine()
+
+                # Map platform.machine() to mkcert's expected architecture strings
+                arch_map = {
+                    "x86_64": "amd64",
+                    "amd64": "amd64",
+                    "AMD64": "amd64",
+                    "arm64": "arm64",
+                    "aarch64": "arm64",
+                }
+                arch = arch_map.get(
+                    arch.lower(), "amd64"
+                )  # Default to amd64 if unknown
+
+                if system == "Darwin":
+                    os_name = "darwin"
+                elif system == "Linux":
+                    os_name = "linux"
+                elif system == "Windows":
+                    os_name = "windows"
+                else:
+                    click.secho("Unsupported OS", fg="red")
+                    sys.exit(1)
+
+                mkcert_url = f"https://dl.filippo.io/mkcert/latest?for={os_name}/{arch}"
+                click.secho(f"Downloading mkcert from {mkcert_url}...", bold=True)
+                urllib.request.urlretrieve(mkcert_url, self.mkcert_bin)
+                self.mkcert_bin.chmod(0o755)
+            self.mkcert_bin = str(self.mkcert_bin)  # Convert Path object to string
+
+        if not self.is_mkcert_ca_installed():
+            click.secho(
+                "Installing mkcert local CA. You may be prompted for your password.",
+                bold=True,
+            )
+            subprocess.run([self.mkcert_bin, "-install"], check=True)
+
+    def is_mkcert_ca_installed(self):
+        """Check if mkcert local CA is already installed using mkcert -check."""
+        try:
+            result = subprocess.run([self.mkcert_bin, "-check"], capture_output=True)
+            output = result.stdout.decode() + result.stderr.decode()
+            if "The local CA is not installed" in output:
+                return False
+            return True
+        except Exception as e:
+            click.secho(f"Error checking mkcert CA installation: {e}", fg="red")
+            return False
+
+    def generate_certs(self, domain, storage_path):
+        cert_path = storage_path / f"{domain}-cert.pem"
+        key_path = storage_path / f"{domain}-key.pem"
+
+        if cert_path.exists() and key_path.exists():
+            return cert_path, key_path
+
+        storage_path.mkdir(parents=True, exist_ok=True)
+
+        # Generate SSL certificates using mkcert
+        click.secho(f"Generating SSL certificates for {domain}...", bold=True)
+        subprocess.run(
+            [
+                self.mkcert_bin,
+                "-cert-file",
+                str(cert_path),
+                "-key-file",
+                str(key_path),
+                domain,
+            ],
+            check=True,
+        )
+
+        return cert_path, key_path

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

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

plain_dev-0.7.0/plain/dev/poncho/color.py

@@ -0,0 +1,28 @@
+ANSI_COLOURS = ["grey", "red", "green", "yellow", "blue", "magenta", "cyan", "white"]
+
+for i, name in enumerate(ANSI_COLOURS):
+    globals()[name] = str(30 + i)
+    globals()["intense_" + name] = str(30 + i) + ";1"
+
+
+def get_colors():
+    cs = [
+        "cyan",
+        "yellow",
+        "green",
+        "magenta",
+        "red",
+        "blue",
+        "intense_cyan",
+        "intense_yellow",
+        "intense_green",
+        "intense_magenta",
+        "intense_red",
+        "intense_blue",
+    ]
+    cs = [globals()[c] for c in cs]
+
+    i = 0
+    while True:
+        yield cs[i % len(cs)]
+        i += 1

plain_dev-0.7.0/plain/dev/poncho/compat.py

@@ -0,0 +1,47 @@
+"""
+Compatibility layer and utilities, mostly for proper Windows and Python 3
+support.
+"""
+import errno
+import os
+import signal
+import sys
+
+# This works for both 32 and 64 bit Windows
+ON_WINDOWS = "win32" in str(sys.platform).lower()
+
+if ON_WINDOWS:
+    import ctypes
+
+
+class ProcessManager:
+    if ON_WINDOWS:
+
+        def terminate(self, pid):
+            # 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)
+    else:
+
+        def terminate(self, pid):
+            try:
+                os.killpg(pid, signal.SIGTERM)
+            except OSError as e:
+                if e.errno not in [errno.EPERM, errno.ESRCH]:
+                    raise
+
+    if ON_WINDOWS:
+
+        def kill(self, pid):
+            # There's no SIGKILL on Win32...
+            self.terminate(pid)
+    else:
+
+        def kill(self, pid):
+            try:
+                os.killpg(pid, signal.SIGKILL)
+            except OSError as e:
+                if e.errno not in [errno.EPERM, errno.ESRCH]:
+                    raise

plain_dev-0.7.0/plain/dev/poncho/manager.py

@@ -0,0 +1,201 @@
+import datetime
+import multiprocessing
+import queue
+import signal
+import sys
+
+from .color import get_colors
+from .compat import ProcessManager
+from .printer import Message, Printer
+from .process import Process
+
+KILL_WAIT = 5
+SIGNALS = {
+    signal.SIGINT: {
+        "name": "SIGINT",
+        "rc": 130,
+    },
+    signal.SIGTERM: {
+        "name": "SIGTERM",
+        "rc": 143,
+    },
+}
+SYSTEM_PRINTER_NAME = "system"
+
+
+class Manager:
+    """
+    Manager is responsible for running multiple external processes in parallel
+    managing the events that result (starting, stopping, printing). By default
+    it relays printed lines to a printer that prints to STDOUT.
+
+    Example::
+
+        import sys
+        from poncho.manager import Manager
+
+        m = Manager()
+        m.add_process('server', 'ruby server.rb')
+        m.add_process('worker', 'python worker.py')
+        m.loop()
+
+        sys.exit(m.returncode)
+    """
+
+    #: After :func:`~poncho.manager.Manager.loop` finishes,
+    #: this will contain a return code that can be used with `sys.exit`.
+    returncode = None
+
+    def __init__(self, printer=None):
+        self.events = multiprocessing.Queue()
+        self.returncode = None
+
+        self._colors = get_colors()
+        self._clock = datetime.datetime
+        self._procmgr = ProcessManager()
+
+        self._printer = printer if printer is not None else Printer(sys.stdout)
+        self._printer.width = len(SYSTEM_PRINTER_NAME)
+
+        self._process_ctor = Process
+        self._processes = {}
+
+        self._terminating = False
+
+    def add_process(self, name, cmd, quiet=False, env=None, cwd=None):
+        """
+        Add a process to this manager instance. The process will not be started
+        until :func:`~poncho.manager.Manager.loop` is called.
+        """
+        assert name not in self._processes, "process names must be unique"
+        proc = self._process_ctor(
+            cmd, name=name, quiet=quiet, color=next(self._colors), env=env, cwd=cwd
+        )
+        self._processes[name] = {}
+        self._processes[name]["obj"] = proc
+
+        # Update printer width to accommodate this process name
+        self._printer.width = max(self._printer.width, len(name))
+
+        return proc
+
+    def loop(self):
+        """
+        Start all the added processes and multiplex their output onto the bound
+        printer (which by default will print to STDOUT).
+
+        If one process terminates, all the others will be terminated by
+        Poncho, and :func:`~poncho.manager.Manager.loop` will return.
+
+        This method will block until all the processes have terminated.
+        """
+
+        def _terminate(signum, frame):
+            self._system_print("%s received\n" % SIGNALS[signum]["name"])
+            self.returncode = SIGNALS[signum]["rc"]
+            self.terminate()
+
+        signal.signal(signal.SIGTERM, _terminate)
+        signal.signal(signal.SIGINT, _terminate)
+
+        self._start()
+
+        exit = False
+        exit_start = None
+
+        while 1:
+            try:
+                msg = self.events.get(timeout=0.1)
+            except queue.Empty:
+                if exit:
+                    break
+            else:
+                if msg.type == "line":
+                    self._printer.write(msg)
+                elif msg.type == "start":
+                    self._processes[msg.name]["pid"] = msg.data["pid"]
+                    self._system_print(
+                        "{} started (pid={})\n".format(msg.name, msg.data["pid"])
+                    )
+                elif msg.type == "stop":
+                    self._processes[msg.name]["returncode"] = msg.data["returncode"]
+                    self._system_print(
+                        "{} stopped (rc={})\n".format(msg.name, msg.data["returncode"])
+                    )
+                    if self.returncode is None:
+                        self.returncode = msg.data["returncode"]
+
+            if self._all_started() and self._all_stopped():
+                exit = True
+
+            if exit_start is None and self._all_started() and self._any_stopped():
+                exit_start = self._clock.now()
+                self.terminate()
+
+            if exit_start is not None:
+                # If we've been in this loop for more than KILL_WAIT seconds,
+                # it's time to kill all remaining children.
+                waiting = self._clock.now() - exit_start
+                if waiting > datetime.timedelta(seconds=KILL_WAIT):
+                    self.kill()
+
+    def terminate(self):
+        """
+        Terminate all processes managed by this ProcessManager.
+        """
+        if self._terminating:
+            return
+        self._terminating = True
+        self._killall()
+
+    def kill(self):
+        """
+        Kill all processes managed by this ProcessManager.
+        """
+        self._killall(force=True)
+
+    def _killall(self, force=False):
+        """Kill all remaining processes, forcefully if requested."""
+        for_termination = []
+
+        for n, p in self._processes.items():
+            if "returncode" not in p:
+                for_termination.append(n)
+
+        for n in for_termination:
+            p = self._processes[n]
+            signame = "SIGKILL" if force else "SIGTERM"
+            self._system_print(
+                "sending {} to {} (pid {})\n".format(signame, n, p["pid"])
+            )
+            if force:
+                self._procmgr.kill(p["pid"])
+            else:
+                self._procmgr.terminate(p["pid"])
+
+    def _start(self):
+        for name, p in self._processes.items():
+            p["process"] = multiprocessing.Process(
+                name=name, target=p["obj"].run, args=(self.events, True)
+            )
+            p["process"].start()
+
+    def _all_started(self):
+        return all(p.get("pid") is not None for _, p in self._processes.items())
+
+    def _all_stopped(self):
+        return all(p.get("returncode") is not None for _, p in self._processes.items())
+
+    def _any_stopped(self):
+        return any(p.get("returncode") is not None for _, p in self._processes.items())
+
+    def _system_print(self, data):
+        self._printer.write(
+            Message(
+                type="line",
+                data=data,
+                time=self._clock.now(),
+                name=SYSTEM_PRINTER_NAME,
+                color=None,
+            )
+        )

plain_dev-0.7.0/plain/dev/poncho/printer.py

@@ -0,0 +1,85 @@
+import sys
+from collections import namedtuple
+
+from .compat import ON_WINDOWS
+
+Message = namedtuple("Message", "type data time name color")
+
+
+class Printer:
+    """
+    Printer is where Poncho's user-visible output is defined. A Printer
+    instance receives typed messages and prints them to its output (usually
+    STDOUT) in the Poncho format.
+    """
+
+    def __init__(
+        self,
+        output=sys.stdout,
+        time_format="%H:%M:%S",
+        width=0,
+        color=True,
+        prefix=True,
+    ):
+        self.output = output
+        self.time_format = time_format
+        self.width = width
+        self.color = color
+        self.prefix = prefix
+
+        try:
+            # We only want to print colored messages if the given output supports
+            # ANSI escape sequences. Usually, testing if it is a TTY is safe enough.
+            self._colors_supported = self.output.isatty()
+        except AttributeError:
+            # If the given output does not implement isatty(), we assume that it
+            # is not able to handle ANSI escape sequences.
+            self._colors_supported = False
+
+    def write(self, message):
+        if message.type != "line":
+            raise RuntimeError('Printer can only process messages of type "line"')
+
+        name = message.name if message.name is not None else ""
+        name = name.ljust(self.width)
+        if name:
+            name += " "
+
+        # When encountering data that cannot be interpreted as UTF-8 encoded
+        # Unicode, Printer will replace the unrecognisable bytes with the
+        # Unicode replacement character (U+FFFD).
+        if isinstance(message.data, bytes):
+            string = message.data.decode("utf-8", "replace")
+        else:
+            string = message.data
+
+        for line in string.splitlines():
+            prefix = ""
+            if self.prefix:
+                time_formatted = message.time.strftime(self.time_format)
+                prefix = f"{time_formatted} {name}| "
+                if self.color and self._colors_supported and message.color:
+                    prefix = _color_string(message.color, prefix)
+            print(prefix + line, file=self.output, flush=True)
+
+
+def _ansi(code):
+    return f"\033[{code}m"
+
+
+def _color_string(color, s):
+    return f"{_ansi(0)}{_ansi(color)}{s}{_ansi(0)}"
+
+
+if ON_WINDOWS:
+    # The colorama package provides transparent support for ANSI color codes
+    # on Win32 platforms. We try and import and configure that, but fall back
+    # to no color if we fail.
+    try:
+        import colorama
+    except ImportError:
+
+        def _color_string(color, s):
+            return s
+    else:
+        colorama.init()

plain_dev-0.7.0/plain/dev/poncho/process.py

@@ -0,0 +1,81 @@
+import datetime
+import os
+import signal
+import subprocess
+
+from .compat import ON_WINDOWS
+from .printer import Message
+
+
+class Process:
+    """
+    A simple utility wrapper around a subprocess.Popen that stores
+    a number of attributes needed by Poncho and supports forwarding process
+    lifecycle events and output to a queue.
+    """
+
+    def __init__(self, cmd, name=None, color=None, quiet=False, env=None, cwd=None):
+        self.cmd = cmd
+        self.color = color
+        self.quiet = quiet
+        self.name = name
+        self.env = os.environ.copy() if env is None else env
+        self.cwd = cwd
+
+        self._clock = datetime.datetime
+        self._child = None
+        self._child_ctor = Popen
+
+    def run(self, events=None, ignore_signals=False):
+        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")
+
+        # Don't pay attention to SIGINT/SIGTERM. The process itself is
+        # considered unkillable, and will only exit when its child (the shell
+        # running the Procfile process) exits.
+        if ignore_signals:
+            signal.signal(signal.SIGINT, signal.SIG_IGN)
+            signal.signal(signal.SIGTERM, signal.SIG_IGN)
+
+        for line in iter(self._child.stdout.readline, b""):
+            if not self.quiet:
+                self._send_message(line)
+        self._child.stdout.close()
+        self._child.wait()
+
+        self._send_message({"returncode": self._child.returncode}, type="stop")
+
+    def _send_message(self, data, type="line"):
+        if self._events is not None:
+            self._events.put(
+                Message(
+                    type=type,
+                    data=data,
+                    time=self._clock.now(),
+                    name=self.name,
+                    color=self.color,
+                )
+            )
+
+
+class Popen(subprocess.Popen):
+    def __init__(self, cmd, **kwargs):
+        start_new_session = kwargs.pop("start_new_session", True)
+        options = {
+            "stdout": subprocess.PIPE,
+            "stderr": subprocess.STDOUT,
+            "shell": True,
+            "close_fds": not ON_WINDOWS,
+        }
+        options.update(**kwargs)
+
+        if ON_WINDOWS:
+            # MSDN reference:
+            #   http://msdn.microsoft.com/en-us/library/windows/desktop/ms684863%28v=vs.85%29.aspx
+            create_no_window = 0x08000000
+            options.update(creationflags=create_no_window)
+        elif start_new_session:
+            options.update(start_new_session=True)
+
+        super().__init__(cmd, **options)

{plain_dev-0.5.0 → plain_dev-0.7.0}/plain/dev/precommit/cli.py

@@ -4,17 +4,13 @@ import sys
 from importlib.util import find_spec
 from pathlib import Path
 
+import click
+import tomllib
+
 from plain.cli.print import print_event
 
 from ..services import Services
 
-try:
-    import tomllib
-except ModuleNotFoundError:
-    import tomli as tomllib
-
-import click
-
 
 def install_git_hook():
     hook_path = os.path.join(".git", "hooks", "pre-commit")

{plain_dev-0.5.0 → plain_dev-0.7.0}/plain/dev/services.py

@@ -5,6 +5,7 @@ from importlib.util import find_spec
 from pathlib import Path
 
 import click
+import tomllib
 from honcho.manager import Manager as HonchoManager
 
 from plain.runtime import APP_PATH
@@ -12,11 +13,6 @@ from plain.runtime import APP_PATH
 from .pid import Pid
 from .utils import has_pyproject_toml
 
-try:
-    import tomllib
-except ModuleNotFoundError:
-    import tomli as tomllib
-
 
 class Services:
     @staticmethod

plain_dev-0.7.0/plain/dev/utils.py

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

{plain_dev-0.5.0 → plain_dev-0.7.0}/pyproject.toml

@@ -5,7 +5,7 @@ packages = [
     { include = "plain" },
 ]
 
-version = "0.5.0"
+version = "0.7.0"
 description = "Local development tools for Plain."
 authors = ["Dave Gaeddert <dave.gaeddert@dropseed.dev>"]
 license = "BSD-3-Clause"
@@ -26,14 +26,11 @@ python = "^3.11"
 plain = "<1.0.0"
 
 click = ">=8.0.0"
-honcho = "^1.1.0"
 debugpy = "^1.6.3"
 
 # For local runserver
 gunicorn = ">20"
 
-tomli = {version = "^2.0.1", python = "<3.11"}
-
 # db
 requests = ">=2.0.0"
 psycopg = {version = "^3.2.2", extras = ["binary"]}

plain_dev-0.5.0/plain/dev/cli.py

@@ -1,164 +0,0 @@
-import json
-import os
-import subprocess
-import sys
-from importlib.util import find_spec
-from pathlib import Path
-
-import click
-from honcho.manager import Manager as HonchoManager
-
-from plain.runtime import APP_PATH
-
-from .db import cli as db_cli
-from .pid import Pid
-from .services import Services
-from .utils import has_pyproject_toml, plainpackage_installed
-
-try:
-    import tomllib
-except ModuleNotFoundError:
-    import tomli as tomllib
-
-
-@click.group(invoke_without_command=True)
-@click.pass_context
-@click.option(
-    "--port",
-    "-p",
-    default=8000,
-    type=int,
-    help="Port to run the web server on",
-    envvar="PORT",
-)
-def cli(ctx, port):
-    """Start local development"""
-
-    if ctx.invoked_subcommand:
-        return
-
-    returncode = Dev(port=port).run()
-    if returncode:
-        sys.exit(returncode)
-
-
-@cli.command()
-def services():
-    """Start additional services defined in pyproject.toml"""
-    Services().run()
-
-
-class Dev:
-    def __init__(self, *, port):
-        self.manager = HonchoManager()
-        self.port = port
-        self.plain_env = {
-            **os.environ,
-            "PYTHONUNBUFFERED": "true",
-        }
-        self.custom_process_env = {
-            **self.plain_env,
-            "PORT": str(self.port),
-            "PYTHONPATH": os.path.join(APP_PATH.parent, "app"),
-        }
-
-    def run(self):
-        pid = Pid()
-        pid.write()
-
-        try:
-            self.add_csrf_trusted_origins()
-            self.run_preflight()
-            self.add_gunicorn()
-            self.add_tailwind()
-            self.add_pyproject_run()
-            self.add_services()
-
-            self.manager.loop()
-
-            return self.manager.returncode
-        finally:
-            pid.rm()
-
-    def add_csrf_trusted_origins(self):
-        if "PLAIN_CSRF_TRUSTED_ORIGINS" in os.environ:
-            return
-
-        csrf_trusted_origins = json.dumps(
-            [f"http://localhost:{self.port}", f"http://127.0.0.1:{self.port}"]
-        )
-
-        click.secho(
-            f"Automatically set PLAIN_CSRF_TRUSTED_ORIGINS={click.style(csrf_trusted_origins, underline=True)}",
-            bold=True,
-        )
-
-        # Set BASE_URL for plain and custom processes
-        self.plain_env["PLAIN_CSRF_TRUSTED_ORIGINS"] = csrf_trusted_origins
-        self.custom_process_env["PLAIN_CSRF_TRUSTED_ORIGINS"] = csrf_trusted_origins
-
-    def run_preflight(self):
-        if subprocess.run(["plain", "preflight"], env=self.plain_env).returncode:
-            click.secho("Preflight check failed!", fg="red")
-            sys.exit(1)
-
-    def add_gunicorn(self):
-        plain_db_installed = find_spec("plain.models") is not None
-
-        # TODO not necessarily watching the right .env...
-        # could return path from env.load?
-        extra_watch_files = []
-        for f in os.listdir(APP_PATH.parent):
-            if f.startswith(".env"):
-                # Will include some extra, but good enough for now
-                extra_watch_files.append(f)
-
-        reload_extra = " ".join(f"--reload-extra-file {f}" for f in extra_watch_files)
-        gunicorn = f"gunicorn --bind 127.0.0.1:{self.port} --reload plain.wsgi:app --timeout 60 --access-logfile - --error-logfile - {reload_extra} --access-logformat '\"%(r)s\" status=%(s)s length=%(b)s dur=%(M)sms'"
-
-        if plain_db_installed:
-            runserver_cmd = f"plain models db-wait && plain migrate && {gunicorn}"
-        else:
-            runserver_cmd = gunicorn
-
-        if "WEB_CONCURRENCY" not in self.plain_env:
-            # Default to two workers so request log etc are less
-            # likely to get locked up
-            self.plain_env["WEB_CONCURRENCY"] = "2"
-
-        self.manager.add_process("plain", runserver_cmd, env=self.plain_env)
-
-    def add_tailwind(self):
-        if not plainpackage_installed("tailwind"):
-            return
-
-        self.manager.add_process("tailwind", "plain tailwind compile --watch")
-
-    def add_pyproject_run(self):
-        if not has_pyproject_toml(APP_PATH.parent):
-            return
-
-        with open(Path(APP_PATH.parent, "pyproject.toml"), "rb") as f:
-            pyproject = tomllib.load(f)
-
-        for name, data in (
-            pyproject.get("tool", {}).get("plain", {}).get("dev", {}).get("run", {})
-        ).items():
-            env = {
-                **self.custom_process_env,
-                **data.get("env", {}),
-            }
-            self.manager.add_process(name, data["cmd"], env=env)
-
-    def add_services(self):
-        services = Services.get_services(APP_PATH.parent)
-        for name, data in services.items():
-            env = {
-                **os.environ,
-                "PYTHONUNBUFFERED": "true",
-                **data.get("env", {}),
-            }
-            self.manager.add_process(name, data["cmd"], env=env)
-
-
-cli.add_command(db_cli)

plain_dev-0.5.0/plain/dev/utils.py

@@ -1,14 +0,0 @@
-import importlib
-from pathlib import Path
-
-
-def plainpackage_installed(name: str) -> bool:
-    try:
-        importlib.import_module(f"plain.{name}")
-        return True
-    except ImportError:
-        return False
-
-
-def has_pyproject_toml(target_path):
-    return (Path(target_path) / "pyproject.toml").exists()