plain 0.67.0__py3-none-any.whl → 0.68.1__py3-none-any.whl

plain/preflight/registry.py

@@ -1,72 +1,79 @@
-from plain.utils.inspect import func_accepts_kwargs
-from plain.utils.itercompat import is_iterable
+from plain.runtime import settings
 
 
 class CheckRegistry:
     def __init__(self):
-        self.registered_checks = set()
-        self.deployment_checks = set()
+        self.checks = {}  # name -> (check_class, deploy)
 
-    def register(self, check=None, deploy=False):
-        """
-        Can be used as a function or a decorator. Register given function
-        `f`. The function should receive **kwargs
-        and return list of Errors and Warnings.
-
-        Example::
-
-            registry = CheckRegistry()
-            @registry.register('mytag', 'anothertag')
-            def my_check(package_configs, **kwargs):
-                # ... perform checks and collect `errors` ...
-                return errors
-            # or
-            registry.register(my_check, 'mytag', 'anothertag')
-        """
-
-        def inner(check):
-            if not func_accepts_kwargs(check):
-                raise TypeError(
-                    "Check functions must accept keyword arguments (**kwargs)."
-                )
-            checks = self.deployment_checks if deploy else self.registered_checks
-            checks.add(check)
-            return check
-
-        if callable(check):
-            return inner(check)
-        else:
-            return inner
+    def register_check(self, check_class, name, deploy=False):
+        """Register a check class with a unique name."""
+        if name in self.checks:
+            raise ValueError(f"Check {name} already registered")
+        self.checks[name] = (check_class, deploy)
 
     def run_checks(
         self,
-        package_configs=None,
-        include_deployment_checks=False,
-        database=False,
+        include_deploy_checks=False,
     ):
         """
-        Run all registered checks and return list of Errors and Warnings.
+        Run all registered checks and yield (check_class, name, results) tuples.
         """
-        errors = []
-        checks = self.get_checks(include_deployment_checks)
-
-        for check in checks:
-            new_errors = check(package_configs=package_configs, database=database)
-            if not is_iterable(new_errors):
-                raise TypeError(
-                    f"The function {check!r} did not return a list. All functions "
-                    "registered with the checks registry must return a list.",
-                )
-            errors.extend(new_errors)
-        return errors
-
-    def get_checks(self, include_deployment_checks=False):
-        checks = list(self.registered_checks)
-        if include_deployment_checks:
-            checks.extend(self.deployment_checks)
-        return checks
+        # Validate silenced check names
+        silenced_checks = settings.PREFLIGHT_SILENCED_CHECKS
+        unknown_silenced = set(silenced_checks) - set(self.checks.keys())
+        if unknown_silenced:
+            unknown_names = ", ".join(sorted(unknown_silenced))
+            raise ValueError(
+                f"Unknown check names in PREFLIGHT_SILENCED_CHECKS: {unknown_names}. "
+                "Check for typos or remove outdated check names."
+            )
+
+        for name, (check_class, deploy) in sorted(self.checks.items()):
+            # Skip silenced checks
+            if name in silenced_checks:
+                continue
+
+            # Skip deployment checks if not requested
+            if deploy and not include_deploy_checks:
+                continue
+
+            # Instantiate and run check
+            check = check_class()
+            results = check.run()
+            yield check_class, name, results
+
+    def get_checks(self, include_deploy_checks=False):
+        """Get list of (check_class, name) tuples."""
+        result = []
+        for name, (check_class, deploy) in self.checks.items():
+            if deploy and not include_deploy_checks:
+                continue
+            result.append((check_class, name))
+        return result
 
 
 checks_registry = CheckRegistry()
