plain 0.1.0__py3-none-any.whl

plain/internal/legacy/management/color.py

@@ -0,0 +1,113 @@
+"""
+Sets up the terminal color scheme.
+"""
+
+import functools
+import os
+import sys
+
+from plain.utils import termcolors
+
+try:
+    import colorama
+
+    colorama.init()
+except (ImportError, OSError):
+    HAS_COLORAMA = False
+else:
+    HAS_COLORAMA = True
+
+
+def supports_color():
+    """
+    Return True if the running system's terminal supports color,
+    and False otherwise.
+    """
+
+    def vt_codes_enabled_in_windows_registry():
+        """
+        Check the Windows Registry to see if VT code handling has been enabled
+        by default, see https://superuser.com/a/1300251/447564.
+        """
+        try:
+            # winreg is only available on Windows.
+            import winreg
+        except ImportError:
+            return False
+        else:
+            try:
+                reg_key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Console")
+                reg_key_value, _ = winreg.QueryValueEx(reg_key, "VirtualTerminalLevel")
+            except FileNotFoundError:
+                return False
+            else:
+                return reg_key_value == 1
+
+    # isatty is not always implemented, #6223.
+    is_a_tty = hasattr(sys.stdout, "isatty") and sys.stdout.isatty()
+
+    return is_a_tty and (
+        sys.platform != "win32"
+        or HAS_COLORAMA
+        or "ANSICON" in os.environ
+        or
+        # Windows Terminal supports VT codes.
+        "WT_SESSION" in os.environ
+        or
+        # Microsoft Visual Studio Code's built-in terminal supports colors.
+        os.environ.get("TERM_PROGRAM") == "vscode"
+        or vt_codes_enabled_in_windows_registry()
+    )
+
+
+class Style:
+    pass
+
+
+def make_style(config_string=""):
+    """
+    Create a Style object from the given config_string.
+
+    If config_string is empty plain.utils.termcolors.DEFAULT_PALETTE is used.
+    """
+
+    style = Style()
+
+    color_settings = termcolors.parse_color_setting(config_string)
+
+    # The nocolor palette has all available roles.
+    # Use that palette as the basis for populating
+    # the palette as defined in the environment.
+    for role in termcolors.PALETTES[termcolors.NOCOLOR_PALETTE]:
+        if color_settings:
+            format = color_settings.get(role, {})
+            style_func = termcolors.make_style(**format)
+        else:
+
+            def style_func(x):
+                return x
+
+        setattr(style, role, style_func)
+
+    # For backwards compatibility,
+    # set style for ERROR_OUTPUT == ERROR
+    style.ERROR_OUTPUT = style.ERROR
+
+    return style
+
+
+@functools.cache
+def no_style():
+    """
+    Return a Style object with no color scheme.
+    """
+    return make_style("nocolor")
+
+
+def color_style(force_color=False):
+    """
+    Return a Style object from the Plain color scheme.
+    """
+    if not force_color and not supports_color():
+        return no_style()
+    return make_style(os.environ.get("DJANGO_COLORS", ""))

plain/internal/legacy/management/commands/collectstatic.py

