plain 0.70.0__tar.gz → 0.71.0__tar.gz

{plain-0.70.0 → plain-0.71.0}/PKG-INFO

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

{plain-0.70.0 → plain-0.71.0}/plain/CHANGELOG.md

@@ -1,5 +1,22 @@
 # plain changelog
 
+## [0.71.0](https://github.com/dropseed/plain/releases/plain@0.71.0) (2025-09-30)
+
+### What's changed
+
+- Renamed `HttpRequest` to `Request` throughout the codebase for consistency and simplicity ([cd46ff20](https://github.com/dropseed/plain/commit/cd46ff2003))
+- Renamed `HttpHeaders` to `RequestHeaders` for naming consistency ([cd46ff20](https://github.com/dropseed/plain/commit/cd46ff2003))
+- Renamed settings: `APP_NAME` → `NAME`, `APP_VERSION` → `VERSION`, `APP_LOG_LEVEL` → `LOG_LEVEL`, `APP_LOG_FORMAT` → `LOG_FORMAT`, `PLAIN_LOG_LEVEL` → `FRAMEWORK_LOG_LEVEL` ([4c5f2166](https://github.com/dropseed/plain/commit/4c5f2166c1))
+- Added `request.get_preferred_type()` method to select the most preferred media type from Accept header ([b105ba4d](https://github.com/dropseed/plain/commit/b105ba4dd0))
+- Moved helper functions in `http/request.py` to be static methods of `QueryDict` ([0e1b0133](https://github.com/dropseed/plain/commit/0e1b0133c5))
+
+### Upgrade instructions
+
+- Replace all imports and usage of `HttpRequest` with `Request`
+- Replace all imports and usage of `HttpHeaders` with `RequestHeaders`
+- Update any custom settings that reference `APP_NAME` to `NAME`, `APP_VERSION` to `VERSION`, `APP_LOG_LEVEL` to `LOG_LEVEL`, `APP_LOG_FORMAT` to `LOG_FORMAT`, and `PLAIN_LOG_LEVEL` to `FRAMEWORK_LOG_LEVEL`
+- Configuring these settings via the `PLAIN_` prefixed environment variable will need to be updated accordingly
+
 ## [0.70.0](https://github.com/dropseed/plain/releases/plain@0.70.0) (2025-09-30)
 
 ### What's changed

{plain-0.70.0 → plain-0.71.0}/plain/csrf/middleware.py

@@ -13,7 +13,7 @@ from .views import CsrfFailureView
 
 if TYPE_CHECKING:
     from plain.http import Response
-    from plain.http.request import HttpRequest
+    from plain.http.request import Request
 
 logger = logging.getLogger("plain.security.csrf")
 
@@ -27,7 +27,7 @@ class CsrfViewMiddleware:
     like subdomains can have different trust levels and are rejected.
     """
 
-    def __init__(self, get_response: Callable[[HttpRequest], Response]):
+    def __init__(self, get_response: Callable[[Request], Response]):
         self.get_response = get_response
 
         # Compile CSRF exempt patterns once for performance
@@ -35,7 +35,7 @@ class CsrfViewMiddleware:
             re.compile(r) for r in settings.CSRF_EXEMPT_PATHS
         ]
 
-    def __call__(self, request: HttpRequest) -> Response:
+    def __call__(self, request: Request) -> Response:
         allowed, reason = self.should_allow_request(request)
 
         if allowed:
@@ -43,7 +43,7 @@ class CsrfViewMiddleware:
         else:
             return self.reject(request, reason)
 
-    def should_allow_request(self, request: HttpRequest) -> tuple[bool, str]:
+    def should_allow_request(self, request: Request) -> tuple[bool, str]:
         # 1. Allow safe methods (GET, HEAD, OPTIONS)
         if request.method in ("GET", "HEAD", "OPTIONS"):
             return True, f"Safe HTTP method: {request.method}"
@@ -128,7 +128,7 @@ class CsrfViewMiddleware:
             f"Cross-origin request detected - Origin {origin} does not match Host",
         )
 
-    def reject(self, request: HttpRequest, reason: str) -> Response:
+    def reject(self, request: Request, reason: str) -> Response:
         """Reject a request with a 403 Forbidden response."""
 
         response = CsrfFailureView.as_view()(request, reason=reason)

{plain-0.70.0 → plain-0.71.0}/plain/forms/forms.py

@@ -14,7 +14,7 @@ from .exceptions import ValidationError
 from .fields import Field, FileField
 
 if TYPE_CHECKING:
-    from plain.http import HttpRequest
+    from plain.http import Request
 
     from .boundfield import BoundField
 
@@ -70,7 +70,7 @@ class BaseForm:
     def __init__(
         self,
         *,
-        request: HttpRequest,
+        request: Request,
         auto_id: str | bool = "id_%s",
         prefix: str | None = None,
         initial: dict[str, Any] | None = None,

{plain-0.70.0 → plain-0.71.0}/plain/http/README.md

@@ -6,7 +6,7 @@
 
 ## Overview
 
-Typically you will interact with [request](request.py#HttpRequest) and [response](response.py#ResponseBase) objects in your views and middleware.
+Typically you will interact with [Request](request.py#Request) and [Response](response.py#ResponseBase) objects in your views and middleware.
 
 ```python
 from plain.views import View

{plain-0.70.0 → plain-0.71.0}/plain/http/__init__.py

@@ -1,9 +1,9 @@
 from plain.http.cookie import parse_cookie
 from plain.http.request import (
-    HttpHeaders,
-    HttpRequest,
     QueryDict,
     RawPostDataException,
+    Request,
+    RequestHeaders,
     UnreadablePostError,
 )
 from plain.http.response import (
@@ -26,8 +26,8 @@ from plain.http.response import (
 
 __all__ = [
     "parse_cookie",
-    "HttpHeaders",
-    "HttpRequest",
+    "Request",
+    "RequestHeaders",
     "QueryDict",
     "RawPostDataException",
     "UnreadablePostError",

{plain-0.70.0 → plain-0.71.0}/plain/http/request.py

@@ -47,7 +47,7 @@ class RawPostDataException(Exception):
     pass
 
 
-class HttpRequest:
+class Request:
     """A basic HTTP request."""
 
     # The encoding used in GET/POST dicts. None means use default setting.
@@ -89,7 +89,7 @@ class HttpRequest:
                 del obj_dict[attr]
         return obj_dict
 
-    def __deepcopy__(self, memo: dict[int, Any]) -> HttpRequest:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Request:
         obj = copy.copy(self)
         for attr in self.non_picklable_attrs:
             if hasattr(self, attr):
@@ -98,18 +98,41 @@ class HttpRequest:
         return obj
 
     @cached_property
-    def headers(self) -> HttpHeaders:
-        return HttpHeaders(self.meta)
+    def headers(self) -> RequestHeaders:
+        return RequestHeaders(self.meta)
 
     @cached_property
     def accepted_types(self) -> list[MediaType]:
-        """Return a list of MediaType instances."""
-        return parse_accept_header(self.headers.get("Accept", "*/*"))
+        """Return accepted media types sorted by quality value (highest first).
+
+        When quality values are equal, the original order from the Accept header
+        is preserved (as per HTTP spec).
+        """
+        header = self.headers.get("Accept", "*/*")
+        types = [MediaType(token) for token in header.split(",") if token.strip()]
+        return sorted(types, key=lambda t: t.quality, reverse=True)
+
+    def get_preferred_type(self, *media_types: str) -> str | None:
+        """Return the most preferred media type from the given options.
+
+        Checks the Accept header in priority order (by quality value) and returns
+        the first matching media type from the provided options.
+
+        Returns None if none of the options are accepted.
+
+        Example:
+            # Accept: text/html;q=1.0, application/json;q=0.5
+            request.get_preferred_type("application/json", "text/html")  # Returns "text/html"
+        """
+        for accepted in self.accepted_types:
+            for option in media_types:
+                if accepted.match(option):
+                    return option
+        return None
 
     def accepts(self, media_type: str) -> bool:
-        return any(
-            accepted_type.match(media_type) for accepted_type in self.accepted_types
-        )
+        """Check if the given media type is accepted."""
+        return self.get_preferred_type(media_type) is not None
 
     def _set_content_type_params(self, meta: dict[str, Any]) -> None:
         """Set content_type, content_params, and encoding."""
@@ -432,7 +455,7 @@ class HttpRequest:
         return unsign_cookie_value(key, cookie_value, salt, max_age, default)
 
 
-class HttpHeaders(CaseInsensitiveMapping):
+class RequestHeaders(CaseInsensitiveMapping):
     HTTP_PREFIX = "HTTP_"
     # PEP 333 gives two headers which aren't prepended with HTTP_.
     UNPREFIXED_HEADERS = {"CONTENT_TYPE", "CONTENT_LENGTH"}
@@ -563,8 +586,8 @@ class QueryDict(MultiValueDict):
 
     def __setitem__(self, key: str, value: Any) -> None:
         self._assert_mutable()
-        key = bytes_to_text(key, self.encoding)
-        value = bytes_to_text(value, self.encoding)
+        key = self.bytes_to_text(key, self.encoding)
+        value = self.bytes_to_text(value, self.encoding)
         super().__setitem__(key, value)
 
     def __delitem__(self, key: str) -> None:
@@ -586,8 +609,8 @@ class QueryDict(MultiValueDict):
 
     def setlist(self, key: str, list_: list[Any]) -> None:
         self._assert_mutable()
-        key = bytes_to_text(key, self.encoding)
-        list_ = [bytes_to_text(elt, self.encoding) for elt in list_]
+        key = self.bytes_to_text(key, self.encoding)
+        list_ = [self.bytes_to_text(elt, self.encoding) for elt in list_]
         super().setlist(key, list_)
 
     def setlistdefault(
@@ -598,8 +621,8 @@ class QueryDict(MultiValueDict):
 
     def appendlist(self, key: str, value: Any) -> None:
         self._assert_mutable()
-        key = bytes_to_text(key, self.encoding)
-        value = bytes_to_text(value, self.encoding)
+        key = self.bytes_to_text(key, self.encoding)
+        value = self.bytes_to_text(value, self.encoding)
         super().appendlist(key, value)
 
     def pop(self, key: str, *args: Any) -> Any:
@@ -616,8 +639,8 @@ class QueryDict(MultiValueDict):
 
     def setdefault(self, key: str, default: Any = None) -> Any:
         self._assert_mutable()
-        key = bytes_to_text(key, self.encoding)
-        default = bytes_to_text(default, self.encoding)
+        key = self.bytes_to_text(key, self.encoding)
+        default = self.bytes_to_text(default, self.encoding)
         return super().setdefault(key, default)
 
     def copy(self) -> QueryDict:
@@ -656,6 +679,23 @@ class QueryDict(MultiValueDict):
             )
         return "&".join(output)
 
+    # It's neither necessary nor appropriate to use
+    # plain.utils.encoding.force_str() for parsing URLs and form inputs. Thus,
+    # this slightly more restricted function, used by QueryDict.
+    @staticmethod
+    def bytes_to_text(s: Any, encoding: str) -> str:
+        """
+        Convert bytes objects to strings, using the given encoding. Illegally
+        encoded input characters are replaced with Unicode "unknown" codepoint
+        (\ufffd).
+
+        Return any non-bytes objects without change.
+        """
+        if isinstance(s, bytes):
+            return str(s, encoding, "replace")
+        else:
+            return s
+
 
 class MediaType:
     def __init__(self, media_type_raw_line: str | MediaType):
@@ -678,6 +718,11 @@ class MediaType:
     def is_all_types(self) -> bool:
         return self.main_type == "*" and self.sub_type == "*"
 
+    @property
+    def quality(self) -> float:
+        """Return the quality value from the Accept header (default 1.0)."""
+        return float(self.params.get("q", 1.0))
+
     def match(self, other: str | MediaType) -> bool:
         if self.is_all_types:
             return True
@@ -685,24 +730,3 @@ class MediaType:
         if self.main_type == other.main_type and self.sub_type in {"*", other.sub_type}:
             return True
         return False
-
-
-# It's neither necessary nor appropriate to use
-# plain.utils.encoding.force_str() for parsing URLs and form inputs. Thus,
-# this slightly more restricted function, used by QueryDict.
-def bytes_to_text(s: Any, encoding: str) -> str:
-    """
-    Convert bytes objects to strings, using the given encoding. Illegally
-    encoded input characters are replaced with Unicode "unknown" codepoint
-    (\ufffd).
-
-    Return any non-bytes objects without change.
-    """
-    if isinstance(s, bytes):
-        return str(s, encoding, "replace")
-    else:
-        return s
-
-
-def parse_accept_header(header: str) -> list[MediaType]:
-    return [MediaType(token) for token in header.split(",") if token.strip()]

{plain-0.70.0 → plain-0.71.0}/plain/internal/files/uploadhandler.py

@@ -19,7 +19,7 @@ from plain.utils.module_loading import import_string
 if TYPE_CHECKING:
     from typing import Any
 
-    from plain.http import HttpRequest
+    from plain.http import Request
 
 __all__ = [
     "UploadFileException",
@@ -85,7 +85,7 @@ class FileUploadHandler:
 
     chunk_size = 64 * 2**10  # : The default chunk size is 64 KB.
 
-    def __init__(self, request: HttpRequest | None = None) -> None:
+    def __init__(self, request: Request | None = None) -> None:
         self.file_name = None
         self.content_type = None
         self.content_length = None
@@ -265,8 +265,8 @@ def load_handler(path: str, *args: Any, **kwargs: Any) -> FileUploadHandler:
     Given a path to a handler, return an instance of that handler.
 
     E.g.::
-        >>> from plain.http import HttpRequest
-        >>> request = HttpRequest()
+        >>> from plain.http import Request
+        >>> request = Request()
         >>> load_handler(
         ...     'plain.internal.files.uploadhandler.TemporaryFileUploadHandler',
         ...     request,

{plain-0.70.0 → plain-0.71.0}/plain/internal/handlers/base.py

@@ -18,7 +18,7 @@ from .exception import convert_exception_to_response
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from plain.http import HttpRequest, Response
+    from plain.http import Request, Response
     from plain.urls import ResolverMatch
 
 logger = logging.getLogger("plain.request")
@@ -43,7 +43,7 @@ tracer = trace.get_tracer("plain")
 
 
 class BaseHandler:
-    _middleware_chain: Callable[[HttpRequest], Response] | None = None
+    _middleware_chain: Callable[[Request], Response] | None = None
 
     def load_middleware(self) -> None:
         """
@@ -72,8 +72,8 @@ class BaseHandler:
         # as a flag for initialization being complete.
         self._middleware_chain = handler
 
-    def get_response(self, request: HttpRequest) -> Response:
-        """Return a Response object for the given HttpRequest."""
+    def get_response(self, request: Request) -> Response:
+        """Return a Response object for the given Request."""
 
         span_attributes = {
             "plain.request.id": request.unique_id,
@@ -124,7 +124,7 @@ class BaseHandler:
                 )
             return response
 
-    def _get_response(self, request: HttpRequest) -> Response:
+    def _get_response(self, request: Request) -> Response:
         """
         Resolve and call the view, then apply view, exception, and
         template_response middleware. This method is everything that happens
@@ -141,7 +141,7 @@ class BaseHandler:
 
         return response
 
-    def resolve_request(self, request: HttpRequest) -> ResolverMatch:
+    def resolve_request(self, request: Request) -> ResolverMatch:
         """
         Retrieve/set the urlrouter for the request. Return the view resolved,
         with its args and kwargs.

{plain-0.70.0 → plain-0.71.0}/plain/internal/handlers/exception.py

@@ -23,12 +23,12 @@ from plain.views.errors import ErrorView
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from plain.http import HttpRequest, Response
+    from plain.http import Request, Response
 
 
 def convert_exception_to_response(
-    get_response: Callable[[HttpRequest], Response],
-) -> Callable[[HttpRequest], Response]:
+    get_response: Callable[[Request], Response],
+) -> Callable[[Request], Response]:
     """
     Wrap the given get_response callable in exception-to-response conversion.
 
@@ -43,7 +43,7 @@ def convert_exception_to_response(
     """
 
     @wraps(get_response)
-    def inner(request: HttpRequest) -> Response:
+    def inner(request: Request) -> Response:
         try:
             response = get_response(request)
         except Exception as exc:
@@ -53,7 +53,7 @@ def convert_exception_to_response(
     return inner
 
 
-def response_for_exception(request: HttpRequest, exc: Exception) -> Response:
+def response_for_exception(request: Request, exc: Exception) -> Response:
     if isinstance(exc, Http404):
         response = get_exception_response(
             request=request, status_code=404, exception=None
@@ -131,7 +131,7 @@ def response_for_exception(request: HttpRequest, exc: Exception) -> Response:
 
 
 def get_exception_response(
-    *, request: HttpRequest, status_code: int, exception: Exception | None
+    *, request: Request, status_code: int, exception: Exception | None
 ) -> Response:
     try:
         view_class = get_error_view(status_code=status_code, exception=exception)
@@ -149,7 +149,7 @@ def get_exception_response(
 
 def get_error_view(
     *, status_code: int, exception: Exception | None
-) -> Callable[[HttpRequest], Response]:
+) -> Callable[[Request], Response]:
     views_by_status = settings.HTTP_ERROR_VIEWS
     if status_code in views_by_status:
         view = views_by_status[status_code]

{plain-0.70.0 → plain-0.71.0}/plain/internal/handlers/wsgi.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 from urllib.parse import quote
 
 from plain import signals
-from plain.http import HttpRequest, QueryDict, parse_cookie
+from plain.http import QueryDict, Request, parse_cookie
 from plain.internal.handlers import base
 from plain.utils.datastructures import MultiValueDict
 from plain.utils.regex_helper import _lazy_re_compile
@@ -60,8 +60,8 @@ class LimitedStream(IOBase):
         return line
 
 
-class WSGIRequest(HttpRequest):
-    non_picklable_attrs = HttpRequest.non_picklable_attrs | frozenset(["environ"])
+class WSGIRequest(Request):
+    non_picklable_attrs = Request.non_picklable_attrs | frozenset(["environ"])
     meta_non_picklable_attrs = frozenset(["wsgi.errors", "wsgi.input"])
 
     def __init__(self, environ: dict[str, Any]) -> None:

{plain-0.70.0 → plain-0.71.0}/plain/internal/middleware/headers.py

@@ -7,14 +7,14 @@ from plain.runtime import settings
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from plain.http import HttpRequest, Response
+    from plain.http import Request, Response
 
 
 class DefaultHeadersMiddleware:
-    def __init__(self, get_response: Callable[[HttpRequest], Response]) -> None:
+    def __init__(self, get_response: Callable[[Request], Response]) -> None:
         self.get_response = get_response
 
-    def __call__(self, request: HttpRequest) -> Response:
+    def __call__(self, request: Request) -> Response:
         response = self.get_response(request)
 
         for header, value in settings.DEFAULT_RESPONSE_HEADERS.items():

{plain-0.70.0 → plain-0.71.0}/plain/internal/middleware/hosts.py

@@ -4,7 +4,7 @@ import ipaddress
 import logging
 from typing import TYPE_CHECKING
 
-from plain.http import HttpRequest, ResponseBadRequest
+from plain.http import Request, ResponseBadRequest
 from plain.runtime import settings
 from plain.utils.regex_helper import _lazy_re_compile
 
@@ -29,10 +29,10 @@ class HostValidationMiddleware:
     host is not allowed.
     """
 
-    def __init__(self, get_response: Callable[[HttpRequest], Response]) -> None:
+    def __init__(self, get_response: Callable[[Request], Response]) -> None:
         self.get_response = get_response
 
-    def __call__(self, request: HttpRequest) -> Response:
+    def __call__(self, request: Request) -> Response:
         if not is_host_valid(request):
             host = request.host
             msg = f"Invalid HTTP_HOST header: {host!r}."
@@ -55,7 +55,7 @@ class HostValidationMiddleware:
         return self.get_response(request)
 
 
-def is_host_valid(request: HttpRequest) -> bool:
+def is_host_valid(request: Request) -> bool:
     """
     Check if the host is valid according to ALLOWED_HOSTS settings.
     """

{plain-0.70.0 → plain-0.71.0}/plain/internal/middleware/https.py

@@ -8,17 +8,17 @@ from plain.runtime import settings
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from plain.http import HttpRequest, Response
+    from plain.http import Request, Response
 
 
 class HttpsRedirectMiddleware:
-    def __init__(self, get_response: Callable[[HttpRequest], Response]) -> None:
+    def __init__(self, get_response: Callable[[Request], Response]) -> None:
         self.get_response = get_response
 
         # Settings for HTTPS
         self.https_redirect_enabled = settings.HTTPS_REDIRECT_ENABLED
 
-    def __call__(self, request: HttpRequest) -> Response:
+    def __call__(self, request: Request) -> Response:
         """
         Perform a blanket HTTP→HTTPS redirect when enabled.
         """
@@ -28,7 +28,7 @@ class HttpsRedirectMiddleware:
 
         return self.get_response(request)
 
-    def maybe_https_redirect(self, request: HttpRequest) -> Response | None:
+    def maybe_https_redirect(self, request: Request) -> Response | None:
         if self.https_redirect_enabled and not request.is_https():
             return ResponseRedirect(
                 f"https://{request.host}{request.get_full_path()}", status_code=301

{plain-0.70.0 → plain-0.71.0}/plain/internal/middleware/slash.py

@@ -10,15 +10,15 @@ from plain.utils.http import escape_leading_slashes
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from plain.http import HttpRequest, Response
+    from plain.http import Request, Response
     from plain.urls import ResolverMatch
 
 
 class RedirectSlashMiddleware:
-    def __init__(self, get_response: Callable[[HttpRequest], Response]) -> None:
+    def __init__(self, get_response: Callable[[Request], Response]) -> None:
         self.get_response = get_response
 
-    def __call__(self, request: HttpRequest) -> Response:
+    def __call__(self, request: Request) -> Response:
         """
         Rewrite the URL based on settings.APPEND_SLASH
         """
@@ -50,7 +50,7 @@ class RedirectSlashMiddleware:
         except Resolver404:
             return False
 
-    def should_redirect_with_slash(self, request: HttpRequest) -> ResolverMatch | bool:
+    def should_redirect_with_slash(self, request: Request) -> ResolverMatch | bool:
         """
         Return True if settings.APPEND_SLASH is True and appending a slash to
         the request path turns an invalid path into a valid one.
@@ -60,7 +60,7 @@ class RedirectSlashMiddleware:
                 return self._is_valid_path(f"{request.path_info}/")
         return False
 
-    def get_full_path_with_slash(self, request: HttpRequest) -> str:
+    def get_full_path_with_slash(self, request: Request) -> str:
         """
         Return the full path of the request with a trailing slash appended.
 

{plain-0.70.0 → plain-0.71.0}/plain/logs/utils.py

@@ -4,7 +4,7 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from plain.http.request import HttpRequest
+    from plain.http.request import Request
     from plain.http.response import ResponseBase
 
 request_logger = logging.getLogger("plain.request")
@@ -14,7 +14,7 @@ def log_response(
     message: str,
     *args: Any,
     response: ResponseBase | None = None,
-    request: HttpRequest | None = None,
+    request: Request | None = None,
     logger: logging.Logger = request_logger,
     level: str | None = None,
     exception: BaseException | None = None,

{plain-0.70.0 → plain-0.71.0}/plain/runtime/__init__.py

@@ -64,9 +64,9 @@ def setup() -> None:
         sys.path.insert(0, APP_PATH.parent.as_posix())
 
     configure_logging(
-        plain_log_level=settings.PLAIN_LOG_LEVEL,
-        app_log_level=settings.APP_LOG_LEVEL,
-        app_log_format=settings.APP_LOG_FORMAT,
+        plain_log_level=settings.FRAMEWORK_LOG_LEVEL,
+        app_log_level=settings.LOG_LEVEL,
+        app_log_format=settings.LOG_FORMAT,
     )
 
     packages_registry.populate(settings.INSTALLED_PACKAGES)

{plain-0.70.0 → plain-0.71.0}/plain/runtime/global_settings.py

@@ -3,8 +3,6 @@ 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
@@ -12,8 +10,8 @@ from .utils import get_app_info_from_pyproject
 DEBUG: bool = False
 
 name, version = get_app_info_from_pyproject()
-APP_NAME: str = name
-APP_VERSION: str = version
+NAME: str = name
+VERSION: str = version
 
 # List of strings representing installed packages.
 INSTALLED_PACKAGES: list[str] = []
@@ -135,11 +133,10 @@ CSRF_TRUSTED_ORIGINS: list[str] = []
 CSRF_EXEMPT_PATHS: list[str] = []
 
 # MARK: Logging
-# (Uses some custom env names in addition to PLAIN_ prefixed )
 
-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")
+FRAMEWORK_LOG_LEVEL: str = "INFO"
+LOG_LEVEL: str = "INFO"
+LOG_FORMAT: str = "keyvalue"
 
 # MARK: Assets
 

{plain-0.70.0 → plain-0.71.0}/plain/test/client.py

@@ -9,7 +9,7 @@ from io import BytesIO, IOBase
 from typing import TYPE_CHECKING, Any
 from urllib.parse import unquote_to_bytes, urljoin, urlparse, urlsplit
 
-from plain.http import HttpHeaders, QueryDict
+from plain.http import QueryDict, RequestHeaders
 from plain.internal import internalcode
 from plain.internal.handlers.base import BaseHandler
 from plain.internal.handlers.wsgi import WSGIRequest
@@ -174,7 +174,7 @@ class RequestFactory:
         self.cookies: SimpleCookie[str] = SimpleCookie()
         self.errors = BytesIO()
         if headers:
-            self.defaults.update(HttpHeaders.to_wsgi_names(headers))
+            self.defaults.update(RequestHeaders.to_wsgi_names(headers))
 
     def _base_environ(self, **request: Any) -> dict[str, Any]:
         """
@@ -417,7 +417,7 @@ class RequestFactory:
                 }
             )
         if headers:
-            extra.update(HttpHeaders.to_wsgi_names(headers))
+            extra.update(RequestHeaders.to_wsgi_names(headers))
         r.update(extra)
         # If QUERY_STRING is absent or empty, we want to extract it from the URL.
         if not r.get("QUERY_STRING"):