-register_check = checks_registry.register
+
+
+def register_check(name: str, *, deploy: bool = False):
+    """
+    Decorator to register a check class.
+
+    Usage:
+        @register_check("security.secret_key", deploy=True)
+        class CheckSecretKey(PreflightCheck):
+            pass
+
+        @register_check("files.upload_temp_dir")
+        class CheckUploadTempDir(PreflightCheck):
+            pass
+    """
+
+    def wrapper(cls):
+        checks_registry.register_check(cls, name=name, deploy=deploy)
+        return cls
+
+    return wrapper
+
+
 run_checks = checks_registry.run_checks

plain/preflight/results.py

@@ -0,0 +1,29 @@
+from plain.runtime import settings
+
+
+class PreflightResult:
+    def __init__(self, *, fix: str, id: str, obj=None, warning: bool = False):
+        self.fix = fix
+        self.obj = obj
+        self.id = id
+        self.warning = warning
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__) and all(
+            getattr(self, attr) == getattr(other, attr)
+            for attr in ["fix", "obj", "id", "warning"]
+        )
+
+    def __str__(self):
+        if self.obj is None:
+            obj = ""
+        elif hasattr(self.obj, "_meta") and hasattr(self.obj._meta, "label"):
+            # Duck type for model objects - use their meta label
+            obj = self.obj._meta.label
+        else:
+            obj = str(self.obj)
+        id_part = f"({self.id}) " if self.id else ""
+        return f"{obj}: {id_part}{self.fix}"
+
+    def is_silenced(self):
+        return self.id and self.id in settings.PREFLIGHT_SILENCED_RESULTS

plain/preflight/security.py

@@ -1,21 +1,12 @@
-from plain.exceptions import ImproperlyConfigured
 from plain.runtime import settings
 
-from .messages import Error, Warning
+from .checks import PreflightCheck
 from .registry import register_check
+from .results import PreflightResult
 
 SECRET_KEY_MIN_LENGTH = 50
 SECRET_KEY_MIN_UNIQUE_CHARACTERS = 5
 
-SECRET_KEY_WARNING_MSG = (
-    f"Your %s has less than {SECRET_KEY_MIN_LENGTH} characters or less than "
-    f"{SECRET_KEY_MIN_UNIQUE_CHARACTERS} unique characters. Please generate "
-    f"a long and random value, otherwise many of Plain's security-critical "
-    f"features will be vulnerable to attack."
-)
-
-W025 = Warning(SECRET_KEY_WARNING_MSG, id="security.W025")
-
 
 def _check_secret_key(secret_key):
     return (
@@ -24,66 +15,67 @@ def _check_secret_key(secret_key):
     )
 
 
-@register_check(deploy=True)
-def check_secret_key(package_configs, **kwargs):
-    try:
-        secret_key = settings.SECRET_KEY
-    except (ImproperlyConfigured, AttributeError):
-        passed_check = False
-    else:
-        passed_check = _check_secret_key(secret_key)
-    return (
-        []
-        if passed_check
-        else [
-            Warning(
-                SECRET_KEY_WARNING_MSG % "SECRET_KEY",
-                id="security.W009",
-            )
-        ]
-    )
+@register_check(name="security.secret_key", deploy=True)
+class CheckSecretKey(PreflightCheck):
+    """Validates that SECRET_KEY is long and random enough for security."""
+
+    def run(self):
+        if not _check_secret_key(settings.SECRET_KEY):
+            return [
+                PreflightResult(
+                    fix=f"SECRET_KEY is too weak (needs {SECRET_KEY_MIN_LENGTH}+ characters, "
+                    f"{SECRET_KEY_MIN_UNIQUE_CHARACTERS}+ unique). Generate a new long random value or "
+                    f"Plain's security features will be vulnerable to attack.",
+                    id="security.secret_key_weak",
+                )
+            ]
+        return []
 
 
-@register_check(deploy=True)
-def check_secret_key_fallbacks(package_configs, **kwargs):
-    warnings = []
-    try:
-        fallbacks = settings.SECRET_KEY_FALLBACKS
-    except (ImproperlyConfigured, AttributeError):
-        warnings.append(Warning(W025.msg % "SECRET_KEY_FALLBACKS", id=W025.id))
-    else:
-        for index, key in enumerate(fallbacks):
+@register_check(name="security.secret_key_fallbacks", deploy=True)
+class CheckSecretKeyFallbacks(PreflightCheck):
+    """Validates that SECRET_KEY_FALLBACKS are long and random enough for security."""
+
+    def run(self):
+        errors = []
+        for index, key in enumerate(settings.SECRET_KEY_FALLBACKS):
             if not _check_secret_key(key):
