plain 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

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

@@ -1,297 +0,0 @@
-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/test/utils.py

@@ -1,255 +0,0 @@
-import sys
-import warnings
-from functools import wraps
-from itertools import chain
-from unittest import TestCase
-
-from plain.packages import packages
-from plain.runtime import settings
-from plain.runtime.user_settings import UserSettingsHolder
-
-__all__ = (
-    "ContextList",
-    "ignore_warnings",
-    "modify_settings",
-    "override_settings",
-)
-
-
-class ContextList(list):
-    """
-    A wrapper that provides direct key access to context items contained
-    in a list of context objects.
-    """
-
-    def __getitem__(self, key):
-        if isinstance(key, str):
-            for subcontext in self:
-                if key in subcontext:
-                    return subcontext[key]
-            raise KeyError(key)
-        else:
-            return super().__getitem__(key)
-
-    def get(self, key, default=None):
-        try:
-            return self.__getitem__(key)
-        except KeyError:
-            return default
-
-    def __contains__(self, key):
-        try:
-            self[key]
-        except KeyError:
-            return False
-        return True
-
-    def keys(self):
-        """
-        Flattened keys of subcontexts.
-        """
-        return set(chain.from_iterable(d for subcontext in self for d in subcontext))
-
-
-class TestContextDecorator:
-    """
-    A base class that can either be used as a context manager during tests
-    or as a test function or unittest.TestCase subclass decorator to perform
-    temporary alterations.
-
-    `attr_name`: attribute assigned the return value of enable() if used as
-                 a class decorator.
-
-    `kwarg_name`: keyword argument passing the return value of enable() if
-                  used as a function decorator.
-    """
-
-    def __init__(self, attr_name=None, kwarg_name=None):
-        self.attr_name = attr_name
-        self.kwarg_name = kwarg_name
-
-    def enable(self):
-        raise NotImplementedError
-
-    def disable(self):
-        raise NotImplementedError
-
-    def __enter__(self):
-        return self.enable()
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.disable()
-
-    def decorate_class(self, cls):
-        if issubclass(cls, TestCase):
-            decorated_setUp = cls.setUp
-
-            def setUp(inner_self):
-                context = self.enable()
-                inner_self.addCleanup(self.disable)
-                if self.attr_name:
-                    setattr(inner_self, self.attr_name, context)
-                decorated_setUp(inner_self)
-
-            cls.setUp = setUp
-            return cls
-        raise TypeError("Can only decorate subclasses of unittest.TestCase")
-
-    def decorate_callable(self, func):
-        @wraps(func)
-        def inner(*args, **kwargs):
-            with self as context:
-                if self.kwarg_name:
-                    kwargs[self.kwarg_name] = context
-                return func(*args, **kwargs)
-
-        return inner
-
-    def __call__(self, decorated):
-        if isinstance(decorated, type):
-            return self.decorate_class(decorated)
-        elif callable(decorated):
-            return self.decorate_callable(decorated)
-        raise TypeError("Cannot decorate object of type %s" % type(decorated))
-
-
-class override_settings(TestContextDecorator):
-    """
-    Act as either a decorator or a context manager. If it's a decorator, take a
-    function and return a wrapped function. If it's a contextmanager, use it
-    with the ``with`` statement. In either event, entering/exiting are called
-    before and after, respectively, the function/block is executed.
-    """
-
-    enable_exception = None
-
-    def __init__(self, **kwargs):
-        self.options = kwargs
-        super().__init__()
-
-    def enable(self):
-        # Keep this code at the beginning to leave the settings unchanged
-        # in case it raises an exception because INSTALLED_PACKAGES is invalid.
-        if "INSTALLED_PACKAGES" in self.options:
-            try:
-                packages.set_installed_packages(self.options["INSTALLED_PACKAGES"])
-            except Exception:
-                packages.unset_installed_packages()
-                raise
-        override = UserSettingsHolder(settings._wrapped)
-        for key, new_value in self.options.items():
-            setattr(override, key, new_value)
-        self.wrapped = settings._wrapped
-        settings._wrapped = override
-        # for key, new_value in self.options.items():
-        #     try:
-        #         setting_changed.send(
-        #             sender=settings._wrapped.__class__,
-        #             setting=key,
-        #             value=new_value,
-        #             enter=True,
-        #         )
-        #     except Exception as exc:
-        #         self.enable_exception = exc
-        #         self.disable()
-
-    def disable(self):
-        if "INSTALLED_PACKAGES" in self.options:
-            packages.unset_installed_packages()
-        settings._wrapped = self.wrapped
-        del self.wrapped
-        responses = []
-        for key in self.options:
-            getattr(settings, key, None)
-            # responses_for_setting = setting_changed.send_robust(
-            #     sender=settings._wrapped.__class__,
-            #     setting=key,
-            #     value=new_value,
-            #     enter=False,
-            # )
-            # responses.extend(responses_for_setting)
-        if self.enable_exception is not None:
-            exc = self.enable_exception
-            self.enable_exception = None
-            raise exc
-        for _, response in responses:
-            if isinstance(response, Exception):
-                raise response
-
-    def save_options(self, test_func):
-        if test_func._overridden_settings is None:
-            test_func._overridden_settings = self.options
-        else:
-            # Duplicate dict to prevent subclasses from altering their parent.
-            test_func._overridden_settings = {
-                **test_func._overridden_settings,
-                **self.options,
-            }
-
-
-class modify_settings(override_settings):
-    """
-    Like override_settings, but makes it possible to append, prepend, or remove
-    items instead of redefining the entire list.
-    """
-
-    def __init__(self, *args, **kwargs):
-        if args:
-            # Hack used when instantiating from SimpleTestCase.setUpClass.
-            assert not kwargs
-            self.operations = args[0]
-        else:
-            assert not args
-            self.operations = list(kwargs.items())
-        super(override_settings, self).__init__()
-
-    def save_options(self, test_func):
-        if test_func._modified_settings is None:
-            test_func._modified_settings = self.operations
-        else:
-            # Duplicate list to prevent subclasses from altering their parent.
-            test_func._modified_settings = (
-                list(test_func._modified_settings) + self.operations
-            )
-
-    def enable(self):
-        self.options = {}
-        for name, operations in self.operations:
-            try:
-                # When called from SimpleTestCase.setUpClass, values may be
-                # overridden several times; cumulate changes.
-                value = self.options[name]
-            except KeyError:
-                value = list(getattr(settings, name, []))
-            for action, items in operations.items():
-                # items my be a single value or an iterable.
-                if isinstance(items, str):
-                    items = [items]
-                if action == "append":
-                    value += [item for item in items if item not in value]
-                elif action == "prepend":
-                    value = [item for item in items if item not in value] + value
-                elif action == "remove":
-                    value = [item for item in value if item not in items]
-                else:
-                    raise ValueError("Unsupported action: %s" % action)
-            self.options[name] = value
-        super().enable()
-
-
-class ignore_warnings(TestContextDecorator):
-    def __init__(self, **kwargs):
-        self.ignore_kwargs = kwargs
-        if "message" in self.ignore_kwargs or "module" in self.ignore_kwargs:
-            self.filter_func = warnings.filterwarnings
-        else:
-            self.filter_func = warnings.simplefilter
-        super().__init__()
-
-    def enable(self):
-        self.catch_warnings = warnings.catch_warnings()
-        self.catch_warnings.__enter__()
-        self.filter_func("ignore", **self.ignore_kwargs)
-
-    def disable(self):
-        self.catch_warnings.__exit__(*sys.exc_info())