@@ -0,0 +1,297 @@
+import os
+
+from plain.assets.finders import get_finders
+from plain.assets.storage import FileSystemStorage, assets_storage
+from plain.internal.legacy.management.base import BaseCommand, CommandError
+from plain.internal.legacy.management.color import no_style
+from plain.utils.functional import cached_property
+
+
+class Command(BaseCommand):
+    """
+    Copies static files from different locations to the
+    settings.ASSETS_ROOT.
+    """
+
+    help = "Collect static files in a single location."
+    # requires_system_checks = [Tags.assets]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.copied_files = []
+        self.unmodified_files = []
+        self.post_processed_files = []
+        self.storage = assets_storage
+        self.style = no_style()
+
+    @cached_property
+    def local(self):
+        try:
+            self.storage.path("")
+        except NotImplementedError:
+            return False
+        return True
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--noinput",
+            "--no-input",
+            action="store_false",
+            dest="interactive",
+            help="Do NOT prompt the user for input of any kind.",
+        )
+        parser.add_argument(
+            "--no-post-process",
+            action="store_false",
+            dest="post_process",
+            help="Do NOT post process collected files.",
+        )
+        parser.add_argument(
+            "-i",
+            "--ignore",
+            action="append",
+            default=[],
+            dest="ignore_patterns",
+            metavar="PATTERN",
+            help="Ignore files or directories matching this glob-style "
+            "pattern. Use multiple times to ignore more.",
+        )
+        parser.add_argument(
+            "-n",
+            "--dry-run",
+            action="store_true",
+            help="Do everything except modify the filesystem.",
+        )
+        parser.add_argument(
+            "-c",
+            "--clear",
+            action="store_true",
+            help="Clear the existing files using the storage "
+            "before trying to copy or link the original file.",
+        )
+        parser.add_argument(
+            "--no-default-ignore",
+            action="store_false",
+            dest="use_default_ignore_patterns",
+            help=(
+                "Don't ignore the common private glob-style patterns (defaults to "
+                "'CVS', '.*' and '*~')."
+            ),
+        )
+
+    def set_options(self, **options):
+        """
+        Set instance variables based on an options dict
+        """
+        self.interactive = options["interactive"]
+        self.verbosity = options["verbosity"]
+        self.clear = options["clear"]
+        self.dry_run = options["dry_run"]
+        ignore_patterns = options["ignore_patterns"]
+        if options["use_default_ignore_patterns"]:
+            ignore_patterns += ["CVS", ".*", "*~"]
+        self.ignore_patterns = list({os.path.normpath(p) for p in ignore_patterns})
+        self.post_process = options["post_process"]
+
+    def collect(self):
+        """
+        Perform the bulk of the work of collectstatic.
+
+        Split off from handle() to facilitate testing.
+        """
+        if self.clear:
+            self.clear_dir("")
+
+        found_files = {}
+        for finder in get_finders():
+            for path, storage in finder.list(self.ignore_patterns):
+                # Prefix the relative path if the source storage contains it
+                if getattr(storage, "prefix", None):
+                    prefixed_path = os.path.join(storage.prefix, path)
+                else:
+                    prefixed_path = path
+
+                if prefixed_path not in found_files:
+                    found_files[prefixed_path] = (storage, path)
+                    self.copy_file(path, prefixed_path, storage)
+                else:
+                    self.log(
+                        "Found another file with the destination path '%s'. It "
+                        "will be ignored since only the first encountered file "
+                        "is collected. If this is not what you want, make sure "
+                        "every static file has a unique path." % prefixed_path,
+                        level=1,
+                    )
+
+        # Storage backends may define a post_process() method.
+        if self.post_process and hasattr(self.storage, "post_process"):
+            processor = self.storage.post_process(found_files, dry_run=self.dry_run)
+            for original_path, processed_path, processed in processor:
+                if isinstance(processed, Exception):
+                    self.stderr.write("Post-processing '%s' failed!" % original_path)
+                    # Add a blank line before the traceback, otherwise it's
+                    # too easy to miss the relevant part of the error message.
+                    self.stderr.write()
+                    raise processed
+                if processed:
+                    self.log(
+                        f"Post-processed '{original_path}' as '{processed_path}'",
+                        level=2,
+                    )
+                    self.post_processed_files.append(original_path)
+                else:
+                    self.log("Skipped post-processing '%s'" % original_path)
+
+        return {
+            "modified": self.copied_files,
+            "unmodified": self.unmodified_files,
+            "post_processed": self.post_processed_files,
+        }
+
+    def handle(self, **options):
+        self.set_options(**options)
+        message = ["\n"]
+        if self.dry_run:
+            message.append(
+                "You have activated the --dry-run option so no files will be "
+                "modified.\n\n"
+            )
+
+        message.append(
+            "You have requested to collect static files at the destination\n"
+            "location as specified in your settings"
+        )
+
+        if self.is_local_storage() and self.storage.location:
+            destination_path = self.storage.location
+            message.append(":\n\n    %s\n\n" % destination_path)
+            should_warn_user = self.storage.exists(destination_path) and any(
+                self.storage.listdir(destination_path)
+            )
+        else:
+            destination_path = None
+            message.append(".\n\n")
+            # Destination files existence not checked; play it safe and warn.
+            should_warn_user = True
+
+        if self.interactive and should_warn_user:
+            if self.clear:
+                message.append("This will DELETE ALL FILES in this location!\n")
+            else:
+                message.append("This will overwrite existing files!\n")
+
+            message.append(
+                "Are you sure you want to do this?\n\n"
+                "Type 'yes' to continue, or 'no' to cancel: "
+            )
+            if input("".join(message)) != "yes":
+                raise CommandError("Collecting static files cancelled.")
+
+        collected = self.collect()
+
+        if self.verbosity >= 1:
+            modified_count = len(collected["modified"])
+            unmodified_count = len(collected["unmodified"])
+            post_processed_count = len(collected["post_processed"])
+            return (
+                "\n{modified_count} {identifier} {action}"
+                "{destination}{unmodified}{post_processed}."
+            ).format(
+                modified_count=modified_count,
+                identifier="static file" + ("" if modified_count == 1 else "s"),
+                action="copied",
+                destination=" to '%s'" % destination_path if destination_path else "",
+                unmodified=", %s unmodified" % unmodified_count
+                if collected["unmodified"]
+                else "",
+                post_processed=collected["post_processed"]
+                and ", %s post-processed" % post_processed_count
+                or "",
+            )
+
+    def log(self, msg, level=2):
+        """
+        Small log helper
+        """
+        if self.verbosity >= level:
+            self.stdout.write(msg)
+
+    def is_local_storage(self):
+        return isinstance(self.storage, FileSystemStorage)
+
+    def clear_dir(self, path):
+        """
+        Delete the given relative path using the destination storage backend.
+        """
+        if not self.storage.exists(path):
+            return
+
+        dirs, files = self.storage.listdir(path)
+        for f in files:
+            fpath = os.path.join(path, f)
+            if self.dry_run:
+                self.log("Pretending to delete '%s'" % fpath, level=1)
+            else:
+                self.log("Deleting '%s'" % fpath, level=1)
+                self.storage.delete(fpath)
+        for d in dirs:
+            self.clear_dir(os.path.join(path, d))
+
+    def delete_file(self, path, prefixed_path, source_storage):
+        """
+        Check if the target file should be deleted if it already exists.
+        """
+        if self.storage.exists(prefixed_path):
+            try:
+                # When was the target file modified last time?
+                target_last_modified = self.storage.get_modified_time(prefixed_path)
+            except (OSError, NotImplementedError, AttributeError):
+                # The storage doesn't support get_modified_time() or failed
+                pass
+            else:
+                try:
+                    # When was the source file modified last time?
+                    source_last_modified = source_storage.get_modified_time(path)
+                except (OSError, NotImplementedError, AttributeError):
+                    pass
+                else:
+                    # In remote storages, skipping is only based on the
+                    # modified times since symlinks aren't relevant.
+                    can_skip_unmodified_files = not self.local
+                    # Avoid sub-second precision (see #14665, #19540)
+                    file_is_unmodified = target_last_modified.replace(
+                        microsecond=0
+                    ) >= source_last_modified.replace(microsecond=0)
+                    if file_is_unmodified and can_skip_unmodified_files:
+                        if prefixed_path not in self.unmodified_files:
+                            self.unmodified_files.append(prefixed_path)
+                        self.log("Skipping '%s' (not modified)" % path)
+                        return False
+            # Then delete the existing file if really needed
+            if self.dry_run:
+                self.log("Pretending to delete '%s'" % path)
+            else:
+                self.log("Deleting '%s'" % path)
+                self.storage.delete(prefixed_path)
+        return True
+
+    def copy_file(self, path, prefixed_path, source_storage):
+        """
+        Attempt to copy ``path`` with storage
+        """
+        # Skip this file if it was already copied earlier
+        if prefixed_path in self.copied_files:
+            return self.log("Skipping '%s' (already copied earlier)" % path)
+        # Delete the target file if needed or break
+        if not self.delete_file(path, prefixed_path, source_storage):
+            return
+        # The full path of the source file
+        source_path = source_storage.path(path)
+        # Finally start copying
+        if self.dry_run:
+            self.log("Pretending to copy '%s'" % source_path, level=1)
+        else:
+            self.log("Copying '%s'" % source_path, level=2)
+            with source_storage.open(path) as source_file:
+                self.storage.save(prefixed_path, source_file)
+        self.copied_files.append(prefixed_path)