-                warnings.append(
-                    Warning(W025.msg % f"SECRET_KEY_FALLBACKS[{index}]", id=W025.id)
+                errors.append(
+                    PreflightResult(
+                        fix=f"SECRET_KEY_FALLBACKS[{index}] is too weak (needs {SECRET_KEY_MIN_LENGTH}+ characters, "
+                        f"{SECRET_KEY_MIN_UNIQUE_CHARACTERS}+ unique). Generate a new long random value or "
+                        f"Plain's security features will be vulnerable to attack.",
+                        id="security.secret_key_fallback_weak",
+                    )
                 )
-    return warnings
+        return errors
 
 
-@register_check(deploy=True)
-def check_debug(package_configs, **kwargs):
-    passed_check = not settings.DEBUG
-    return (
-        []
-        if passed_check
-        else [
-            Warning(
-                "You should not have DEBUG set to True in deployment.",
-                id="security.W018",
-            )
-        ]
-    )
+@register_check(name="security.debug", deploy=True)
+class CheckDebug(PreflightCheck):
+    """Ensures DEBUG is False in production deployment."""
 
+    def run(self):
+        if settings.DEBUG:
+            return [
+                PreflightResult(
+                    fix="DEBUG is True in deployment. Set DEBUG=False to prevent exposing sensitive information.",
+                    id="security.debug_enabled_in_production",
+                )
+            ]
+        return []
 
-@register_check(deploy=True)
-def check_allowed_hosts(package_configs, **kwargs):
-    return (
-        []
-        if settings.ALLOWED_HOSTS
-        else [
-            Error(
-                "ALLOWED_HOSTS must not be empty in deployment.",
-                id="security.E020",
-            )
-        ]
-    )
+
+@register_check(name="security.allowed_hosts", deploy=True)
+class CheckAllowedHosts(PreflightCheck):
+    """Ensures ALLOWED_HOSTS is not empty in production deployment."""
+
+    def run(self):
+        if not settings.ALLOWED_HOSTS:
+            return [
+                PreflightResult(
+                    fix="ALLOWED_HOSTS is empty in deployment. Add your domain(s) to prevent host header attacks.",
+                    id="security.allowed_hosts_empty",
+                )
+            ]
+        return []

plain/preflight/urls.py

@@ -1,54 +1,13 @@
-from plain.runtime import settings
+from .checks import PreflightCheck
+from .registry import register_check
 
-from . import Error, register_check
 
+@register_check("urls.config")
+class CheckUrlConfig(PreflightCheck):
+    """Validates the URL configuration for common issues."""
 
-@register_check
-def check_url_config(package_configs, **kwargs):
-    if getattr(settings, "URLS_ROUTER", None):
+    def run(self):
         from plain.urls import get_resolver
 
         resolver = get_resolver()
-        return check_resolver(resolver)
-
-    return []
-
-
-def check_resolver(resolver):
-    """
-    Recursively check the resolver.
-    """
-    check_method = getattr(resolver, "check", None)
-    if check_method is not None:
-        return check_method()
-    elif not hasattr(resolver, "resolve"):
-        return get_warning_for_invalid_pattern(resolver)
-    else:
-        return []
-
-
-def get_warning_for_invalid_pattern(pattern):
-    """
-    Return a list containing a warning that the pattern is invalid.
-
-    describe_pattern() cannot be used here, because we cannot rely on the
-    urlpattern having regex or name attributes.
-    """
-    if isinstance(pattern, str):
-        hint = (
-            f"Try removing the string '{pattern}'. The list of urlpatterns should not "
-            "have a prefix string as the first element."
-        )
-    elif isinstance(pattern, tuple):
-        hint = "Try using path() instead of a tuple."
-    else:
-        hint = None
-
-    return [
-        Error(
-            f"Your URL pattern {pattern!r} is invalid. Ensure that urlpatterns is a list "
-            "of path() and/or re_path() instances.",
-            hint=hint,
-            id="urls.E004",
-        )
-    ]
+        return resolver.preflight()

plain/runtime/global_settings.py

@@ -152,11 +152,11 @@ ASSETS_BASE_URL: str = ""
 
 # MARK: Preflight Checks
 
-# List of all issues generated by system checks that should be silenced. Light
-# issues like warnings, infos or debugs will not generate a message. Silencing
-# serious issues like errors and criticals does not result in hiding the
-# message, but Plain will not stop you from e.g. running server.
-PREFLIGHT_SILENCED_CHECKS = []
+# Silence checks by name
+PREFLIGHT_SILENCED_CHECKS: list[str] = []
+
+# Silence specific check results by id
+PREFLIGHT_SILENCED_RESULTS: list[str] = []
 
 # MARK: Templates
 

plain/templates/jinja/__init__.py

@@ -1,6 +1,3 @@
-import importlib.util
-from importlib import import_module
-
 from plain.packages import packages_registry
 from plain.runtime import settings
 from plain.utils.functional import LazyObject
@@ -10,10 +7,6 @@ from .environments import DefaultEnvironment, get_template_dirs
 
 
 class JinjaEnvironment(LazyObject):
-    def __init__(self, *args, **kwargs):
-        self.__dict__["_imported_modules"] = set()
-        super().__init__(*args, **kwargs)
-
     def _setup(self):
         environment_setting = settings.TEMPLATES_JINJA_ENVIRONMENT
 
@@ -25,22 +18,8 @@ class JinjaEnvironment(LazyObject):
         # We have to set _wrapped before we trigger the autoloading of "register" commands
         self._wrapped = env
 
-        for package_config in packages_registry.get_package_configs():
-            # Autoload template helpers if the package provides a ``templates`` module
-            import_name = f"{package_config.name}.templates"
-            if import_name in self._imported_modules:
-                continue
-            if importlib.util.find_spec(import_name) is None:
-                continue
-            import_module(import_name)
-            self._imported_modules.add(import_name)
-
-        # Autoload template helpers from the local ``app`` package if present
-        import_name = "app.templates"
-        if import_name not in self._imported_modules:
-            if importlib.util.find_spec(import_name) is not None:
-                import_module(import_name)
-                self._imported_modules.add(import_name)
+        # Autoload template helpers using the registry method
+        packages_registry.autodiscover_modules("templates", include_app=True)
 
 
 environment = JinjaEnvironment()

plain/urls/patterns.py

@@ -3,7 +3,7 @@ import string
 
 from plain.exceptions import ImproperlyConfigured
 from plain.internal import internalcode
-from plain.preflight import Warning
+from plain.preflight import PreflightResult
 from plain.runtime import settings
 from plain.utils.regex_helper import _lazy_re_compile
 
@@ -33,11 +33,10 @@ class CheckURLMixin:
         if regex_pattern.startswith(("/", "^/", "^\\/")) and not regex_pattern.endswith(
             "/"
         ):
-            warning = Warning(
-                f"Your URL pattern {self.describe()} has a route beginning with a '/'. Remove this "
-                "slash as it is unnecessary. If this pattern is targeted in an "
-                "include(), ensure the include() pattern has a trailing '/'.",
-                id="urls.W002",
+            warning = PreflightResult(
+                fix=f"URL pattern {self.describe()} starts with unnecessary '/'. Remove the leading slash.",
+                warning=True,
+                id="urls.pattern_starts_with_slash",
             )
             return [warning]
         else:
@@ -68,7 +67,7 @@ class RegexPattern(CheckURLMixin):
             return path[match.end() :], args, kwargs
         return None
 
-    def check(self):
+    def preflight(self):
         warnings = []
         warnings.extend(self._check_pattern_startswith_slash())
         if not self._is_endpoint:
@@ -79,11 +78,10 @@ class RegexPattern(CheckURLMixin):
         regex_pattern = self.regex.pattern
         if regex_pattern.endswith("$") and not regex_pattern.endswith(r"\$"):
             return [
-                Warning(
-                    f"Your URL pattern {self.describe()} uses include with a route ending with a '$'. "
-                    "Remove the dollar from the route to avoid problems including "
-                    "URLs.",
-                    id="urls.W001",
+                PreflightResult(
+                    fix=f"Include pattern {self.describe()} ends with '$' which prevents URL inclusion. Remove the dollar sign.",
+                    warning=True,
+                    id="urls.include_pattern_ends_with_dollar",
                 )
             ]
         else:
@@ -174,16 +172,17 @@ class RoutePattern(CheckURLMixin):
             return path[match.end() :], (), kwargs
         return None
 
-    def check(self):
+    def preflight(self):
         warnings = self._check_pattern_startswith_slash()
         route = self._route
         if "(?P<" in route or route.startswith("^") or route.endswith("$"):
             warnings.append(
-                Warning(
-                    f"Your URL pattern {self.describe()} has a route that contains '(?P<', begins "
+                PreflightResult(
+                    fix=f"Your URL pattern {self.describe()} has a route that contains '(?P<', begins "
                     "with a '^', or ends with a '$'. This was likely an oversight "
                     "when migrating to plain.urls.path().",
-                    id="2_0.W001",
+                    warning=True,
+                    id="urls.path_migration_warning",
                 )
             )
         return warnings
@@ -204,9 +203,9 @@ class URLPattern:
     def __repr__(self):
         return f"<{self.__class__.__name__} {self.pattern.describe()}>"
 
-    def check(self):
+    def preflight(self):
         warnings = self._check_pattern_name()
-        warnings.extend(self.pattern.check())
+        warnings.extend(self.pattern.preflight())
         return warnings
 
     def _check_pattern_name(self):
@@ -214,10 +213,11 @@ class URLPattern:
         Check that the pattern name does not contain a colon.
         """
         if self.pattern.name is not None and ":" in self.pattern.name:
-            warning = Warning(
-                f"Your URL pattern {self.pattern.describe()} has a name including a ':'. Remove the colon, to "
+            warning = PreflightResult(
+                fix=f"Your URL pattern {self.pattern.describe()} has a name including a ':'. Remove the colon, to "
                 "avoid ambiguous namespace references.",
-                id="urls.W003",
+                warning=True,
+                id="urls.pattern_name_contains_colon",
             )
             return [warning]
         else:

plain/urls/resolvers.py

@@ -11,7 +11,6 @@ import re
 from threading import local
 from urllib.parse import quote
 
-from plain.preflight.urls import check_resolver
 from plain.runtime import settings
 from plain.utils.datastructures import MultiValueDict
 from plain.utils.http import RFC3986_SUBDELIMS, escape_leading_slashes
@@ -114,11 +113,12 @@ class URLResolver:
     def __repr__(self):
         return f"<{self.__class__.__name__} {repr(self.router)} ({self.namespace}) {self.pattern.describe()}>"
 
-    def check(self):
+    def preflight(self):
         messages = []
+        messages.extend(self.pattern.preflight())
         for pattern in self.url_patterns:
-            messages.extend(check_resolver(pattern))
-        return messages or self.pattern.check()
+            messages.extend(pattern.preflight())
+        return messages
 
     def _populate(self):
         # Short-circuit if called recursively in this thread to prevent

{plain-0.67.0.dist-info → plain-0.68.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain
-Version: 0.67.0
+Version: 0.68.1
 Summary: A web framework for building products with Python.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE