plain 0.61.0__py3-none-any.whl → 0.62.0__py3-none-any.whl

plain/AGENTS.md

@@ -11,4 +11,8 @@ The `plain` CLI is the main entrypoint for the framework. If `plain` is not avai
 - `plain agent docs <package>`: Show README.md and symbolicated source files for a specific package.
 - `plain agent docs --list`: List packages with docs available.
 - `plain agent request <path> --user <user_id>`: Make an authenticated request to the application and inspect the output.
-- `plain --help`: List all available commands (including those from installed packages)
+- `plain --help`: List all available commands (including those from installed packages).
+
+## Code style
+
+- Imports should be at the top of the file, unless there is a specific reason to import later (e.g. to avoid circular imports).

plain/CHANGELOG.md

@@ -1,5 +1,17 @@
 # plain changelog
 
+## [0.62.0](https://github.com/dropseed/plain/releases/plain@0.62.0) (2025-09-09)
+
+### What's changed
+
+- Complete rewrite of logging settings and AppLogger with improved formatters and debug capabilities ([ea7c953](https://github.com/dropseed/plain/commit/ea7c9537e3))
+- Added `app_logger.debug_mode()` context manager to temporarily change log level ([f535459](https://github.com/dropseed/plain/commit/f53545f9fa))
+- Minimum Python version updated to 3.13 ([d86e307](https://github.com/dropseed/plain/commit/d86e307efb))
+
+### Upgrade instructions
+
+- Make sure you are using Python 3.13 or higher
+
 ## [0.61.0](https://github.com/dropseed/plain/releases/plain@0.61.0) (2025-09-03)
 
 ### What's changed

plain/csrf/middleware.py

@@ -3,7 +3,7 @@ import re
 from urllib.parse import urlparse
 
 from plain.exceptions import DisallowedHost
-from plain.logs import log_response
+from plain.logs.utils import log_response
 from plain.runtime import settings
 
 from .views import CsrfFailureView

plain/internal/handlers/base.py

@@ -5,7 +5,7 @@ from opentelemetry import baggage, trace
 from opentelemetry.semconv.attributes import http_attributes, url_attributes
 
 from plain.exceptions import ImproperlyConfigured
-from plain.logs import log_response
+from plain.logs.utils import log_response
 from plain.runtime import settings
 from plain.urls import get_resolver
 from plain.utils.module_loading import import_string

plain/internal/handlers/exception.py

@@ -12,7 +12,7 @@ from plain.exceptions import (
 )
 from plain.http import Http404, ResponseServerError
 from plain.http.multipartparser import MultiPartParserError
-from plain.logs import log_response
+from plain.logs.utils import log_response
 from plain.runtime import settings
 from plain.utils.module_loading import import_string
 from plain.views.errors import ErrorView

plain/logs/README.md

@@ -4,7 +4,10 @@
 
 - [Overview](#overview)
 - [`app_logger`](#app_logger)
-- [`app_logger.kv`](#app_loggerkv)
+- [Output formats](#output-formats)
+- [Context management](#context-management)
+- [Debug mode](#debug-mode)
+- [Advanced usage](#advanced-usage)
 - [Logging settings](#logging-settings)
 
 ## Overview
@@ -13,49 +16,124 @@ In Python, configuring logging can be surprisingly complex. For most use cases,
 
 By default, both the `plain` and `app` loggers are set to the `INFO` level. You can quickly change this by using the `PLAIN_LOG_LEVEL` and `APP_LOG_LEVEL` environment variables.
 
+The `app_logger` supports multiple output formats and provides a friendly kwargs-based API for structured logging.
+
 ## `app_logger`
 
-The `app_logger` is a pre-configured logger you can use inside your app code.
+The `app_logger` is an enhanced logger that supports kwargs-style logging and multiple output formats.
 
 ```python
 from plain.logs import app_logger
 
 
 def example_function():
-    app_logger.info("Hey!")
+    # Basic logging
+    app_logger.info("User logged in")
+
+    # With structured context data (explicit **context parameter)
+    app_logger.info("User action", user_id=123, action="login", success=True)
+
+    # All log levels support context parameters
+    app_logger.debug("Debug info", step="validation", count=5)
+    app_logger.warning("Rate limit warning", user_id=456, limit_exceeded=True)
+    app_logger.error("Database error", error_code=500, table="users")
+
+    # Standard logging parameters with context
+    try:
+        risky_operation()
+    except Exception:
+        app_logger.error(
+            "Operation failed",
+            exc_info=True,  # Include exception traceback
+            stack_info=True,  # Include stack trace
+            user_id=789,
+            operation="risky_operation"
+        )
 ```
 
-## `app_logger.kv`
+## Output formats
+
+The `app_logger` supports three output formats controlled by the `APP_LOG_FORMAT` environment variable:
 
-The key-value logging format is popular for outputting more structured logs that are still human-readable.
+### Key-Value format (default)
+
+```bash
+export APP_LOG_FORMAT=keyvalue  # or leave unset for default
+```
+
+```
+[INFO] User action user_id=123 action=login success=True
+[ERROR] Database error error_code=500 table=users
+```
+
+### JSON format
+
+```bash
+export APP_LOG_FORMAT=json
+```
+
+```json
+{"timestamp": "2024-01-01 12:00:00,123", "level": "INFO", "message": "User action", "user_id": 123, "action": "login", "success": true}
+{"timestamp": "2024-01-01 12:00:01,456", "level": "ERROR", "message": "Database error", "error_code": 500, "table": "users"}
+```
+
+### Standard format
+
+```bash
+export APP_LOG_FORMAT=standard
+```
+
+```
+[INFO] User action
+[ERROR] Database error
+```
+
+Note: In standard format, the context kwargs are ignored and not displayed.
+
+## Context management
+
+The `app_logger` provides powerful context management for adding data to multiple log statements.
+
+### Persistent context
+
+Use the `context` dict to add data that persists across log calls:
 
 ```python
-from plain.logs import app_logger
+# Set persistent context
+app_logger.context["user_id"] = 123
+app_logger.context["request_id"] = "abc456"
 
+app_logger.info("Started processing")      # Includes user_id and request_id
+app_logger.info("Validation complete")     # Includes user_id and request_id
+app_logger.info("Processing finished")     # Includes user_id and request_id
 
-def example_function():
-    app_logger.kv("Example log line with", example_key="example_value")
+# Clear context
+app_logger.context.clear()
 ```
 
-## Logging settings
+### Temporary context
 
-You can further configure your logging with `settings.LOGGING`.
+Use `include_context()` for temporary context that only applies within a block:
 
 ```python
-# app/settings.py
-LOGGING = {
-    "version": 1,
-    "disable_existing_loggers": False,
-    "handlers": {
-        "console": {
-            "class": "logging.StreamHandler",
-        },
-    },
-    "loggers": {
-        "mylogger": {
-            "handlers": ["console"],
-            "level": "DEBUG",
-        },
-    },
-}
+app_logger.context["user_id"] = 123  # Persistent
+
+with app_logger.include_context(operation="payment", transaction_id="txn789"):
+    app_logger.info("Payment started")     # Has user_id, operation, transaction_id
+    app_logger.info("Payment validated")   # Has user_id, operation, transaction_id
+
+app_logger.info("Payment complete")        # Only has user_id
+```
+
+## Debug mode
+
+The `force_debug()` context manager allows temporarily enabling DEBUG level logging:
+
+```python
+# Debug messages might not show at INFO level
+app_logger.debug("This might not appear")
+
+# Temporarily enable debug logging
+with app_logger.force_debug():
+    app_logger.debug("This will definitely appear", extra_data="debug_info")
 ```

plain/logs/__init__.py

@@ -1,5 +1,3 @@
-from .configure import configure_logging
 from .loggers import app_logger
-from .utils import log_response
 
-__all__ = ["app_logger", "log_response", "configure_logging"]
+__all__ = ["app_logger"]

plain/logs/configure.py

@@ -1,44 +1,36 @@
 import logging
-import logging.config
-from os import environ
-
-
-def configure_logging(logging_settings):
-    # Load the defaults
-    default_logging = {
-        "version": 1,
-        "disable_existing_loggers": False,
-        "formatters": {
-            "simple": {
-                "format": "[%(levelname)s] %(message)s",
-            },
-        },
-        "handlers": {
-            "plain_console": {
-                "level": environ.get("PLAIN_LOG_LEVEL", "INFO"),
-                "class": "logging.StreamHandler",
-                "formatter": "simple",
-            },
-            "app_console": {
-                "level": environ.get("APP_LOG_LEVEL", "INFO"),
-                "class": "logging.StreamHandler",
-                "formatter": "simple",
-            },
-        },
-        "loggers": {
-            "plain": {
-                "handlers": ["plain_console"],
-                "level": environ.get("PLAIN_LOG_LEVEL", "INFO"),
-            },
-            "app": {
-                "handlers": ["app_console"],
-                "level": environ.get("APP_LOG_LEVEL", "INFO"),
-                "propagate": False,
-            },
-        },
-    }
-    logging.config.dictConfig(default_logging)
-
-    # Then customize it from settings
-    if logging_settings:
-        logging.config.dictConfig(logging_settings)
+
+from .formatters import JSONFormatter, KeyValueFormatter
+
+
+def configure_logging(*, plain_log_level, app_log_level, app_log_format):
+    # Create and configure the plain logger (uses standard Logger, not AppLogger)
+    plain_logger = logging.Logger("plain")
+    plain_logger.setLevel(plain_log_level)
+    plain_handler = logging.StreamHandler()
+    plain_handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+    plain_logger.addHandler(plain_handler)
+    plain_logger.propagate = False
+    logging.root.manager.loggerDict["plain"] = plain_logger
+
+    # Configure the existing app_logger
+    from .loggers import app_logger
+
+    app_logger.setLevel(app_log_level)
+    app_logger.propagate = False
+
+    app_handler = logging.StreamHandler()
+    match app_log_format:
+        case "json":
+            app_handler.setFormatter(JSONFormatter("%(json)s"))
+        case "keyvalue":
+            app_handler.setFormatter(
+                KeyValueFormatter("[%(levelname)s] %(message)s %(keyvalue)s")
+            )
+        case _:
+            app_handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+
+    app_logger.addHandler(app_handler)
+
+    # Register the app_logger in the logging system so getLogger("app") returns it
+    logging.root.manager.loggerDict["app"] = app_logger

plain/logs/debug.py

@@ -0,0 +1,36 @@
+import logging
+import threading
+
+
+class DebugMode:
+    """Context manager to temporarily set DEBUG level on a logger with reference counting."""
+
+    def __init__(self, logger):
+        self.logger = logger
+        self.original_level = None
+        self._ref_count = 0
+        self._lock = threading.Lock()
+
+    def __enter__(self):
+        """Store original level and set to DEBUG."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Restore original level."""
+        self.end()
+
+    def start(self):
+        """Enable DEBUG logging level."""
+        with self._lock:
+            if self._ref_count == 0:
+                self.original_level = self.logger.level
+                self.logger.setLevel(logging.DEBUG)
+            self._ref_count += 1
+
+    def end(self):
+        """Restore original logging level."""
+        with self._lock:
+            self._ref_count = max(0, self._ref_count - 1)
+            if self._ref_count == 0:
+                self.logger.setLevel(self.original_level)

plain/logs/formatters.py

@@ -0,0 +1,70 @@
+import json
+import logging
+
+
+class KeyValueFormatter(logging.Formatter):
+    """Formatter that outputs key-value pairs from Plain's context system."""
+
+    def format(self, record):
+        # Build key-value pairs from context
+        kv_pairs = []
+
+        # Look for Plain's context data
+        if hasattr(record, "context") and isinstance(record.context, dict):
+            for key, value in record.context.items():
+                formatted_value = self._format_value(value)
+                kv_pairs.append(f"{key}={formatted_value}")
+
+        # Add the keyvalue attribute to the record for %(keyvalue)s substitution
+        record.keyvalue = " ".join(kv_pairs)
+
+        # Let the parent formatter handle the format string with %(keyvalue)s
+        return super().format(record)
+
+    @staticmethod
+    def _format_value(value):
+        """Format a value for key-value output."""
+        if isinstance(value, str):
+            s = value
+        else:
+            s = str(value)
+
+        if '"' in s:
+            # Escape quotes and surround it
+            s = s.replace('"', '\\"')
+            s = f'"{s}"'
+        elif s == "":
+            # Quote empty strings instead of printing nothing
+            s = '""'
+        elif any(char in s for char in [" ", "/", "'", ":", "=", "."]):
+            # Surround these with quotes for parsers
+            s = f'"{s}"'
+
+        return s
+
+
+class JSONFormatter(logging.Formatter):
+    """Formatter that outputs JSON from Plain's context system, with optional format string."""
+
+    def format(self, record):
+        # Build the JSON object from Plain's context data
+        log_obj = {
+            "timestamp": self.formatTime(record),
+            "level": record.levelname,
+            "message": record.getMessage(),
+            "logger": record.name,
+        }
+
+        # Add Plain's context data to the main JSON object
+        if hasattr(record, "context") and isinstance(record.context, dict):
+            log_obj.update(record.context)
+
+        # Handle exceptions
+        if record.exc_info:
+            log_obj["exception"] = self.formatException(record.exc_info)
+
+        # Add the json attribute to the record for %(json)s substitution
+        record.json = json.dumps(log_obj, default=str, ensure_ascii=False)
+
+        # Let the parent formatter handle the format string with %(json)s
+        return super().format(record)

plain/logs/loggers.py

@@ -1,74 +1,183 @@
 import logging
-
-app_logger = logging.getLogger("app")
-
-
-class KVLogger:
-    def __init__(self, logger):
-        self.logger = logger
-        self.context = {}  # A dict that will be output in every log message
-
-    def log(self, level, message, **kwargs):
-        msg_kwargs = {
-            **kwargs,
-            **self.context,  # Put these last so they're at the end of the line
-        }
-        self.logger.log(level, f"{message} {self._format_kwargs(msg_kwargs)}")
-
-    def _format_kwargs(self, kwargs):
-        outputs = []
-
-        for k, v in kwargs.items():
-            self._validate_key(k)
-            formatted_value = self._format_value(v)
-            outputs.append(f"{k}={formatted_value}")
-
-        return " ".join(outputs)
-
-    def _validate_key(self, key):
-        if " " in key:
-            raise ValueError("Keys cannot have spaces")
-
-        if "=" in key:
-            raise ValueError("Keys cannot have equals signs")
-
-        if '"' in key or "'" in key:
-            raise ValueError("Keys cannot have quotes")
-
-    def _format_value(self, value):
-        if isinstance(value, str):
-            s = value
-        else:
-            s = str(value)
-
-        if '"' in s:
-            # Escape quotes and surround it
-            s = s.replace('"', '\\"')
-            s = f'"{s}"'
-        elif s == "":
-            # Quote empty strings instead of printing nothing
-            s = '""'
-        elif any(char in s for char in [" ", "/", "'", ":", "=", "."]):
-            # Surround these with quotes for parsers
-            s = f'"{s}"'
-
-        return s
-
-    def info(self, message, **kwargs):
-        self.log(logging.INFO, message, **kwargs)
-
-    def debug(self, message, **kwargs):
-        self.log(logging.DEBUG, message, **kwargs)
-
-    def warning(self, message, **kwargs):
-        self.log(logging.WARNING, message, **kwargs)
-
-    def error(self, message, **kwargs):
-        self.log(logging.ERROR, message, **kwargs)
-
-    def critical(self, message, **kwargs):
-        self.log(logging.CRITICAL, message, **kwargs)
-
-
-# Make this accessible from the app_logger
-app_logger.kv = KVLogger(app_logger)
+from contextlib import contextmanager
+
+from .debug import DebugMode
+
+
+class AppLogger(logging.Logger):
+    """Enhanced logger that supports kwargs-style logging and context management."""
+
+    def __init__(self, name):
+        super().__init__(name)
+        self.context = {}  # Public, mutable context dict
+        self.debug_mode = DebugMode(self)
+
+    @contextmanager
+    def include_context(self, **kwargs):
+        """Context manager for temporary context."""
+        # Store original context
+        original_context = self.context.copy()
+
+        # Add temporary context
+        self.context.update(kwargs)
+
+        try:
+            yield
+        finally:
+            # Restore original context
+            self.context = original_context
+
+    def force_debug(self):
+        """Return context manager for temporarily enabling DEBUG level logging."""
+        return self.debug_mode
+
+    # Override logging methods with explicit parameters for IDE support
+    def debug(
+        self,
+        msg,
+        *args,
+        exc_info=None,
+        extra=None,
+        stack_info=False,
+        stacklevel=1,
+        **context,
+    ):
+        if self.isEnabledFor(logging.DEBUG):
+            self._log(
+                logging.DEBUG,
+                msg,
+                args,
+                exc_info=exc_info,
+                extra=extra,
+                stack_info=stack_info,
+                stacklevel=stacklevel,
+                **context,
+            )
+
+    def info(
+        self,
+        msg,
+        *args,
+        exc_info=None,
+        extra=None,
+        stack_info=False,
+        stacklevel=1,
+        **context,
+    ):
+        if self.isEnabledFor(logging.INFO):
+            self._log(
+                logging.INFO,
+                msg,
+                args,
+                exc_info=exc_info,
+                extra=extra,
+                stack_info=stack_info,
+                stacklevel=stacklevel,
+                **context,
+            )
+
+    def warning(
+        self,
+        msg,
+        *args,
+        exc_info=None,
+        extra=None,
+        stack_info=False,
+        stacklevel=1,
+        **context,
+    ):
+        if self.isEnabledFor(logging.WARNING):
+            self._log(
+                logging.WARNING,
+                msg,
+                args,
+                exc_info=exc_info,
+                extra=extra,
+                stack_info=stack_info,
+                stacklevel=stacklevel,
+                **context,
+            )
+
+    def error(
+        self,
+        msg,
+        *args,
+        exc_info=None,
+        extra=None,
+        stack_info=False,
+        stacklevel=1,
+        **context,
+    ):
+        if self.isEnabledFor(logging.ERROR):
+            self._log(
+                logging.ERROR,
+                msg,
+                args,
+                exc_info=exc_info,
+                extra=extra,
+                stack_info=stack_info,
+                stacklevel=stacklevel,
+                **context,
+            )
+
+    def critical(
+        self,
+        msg,
+        *args,
+        exc_info=None,
+        extra=None,
+        stack_info=False,
+        stacklevel=1,
+        **context,
+    ):
+        if self.isEnabledFor(logging.CRITICAL):
+            self._log(
+                logging.CRITICAL,
+                msg,
+                args,
+                exc_info=exc_info,
+                extra=extra,
+                stack_info=stack_info,
+                stacklevel=stacklevel,
+                **context,
+            )
+
+    def _log(
+        self,
+        level,
+        msg,
+        args,
+        exc_info=None,
+        extra=None,
+        stack_info=False,
+        stacklevel=1,
+        **context,
+    ):
+        """Low-level logging routine which creates a LogRecord and then calls all handlers."""
+        # Check if extra already has a 'context' key
+        if extra and "context" in extra:
+            raise ValueError(
+                "The 'context' key in extra is reserved for Plain's context system"
+            )
+
+        # Build final extra with context
+        extra = extra.copy() if extra else {}
+
+        # Add our context (persistent + kwargs) to extra["context"]
+        if self.context or context:
+            extra["context"] = {**self.context, **context}
+
+        # Call the parent logger's _log method with explicit parameters
+        super()._log(
+            level=level,
+            msg=msg,
+            args=args,
+            exc_info=exc_info,
+            extra=extra or None,
+            stack_info=stack_info,
+            stacklevel=stacklevel,
+        )
+
+
+# Create the default app logger instance
+app_logger = AppLogger("app")

plain/runtime/__init__.py

@@ -3,6 +3,9 @@ import sys
 from importlib.metadata import entry_points
 from pathlib import Path
 
+from plain.logs.configure import configure_logging
+from plain.packages import packages_registry
+
 from .user_settings import Settings
 
 try:
@@ -48,9 +51,6 @@ def setup():
     for entry_point in entry_points().select(group="plain.setup"):
         entry_point.load()()
 
-    from plain.logs import configure_logging
-    from plain.packages import packages_registry
-
     if not APP_PATH.exists():
         raise AppPathNotFound(
             "No app directory found. Are you sure you're in a Plain project?"
@@ -62,7 +62,11 @@ def setup():
     if APP_PATH.parent.as_posix() not in sys.path:
         sys.path.insert(0, APP_PATH.parent.as_posix())
 
-    configure_logging(settings.LOGGING)
+    configure_logging(
+        plain_log_level=settings.PLAIN_LOG_LEVEL,
+        app_log_level=settings.APP_LOG_LEVEL,
+        app_log_format=settings.APP_LOG_FORMAT,
+    )
 
     packages_registry.populate(settings.INSTALLED_PACKAGES)
 

plain/runtime/global_settings.py

@@ -3,6 +3,8 @@ Default Plain settings. Override these with settings in the module pointed to
 by the PLAIN_SETTINGS_MODULE environment variable.
 """
 
+from os import environ
+
 from .utils import get_app_info_from_pyproject
 
 # MARK: Core Settings
@@ -137,9 +139,11 @@ CSRF_TRUSTED_ORIGINS: list[str] = []
 CSRF_EXEMPT_PATHS: list[str] = []
 
 # MARK: Logging
+# (Uses some custom env names in addition to PLAIN_ prefixed )
 
-# Custom logging configuration.
-LOGGING = {}
+PLAIN_LOG_LEVEL: str = environ.get("PLAIN_LOG_LEVEL", "INFO")
+APP_LOG_LEVEL: str = environ.get("APP_LOG_LEVEL", "INFO")
+APP_LOG_FORMAT: str = environ.get("APP_LOG_FORMAT", "keyvalue")
 
 # MARK: Assets
 

{plain-0.61.0.dist-info → plain-0.62.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: plain
-Version: 0.61.0
+Version: 0.62.0
 Summary: A web framework for building products with Python.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE
-Requires-Python: >=3.11
+Requires-Python: >=3.13
 Requires-Dist: click>=8.0.0
 Requires-Dist: jinja2>=3.1.2
 Requires-Dist: opentelemetry-api>=1.34.1

{plain-0.61.0.dist-info → plain-0.62.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-plain/AGENTS.md,sha256=Euyn6UG9gumJj1vXi6PFPmhRAlwedUfK7UcYTBF9Y9Y,893
-plain/CHANGELOG.md,sha256=X0ep2U-LXpociHtkEk-PTB30VVFiZHOocGunQgrqGAQ,11831
+plain/AGENTS.md,sha256=5XMGBpJgbCNIpp60DPXB7bpAtFk8FAzqiZke95T965o,1038
+plain/CHANGELOG.md,sha256=qEE2843NosxXT0v1-2HE02EX3pesOtoaBDYBqSFCI8k,12429
 plain/README.md,sha256=5BJyKhf0TDanWVbOQyZ3zsi5Lov9xk-LlJYCDWofM6Y,4078
 plain/__main__.py,sha256=GK39854Lc_LO_JP8DzY9Y2MIQ4cQEl7SXFJy244-lC8,110
 plain/debug.py,sha256=XdjnXcbPGsi0J2SpHGaLthhYU5AjhBlkHdemaP4sbYY,758
@@ -46,7 +46,7 @@ plain/cli/agent/md.py,sha256=7r1II8ckubBFOZNGPASWaPmJdgByWFPINLqIOzRetLQ,2581
 plain/cli/agent/prompt.py,sha256=rugYyQHV7JDNqGrx3_PPShwwqYlnEVbxw8RsczOo8tg,1253
 plain/cli/agent/request.py,sha256=JILrcxEMPagBXWrjNGMy3qatCYCXw-_uJMKkVHk_bho,6549
 plain/csrf/README.md,sha256=ApWpB-qlEf0LkOKm9Yr-6f_lB9XJEvGFDo_fraw8ghI,2391
-plain/csrf/middleware.py,sha256=d_vb8l0-KxzyqCivVq0jTCsFOm-ljwjmjVuZXKVYR5U,5113
+plain/csrf/middleware.py,sha256=n5_7v6qwFKgiAnKVyJa7RhwHoWepLkPudzIgZtdku5A,5119
 plain/csrf/views.py,sha256=HwQqfI6KPelHP9gSXhjfZaTLQic71PKsoZ6DPhr1rKI,572
 plain/forms/README.md,sha256=7MJQxNBoKkg0rW16qF6bGpUBxZrMrWjl2DZZk6gjzAU,2258
 plain/forms/__init__.py,sha256=UxqPwB8CiYPCQdHmUc59jadqaXqDmXBH8y4bt9vTPms,226
@@ -70,17 +70,19 @@ plain/internal/files/uploadedfile.py,sha256=JRB7T3quQjg-1y3l1ASPxywtSQZhaeMc45uF
 plain/internal/files/uploadhandler.py,sha256=63_QUwAwfq3bevw79i0S7zt2EB2UBoO7MaauvezaVMY,7198
 plain/internal/files/utils.py,sha256=xN4HTJXDRdcoNyrL1dFd528MBwodRlHZM8DGTD_oBIg,2646
 plain/internal/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-plain/internal/handlers/base.py,sha256=GFN5qoGqZmGinz6IOJgRW-dV4_nY5Dwo9L0F7muHvoc,6000
-plain/internal/handlers/exception.py,sha256=vfha_6-fz6S6VYCP1PMBfue2Gw-_th6jqaTE372fGlw,4809
+plain/internal/handlers/base.py,sha256=ur-nYmpvXjXhu03aPP1KV5GSNaLL_QZoT8x0v8l6_wg,6006
+plain/internal/handlers/exception.py,sha256=TbPYtgZ7ITJahUKhQWkptHK28Lb4zh_nOviNctC2EYs,4815
 plain/internal/handlers/wsgi.py,sha256=dgPT29t_F9llB-c5RYU3SHxGuZNaZ83xRjOfuOmtOl8,8209
 plain/internal/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plain/internal/middleware/headers.py,sha256=ENIW1Gwat54hv-ejgp2R8QTZm-PlaI7k44WU01YQrNk,964
 plain/internal/middleware/https.py,sha256=mS1YejfLB_5qlAoMfanh8Wn2O-RdSpOBdhvw2DRcTHs,1257
 plain/internal/middleware/slash.py,sha256=JWcIfGbXEKH00I7STq1AMdHhFGmQHC8lkKENa6280ko,2846
-plain/logs/README.md,sha256=ON6Zylg_WA_V7QiIbRY7sgsl2nfG7KFzIbxK2x3rPuc,1419
-plain/logs/__init__.py,sha256=rASvo4qFBDIHfkACmGLNGa6lRGbG9PbNjW6FmBt95ys,168
-plain/logs/configure.py,sha256=2kDJ-WPv3PV4H46mz5tTfzIa2kvN6cjVlb3t-AEbMyk,1307
-plain/logs/loggers.py,sha256=iz9SYcwP9w5QAuwpULl48SFkVyJuuMoQ_fdLgdCHpNg,2121
+plain/logs/README.md,sha256=rzOHfngjizLgXL21g0svC1Cdya2s_gBA_E-IljtHpy8,4069
+plain/logs/__init__.py,sha256=gFVMcNn5D6z0JrvUJgGsOeYj1NKNtEXhw0MvPDtkN6w,58
+plain/logs/configure.py,sha256=G5kLP-92hOWE7vlWG3lhSbzOKXobavFbqjohevJF1Jg,1322
+plain/logs/debug.py,sha256=QBXA_M498uGtqFnwHN08z6fItiGR4A732JyIWG2b39Q,1048
+plain/logs/formatters.py,sha256=sHB4yo7806YN_V6cCzs1WOGMIZLq5q_eOndRqODI-T4,2380
+plain/logs/loggers.py,sha256=kV2uZDxA5XU4GJF8dAOqny5LmbC8nPKZmakS-xX4x1Y,4625
 plain/logs/utils.py,sha256=9UzdCCQXJinGDs71Ngw297mlWkhgZStSd67ya4NOW98,1257
 plain/packages/README.md,sha256=iNqMtwFDVNf2TqKUzLKQW5Y4_GsssmdB4cVerzu27Ro,2674
 plain/packages/__init__.py,sha256=OpQny0xLplPdPpozVUUkrW2gB-IIYyDT1b4zMzOcCC4,160
@@ -94,8 +96,8 @@ plain/preflight/registry.py,sha256=vcqzaE1MIneNL_ydKPy_1zrSThnzsrWARSClLCJ-4b8,2
 plain/preflight/security.py,sha256=oxUZBp2M0bpBfUoLYepIxoex2Y90nyjlrL8XU8UTHYY,2438
 plain/preflight/urls.py,sha256=cQ-WnFa_5oztpKdtwhuIGb7pXEml__bHsjs1SWO2YNI,1468
 plain/runtime/README.md,sha256=sTqXXJkckwqkk9O06XMMSNRokAYjrZBnB50JD36BsYI,4873
-plain/runtime/__init__.py,sha256=8GtvKROf3HUCtneDYXTbEioPcCtwnV76dP57n2PnjuE,2343
-plain/runtime/global_settings.py,sha256=LX4g0ncNif_STuM83Idcron1j_TnQ9TJwWbVywexyZo,5788
+plain/runtime/__init__.py,sha256=byFYnHrpUCwkpkHtdNhxr9iUdLDCWJjy92HPj30Ilck,2478
+plain/runtime/global_settings.py,sha256=cDhsZOh0FemxUQE41viBjoMOriXV9_JnbSu28Kon_uI,6014
 plain/runtime/user_settings.py,sha256=OzMiEkE6ZQ50nxd1WIqirXPiNuMAQULklYHEzgzLWgA,11027
 plain/runtime/utils.py,sha256=p5IuNTzc7Kq-9Ym7etYnt_xqHw5TioxfSkFeq1bKdgk,832
 plain/signals/README.md,sha256=XefXqROlDhzw7Z5l_nx6Mhq6n9jjQ-ECGbH0vvhKWYg,272
@@ -158,8 +160,8 @@ plain/views/forms.py,sha256=ESZOXuo6IeYixp1RZvPb94KplkowRiwO2eGJCM6zJI0,2400
 plain/views/objects.py,sha256=v3Vgvdoc1s0QW6JNWWrO5XXy9zF7vgwndgxX1eOSQoE,4999
 plain/views/redirect.py,sha256=Xpb3cB7nZYvKgkNqcAxf9Jwm2SWcQ0u2xz4oO5M3vP8,1909
 plain/views/templates.py,sha256=oAlebEyfES0rzBhfyEJzFmgLkpkbleA6Eip-8zDp-yk,1863
-plain-0.61.0.dist-info/METADATA,sha256=9fm4uV_Uo8yyhaMeWayg-UyS4_y1_W6sI_tKNONklAY,4488
-plain-0.61.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-plain-0.61.0.dist-info/entry_points.txt,sha256=nn4uKTRRZuEKOJv3810s3jtSMW0Gew7XDYiKIvBRR6M,93
-plain-0.61.0.dist-info/licenses/LICENSE,sha256=m0D5O7QoH9l5Vz_rrX_9r-C8d9UNr_ciK6Qwac7o6yo,3175
-plain-0.61.0.dist-info/RECORD,,
+plain-0.62.0.dist-info/METADATA,sha256=vjydB1elvpE9PC6UhqU1F8B5eVxzWsoz2lrDJTnEYL0,4488
+plain-0.62.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+plain-0.62.0.dist-info/entry_points.txt,sha256=nn4uKTRRZuEKOJv3810s3jtSMW0Gew7XDYiKIvBRR6M,93
+plain-0.62.0.dist-info/licenses/LICENSE,sha256=m0D5O7QoH9l5Vz_rrX_9r-C8d9UNr_ciK6Qwac7o6yo,3175
+plain-0.62.0.dist-info/RECORD,,