plain/internal/legacy/management/sql.py

@@ -0,0 +1,67 @@
+import sys
+
+from plain.packages import packages
+
+
+def sql_flush(style, connection, reset_sequences=True, allow_cascade=False):
+    """
+    Return a list of the SQL statements used to flush the database.
+    """
+    tables = connection.introspection.plain_table_names(
+        only_existing=True, include_views=False
+    )
+    return connection.ops.sql_flush(
+        style,
+        tables,
+        reset_sequences=reset_sequences,
+        allow_cascade=allow_cascade,
+    )
+
+
+def emit_pre_migrate_signal(verbosity, interactive, db, **kwargs):
+    # Emit the pre_migrate signal for every application.
+    for package_config in packages.get_package_configs():
+        if package_config.models_module is None:
+            continue
+        if verbosity >= 2:
+            stdout = kwargs.get("stdout", sys.stdout)
+            stdout.write(
+                "Running pre-migrate handlers for application %s" % package_config.label
+            )
+        try:
+            from plain import models
+        except ImportError:
+            continue
+        models.signals.pre_migrate.send(
+            sender=package_config,
+            package_config=package_config,
+            verbosity=verbosity,
+            interactive=interactive,
+            using=db,
+            **kwargs,
+        )
+
+
+def emit_post_migrate_signal(verbosity, interactive, db, **kwargs):
+    # Emit the post_migrate signal for every application.
+    for package_config in packages.get_package_configs():
+        if package_config.models_module is None:
+            continue
+        if verbosity >= 2:
+            stdout = kwargs.get("stdout", sys.stdout)
+            stdout.write(
+                "Running post-migrate handlers for application %s"
+                % package_config.label
+            )
+        try:
+            from plain import models
+        except ImportError:
+            continue
+        models.signals.post_migrate.send(
+            sender=package_config,
+            package_config=package_config,
+            verbosity=verbosity,
+            interactive=interactive,
+            using=db,
+            **kwargs,
+        )

