plain.dev 0.6.0__tar.gz → 0.7.0__tar.gz

{plain_dev-0.6.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.6.0 → plain_dev-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plain.dev
-Version: 0.6.0
+Version: 0.7.0
 Summary: Local development tools for Plain.
 Home-page: https://plainframework.com
 License: BSD-3-Clause
@@ -14,7 +14,6 @@ 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)

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

@@ -1,23 +1,25 @@
 import json
 import os
 import platform
-import shutil
 import subprocess
 import sys
-import urllib.request
+from importlib.metadata import entry_points
 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, 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, plainpackage_installed
+from .utils import has_pyproject_toml
+
+ENTRYPOINT_GROUP = "plain.dev"
 
 
 @click.group(invoke_without_command=True)
@@ -47,9 +49,27 @@ def services():
     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.manager = HonchoManager()
+        self.poncho = PonchoManager()
         self.port = port
         self.plain_env = {
             **os.environ,
@@ -62,31 +82,28 @@ class Dev:
         }
         self.project_name = os.path.basename(os.getcwd())
         self.domain = f"{self.project_name}.localhost"
-
-        # Paths for mkcert and certificates
-        self.mkcert_dir = Path.home() / ".plain" / "dev"
-        self.mkcert_bin = self.mkcert_dir / "mkcert"
-        self.certs_dir = (
-            Path(settings.PLAIN_TEMP_PATH) / "dev" / "certs"
-        )  # Local project directory for certs
-
-        # Define certificate and key paths with clear filenames
-        self.cert_path = self.certs_dir / f"{self.domain}-cert.pem"
-        self.key_path = self.certs_dir / f"{self.domain}-key.pem"
+        self.ssl_cert_path = None
+        self.ssl_key_path = None
 
     def run(self):
         pid = Pid()
         pid.write()
 
         try:
-            self.setup_mkcert()
-            self.generate_certs()
+            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.add_csrf_trusted_origins()
-            self.add_allowed_hosts()
+            self.set_csrf_trusted_origins()
+            self.set_allowed_hosts()
             self.run_preflight()
+
+            # Processes for poncho to run simultaneously
             self.add_gunicorn()
-            self.add_tailwind()
+            self.add_entrypoints()
             self.add_pyproject_run()
             self.add_services()
 
@@ -97,90 +114,12 @@ class Dev:
                 bold=True,
             )
 
-            self.manager.loop()
+            self.poncho.loop()
 
-            return self.manager.returncode
+            return self.poncho.returncode
         finally:
             pid.rm()
 
-    def setup_mkcert(self):
-        """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_dir.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):
-        if self.cert_path.exists() and self.key_path.exists():
-            return
-
-        self.certs_dir.mkdir(parents=True, exist_ok=True)
-
-        # Generate SSL certificates using mkcert
-        click.secho(f"Generating SSL certificates for {self.domain}...", bold=True)
-        subprocess.run(
-            [
-                self.mkcert_bin,
-                "-cert-file",
-                str(self.cert_path),
-                "-key-file",
-                str(self.key_path),
-                self.domain,
-            ],
-            check=True,
-        )
-
     def modify_hosts_file(self):
         """Modify the hosts file to map the custom domain to 127.0.0.1."""
         entry_identifier = "# Added by plain"
@@ -236,7 +175,7 @@ class Dev:
                 )
                 sys.exit(1)
 
-    def add_csrf_trusted_origins(self):
+    def set_csrf_trusted_origins(self):
         csrf_trusted_origins = json.dumps(
             [
                 f"https://{self.domain}:{self.port}",
@@ -252,7 +191,7 @@ class Dev:
         self.plain_env["PLAIN_CSRF_TRUSTED_ORIGINS"] = csrf_trusted_origins
         self.custom_process_env["PLAIN_CSRF_TRUSTED_ORIGINS"] = csrf_trusted_origins
 
-    def add_allowed_hosts(self):
+    def set_allowed_hosts(self):
         allowed_hosts = json.dumps([self.domain])
 
         click.secho(
@@ -284,9 +223,9 @@ class Dev:
             "--bind",
             f"{self.domain}:{self.port}",
             "--certfile",
-            str(self.cert_path),
+            str(self.ssl_cert_path),
             "--keyfile",
-            str(self.key_path),
+            str(self.ssl_key_path),
             "--reload",
             "plain.wsgi:app",
             "--timeout",
@@ -310,13 +249,13 @@ class Dev:
             # Default to two workers to prevent lockups
             self.plain_env["WEB_CONCURRENCY"] = "2"
 
-        self.manager.add_process("plain", runserver_cmd, env=self.plain_env)
+        self.poncho.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_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):
@@ -333,7 +272,7 @@ class Dev:
                 **self.custom_process_env,
                 **data.get("env", {}),
             }
-            self.manager.add_process(name, data["cmd"], env=env)
+            self.poncho.add_process(name, data["cmd"], env=env)
 
     def add_services(self):
         services = Services.get_services(APP_PATH.parent)
@@ -343,7 +282,7 @@ class Dev:
                 "PYTHONUNBUFFERED": "true",
                 **data.get("env", {}),
             }
-            self.manager.add_process(name, data["cmd"], env=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.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.6.0 → plain_dev-0.7.0}/pyproject.toml

@@ -5,7 +5,7 @@ packages = [
     { include = "plain" },
 ]
 
-version = "0.6.0"
+version = "0.7.0"
 description = "Local development tools for Plain."
 authors = ["Dave Gaeddert <dave.gaeddert@dropseed.dev>"]
 license = "BSD-3-Clause"
@@ -26,7 +26,6 @@ python = "^3.11"
 plain = "<1.0.0"
 
 click = ">=8.0.0"
-honcho = "^1.1.0"
 debugpy = "^1.6.3"
 
 # For local runserver

plain_dev-0.6.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()