plain/internal/legacy/management/utils.py

@@ -0,0 +1,175 @@
+import fnmatch
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from subprocess import run
+
+from plain.packages import packages as installed_packages
+from plain.utils.crypto import get_random_string
+from plain.utils.encoding import DEFAULT_LOCALE_ENCODING
+
+from .base import CommandError, CommandParser
+
+
+def popen_wrapper(args, stdout_encoding="utf-8"):
+    """
+    Friendly wrapper around Popen.
+
+    Return stdout output, stderr output, and OS status code.
+    """
+    try:
+        p = run(args, capture_output=True, close_fds=os.name != "nt")
+    except OSError as err:
+        raise CommandError("Error executing %s" % args[0]) from err
+    return (
+        p.stdout.decode(stdout_encoding),
+        p.stderr.decode(DEFAULT_LOCALE_ENCODING, errors="replace"),
+        p.returncode,
+    )
+
+
+def handle_extensions(extensions):
+    """
+    Organize multiple extensions that are separated with commas or passed by
+    using --extension/-e multiple times.
+
+    For example: running 'django-admin makemessages -e js,txt -e xhtml -a'
+    would result in an extension list: ['.js', '.txt', '.xhtml']
+
+    >>> handle_extensions(['.html', 'html,js,py,py,py,.py', 'py,.py'])
+    {'.html', '.js', '.py'}
+    >>> handle_extensions(['.html, txt,.tpl'])
+    {'.html', '.tpl', '.txt'}
+    """
+    ext_list = []
+    for ext in extensions:
+        ext_list.extend(ext.replace(" ", "").split(","))
+    for i, ext in enumerate(ext_list):
+        if not ext.startswith("."):
+            ext_list[i] = ".%s" % ext_list[i]
+    return set(ext_list)
+
+
+def find_command(cmd, path=None, pathext=None):
+    if path is None:
+        path = os.environ.get("PATH", "").split(os.pathsep)
+    if isinstance(path, str):
+        path = [path]
+    # check if there are funny path extensions for executables, e.g. Windows
+    if pathext is None:
+        pathext = os.environ.get("PATHEXT", ".COM;.EXE;.BAT;.CMD").split(os.pathsep)
+    # don't use extensions if the command ends with one of them
+    for ext in pathext:
+        if cmd.endswith(ext):
+            pathext = [""]
+            break
+    # check if we find the command on PATH
+    for p in path:
+        f = os.path.join(p, cmd)
+        if os.path.isfile(f):
+            return f
+        for ext in pathext:
+            fext = f + ext
+            if os.path.isfile(fext):
+                return fext
+    return None
+
+
+def get_random_secret_key():
+    """
+    Return a 50 character random string usable as a SECRET_KEY setting value.
+    """
+    chars = "abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)"
+    return get_random_string(50, chars)
+
+
+def parse_packages_and_model_labels(labels):
+    """
+    Parse a list of "package_label.ModelName" or "package_label" strings into actual
+    objects and return a two-element tuple:
+        (set of model classes, set of package_configs).
+    Raise a CommandError if some specified models or packages don't exist.
+    """
+    packages = set()
+    models = set()
+
+    for label in labels:
+        if "." in label:
+            try:
+                model = installed_packages.get_model(label)
+            except LookupError:
+                raise CommandError("Unknown model: %s" % label)
+            models.add(model)
+        else:
+            try:
+                package_config = installed_packages.get_package_config(label)
+            except LookupError as e:
+                raise CommandError(str(e))
+            packages.add(package_config)
+
+    return models, packages
+
+
+def get_command_line_option(argv, option):
+    """
+    Return the value of a command line option (which should include leading
+    dashes, e.g. '--testrunner') from an argument list. Return None if the
+    option wasn't passed or if the argument list couldn't be parsed.
+    """
+    parser = CommandParser(add_help=False, allow_abbrev=False)
+    parser.add_argument(option, dest="value")
+    try:
+        options, _ = parser.parse_known_args(argv[2:])
+    except CommandError:
+        return None
+    else:
+        return options.value
+
+
+def normalize_path_patterns(patterns):
+    """Normalize an iterable of glob style patterns based on OS."""
+    patterns = [os.path.normcase(p) for p in patterns]
+    dir_suffixes = {"%s*" % path_sep for path_sep in {"/", os.sep}}
+    norm_patterns = []
+    for pattern in patterns:
+        for dir_suffix in dir_suffixes:
+            if pattern.endswith(dir_suffix):
+                norm_patterns.append(pattern.removesuffix(dir_suffix))
+                break
+        else:
+            norm_patterns.append(pattern)
+    return norm_patterns
+
+
+def is_ignored_path(path, ignore_patterns):
+    """
+    Check if the given path should be ignored or not based on matching
+    one of the glob style `ignore_patterns`.
+    """
+    path = Path(path)
+
+    def ignore(pattern):
+        return fnmatch.fnmatchcase(path.name, pattern) or fnmatch.fnmatchcase(
+            str(path), pattern
+        )
+
+    return any(ignore(pattern) for pattern in normalize_path_patterns(ignore_patterns))
+
+
+def find_formatters():
+    return {"black_path": shutil.which("black")}
+
+
+def run_formatters(written_files, black_path=(sentinel := object())):
+    """
+    Run the black formatter on the specified files.
+    """
+    # Use a sentinel rather than None, as which() returns None when not found.
+    if black_path is sentinel:
+        black_path = shutil.which("black")
+    if black_path:
+        subprocess.run(
+            [black_path, "--fast", "--", *written_files],
+            capture_output=True,
+        )

plain/json.py

@@ -0,0 +1,40 @@
+import datetime
+import decimal
+import json
+import uuid
+
+from plain.utils.duration import duration_iso_string
+from plain.utils.functional import Promise
+from plain.utils.timezone import is_aware
+
+
+class PlainJSONEncoder(json.JSONEncoder):
+    """
+    JSONEncoder subclass that knows how to encode date/time, decimal types, and
+    UUIDs.
+    """
+
+    def default(self, o):
+        # See "Date Time String Format" in the ECMA-262 specification.
+        if isinstance(o, datetime.datetime):
+            r = o.isoformat()
+            if o.microsecond:
+                r = r[:23] + r[26:]
+            if r.endswith("+00:00"):
+                r = r.removesuffix("+00:00") + "Z"
+            return r
+        elif isinstance(o, datetime.date):
+            return o.isoformat()
+        elif isinstance(o, datetime.time):
+            if is_aware(o):
+                raise ValueError("JSON can't represent timezone-aware times.")
+            r = o.isoformat()
+            if o.microsecond:
+                r = r[:12]
+            return r
+        elif isinstance(o, datetime.timedelta):
+            return duration_iso_string(o)
+        elif isinstance(o, decimal.Decimal | uuid.UUID | Promise):
+            return str(o)
+        else:
+            return super().default(o)