WhakerPy 2.2__py3-none-any.whl → 2.4__py3-none-any.whl

whakerpy/__init__.py

@@ -25,6 +25,6 @@ from .httpd import *
 from .messages import error
 from .webapp import *
 
-__version__ = "2.2"
+__version__ = "2.4"
 ___author__ = "Brigitte Bigi"
 __copyright__ = "Copyright (C) 2023-2026 Brigitte Bigi, CNRS, Laboratoire Parole et Langage, Aix-en-Provence, France"

whakerpy/htmlmaker/htmnodes/htmnode.py

@@ -224,6 +224,33 @@ class TagNode(BaseTagNode):
         """Remove all children of the node."""
         self._children.clear()
 
+    # -----------------------------------------------------------------------
+    # Convenient method to create and add a child node
+    # -----------------------------------------------------------------------
+
+    def element(self, tag: str = "div", ident=None, class_name=None, value=None) -> HTMLNode:
+        """Create an HTML node and append it as a direct child of this node.
+
+        Convenient method to create a node and add it to the children of this
+        node in a single call, for example self.element("p", value="Hello.").
+
+        :param tag: (str) HTML element name
+        :param ident: (str) Optional identifier of the created node
+        :param class_name: (str) Optional value of the class attribute
+        :param value: (str) Optional text content of the tag
+        :return: (HTMLNode) The created and appended node
+
+        """
+        attributes = dict()
+        if ident is not None:
+            attributes["id"] = str(ident)
+        if class_name is not None:
+            attributes["class"] = str(class_name)
+
+        node = HTMLNode(self.identifier, ident, tag, attributes=attributes, value=value)
+        self.append_child(node)
+        return node
+
     # -----------------------------------------------------------------------
     # HTML management: getters and setters
     # -----------------------------------------------------------------------
@@ -284,7 +311,7 @@ class TagNode(BaseTagNode):
         html = ""
         try:
             # For some tags, the space char is meaningful. textarea is one of them. others???
-            if self.tag != "textarea":
+            if self.tag not in ("textarea", "pre"):
                 html += indent + " " * nbs
             html += self._value
             html += "\n"

whakerpy/httpd/handler.py

@@ -218,6 +218,14 @@ class HTTPDHandler(http.server.BaseHTTPRequestHandler):
             elif mime_type == "text/html":
                 events = HTTPDHandlerUtils.parse_query_string(query_string)
                 content, status = self._bakery(handler_utils, events, mime_type)
+                # A GET is a navigation, not a form submission: query
+                # parameters the recipe does not handle (status 205) must
+                # not prevent the page from being served. The baked content
+                # is complete: serve it with a 200.
+                if status.code == 205:
+                    logging.warning("Ignored unknown GET events {} for page {}"
+                                    "".format(events, self.path))
+                    status = HTTPDStatus(200)
 
             # Unknown mime type: try to get a static file anyway.
             else:

whakerpy/httpd/hutils.py

@@ -10,7 +10,7 @@
 ..
     -------------------------------------------------------------------------
 
-    Copyright (C) 2023-2024 Brigitte Bigi, CNRS
+    Copyright (C) 2023-2026 Brigitte Bigi, CNRS
     Laboratoire Parole et Langage, Aix-en-Provence, France
 
     This program is free software: you can redistribute it and/or modify
@@ -49,6 +49,12 @@ from .hstatus import HTTPDStatus
 from .permissions import UnixPermissions
 from .permissions import FileAccessChecker
 
+# The stdlib "mimetypes" default type for ".js" changed across Python
+# versions (RFC 9239 moved it from "application/javascript" to
+# "text/javascript"). Pin it explicitly so the mime type returned by
+# get_mime_type() is identical on every supported Python version.
+mimetypes.add_type("text/javascript", ".js")
+
 # -----------------------------------------------------------------------
 
 

whakerpy/httpd/permissions.py

@@ -203,21 +203,22 @@ class FileAccessChecker:
     def __check_permission_for_role(self, role: str) -> bool:
         """Helper function to check permissions for a single role.
 
+        The permission of a role is given by the mode bits of the file
+        only: the role does not have to match the effective uid/gid of
+        the current process. It answers "is the file readable by this
+        role", not "can the current process read it as this role" --
+        otherwise no file can be served from a mount owning the files
+        to a foreign user, like a FUSE/NTFS partition.
+
         :param role: (str) Who to check permissions for: 'others', 'group', or 'owner'.
 
         """
-        current_uid = os.geteuid()  # Effective user ID of the current process
-        current_gid = os.getegid()  # Effective group ID of the current process
-
-        # Check owner, group, and others' permissions
         mode = self.__file_stat.st_mode
-        owner_uid = self.__file_stat.st_uid
-        group_gid = self.__file_stat.st_gid
 
         # Determine read permission based on the role
-        if role == "owner" and current_uid == owner_uid:
+        if role == "owner":
             return bool(mode & stat.S_IRUSR)  # Owner read permission
-        elif role == "group" and current_gid == group_gid:
+        elif role == "group":
             return bool(mode & stat.S_IRGRP)  # Group read permission
         elif role == "others":
             return bool(mode & stat.S_IROTH)  # Others' read permission

whakerpy/webapp/webconfig.py

@@ -8,7 +8,7 @@
 ..
     -------------------------------------------------------------------------
 
-    Copyright (C) 2023-2025 Brigitte Bigi
+    Copyright (C) 2023-2026 Brigitte Bigi
     Laboratoire Parole et Langage, Aix-en-Provence, France
 
     This program is free software: you can redistribute it and/or modify
@@ -270,8 +270,8 @@ class WebSiteData:
     def __get_json_whakerpy_section(filename: str):
         """Return the configuration section related to WhakerPy.
 
-        - Look for a top‐level "WhakerPy" key (new format).
-        - Otherwise use the full JSON (old format) and issue a deprecation warning.
+        Requires a top-level "WhakerPy" key, introduced in WhakerPy 1.2.
+        Configuration files predating this key are not supported.
 
         :param filename: path to JSON configuration file
         :return: dict with keys "pagespath", "<page>.html", …

whakerpy/webapp/webwsgi.py

@@ -60,6 +60,7 @@ key/values:
 
 import os
 import types
+import logging
 
 from ..httpd import HTTPDStatus
 from ..httpd import HTTPDHandlerUtils
@@ -238,6 +239,14 @@ class WSGIApplication(object):
         else:
             # Process dynamic content. Events are empty if POST request.
             events, accept = handler_utils.process_post(environ['wsgi.input'])
+
+            # A GET carries its data in the query string, the very same way a
+            # POST carries it in its body -- e.g. for a plain HTML form using
+            # method="get" (see do_GET() of the httpd request handler).
+            is_get = environ.get("REQUEST_METHOD", "GET").upper() == "GET"
+            if is_get is True:
+                events = HTTPDHandlerUtils.parse_query_string(environ.get("QUERY_STRING", ""))
+
             has_to_return_data = HTTPDHandlerUtils.has_to_return_data(accept)
             content, status = HTTPDHandlerUtils.bakery(
                 self._pages,
@@ -246,6 +255,16 @@ class WSGIApplication(object):
                 events,
                 has_to_return_data
             )
+
+            # A GET is a navigation, not a form submission: query parameters
+            # the recipe does not handle (status 205) must not prevent the
+            # page from being served. The baked content is complete: serve
+            # it with a 200.
+            if is_get is True and status.code == 205:
+                logging.warning("Ignored unknown GET events {} for page {}"
+                                "".format(events, page_name))
+                status = HTTPDStatus(200)
+
             if has_to_return_data is False:
                 content = self.__policy.finalize_html(content)
         return content, status

{whakerpy-2.2.dist-info → whakerpy-2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: WhakerPy
-Version: 2.2
+Version: 2.4
 Summary: Web HTML maker in Python - a light web application framework
 Author-email: Brigitte Bigi <contact@sppas.org>
 Project-URL: Repo, https://github.com/brigitte-bigi/WhakerPy
@@ -53,47 +53,86 @@ Dynamic: license-file
 
 ### Uses cases
 
-You want all users to get access to dynamic web pages via web browser. You then need to create a web application allowing creating HTML pages and communicating via HTTPD.
-WhakerPy is a Python library of such a tool.
+You want your users to reach dynamic web pages from a browser, without adopting a full templating stack. WhakerPy is a Python library to build and serve that content.
 
-In fact, you may have already heard of Django — high-level, full-stack framework, and Flash — a micro-framework. Both of them generate output in the form of content from the model presented and formatted based on a template file.
-The WhakerPy library does not offer views, templates or models! 
-On the contrary, **WhakerPy offers a 100% pure-Python solution** by creating HTML pages entirely dynamically, or with a static content. 
+Django and Flask both render a template file against a model. WhakerPy has no views, no templates and no models: a page is an HTML tree, built and serialized directly in Python.
 
 WhakerPy is your solution if:
-- you're looking to design a relatively simple web app with a few static pages; 
-- and/or you want a full control on dynamic HTML creation content;
-- **you want to build a web app with nothing but Python**.
+
+- you want a relatively simple web app with a few static or semi-dynamic pages;
+- you want full, programmatic control over the generated HTML, without a template language to learn;
+- **you want to build and secure a web app with nothing but Python and its standard library**.
 
 
 ### Features
 
-WhakerPy is a Python, free, open source, self-hosted library to create dynamic HTML content and web applications. It offers more flexibility than a framework: it's a library!
-WhakerPy is then a collection of packages and modules that help developers to create static or dynamic web content without having to worry about the details involved. 
+WhakerPy is a free, open-source, self-hosted Python library — not a framework — to build dynamic HTML content and web applications. It stays out of the way: no views, no templates, no models, no third-party dependency for the core library.
 
-* Build powerful web apps with all the flexibility of Python: building a web app with WhakerPy is as simple as coding with Python 
-* Create HTML pages dynamically: create a tree with nodes and serialize the tree into a string
-* Can save as static HTML files
-* Create a web-frontend with its HTTPD response "bakery" system
-* Run locally with its HTTPD server
-* Run locally or remotely with its WSGI application
+* Build an HTML page as a tree of Python objects (`HTMLTree`, `HTMLNode`), then serialize it to a string or to a static file
+* Serve pages dynamically with a "bakery" response system that re-renders only what changed
+* Deploy the same application three ways, unchanged: as static files, behind the built-in HTTPD dev server, or behind a production WSGI server (Apache, nginx, gunicorn, ...)
+* Parse GET query strings, POST bodies (JSON, url-encoded forms) and multipart file uploads yourself — hand-written against the standard library, no `python-multipart`, and no dependency on the `cgi` module removed from Python 3.13
+* Protect pages and endpoints with a built-in HTTP security policy, shared by the HTTPD server and the WSGI application:
+  - a configurable blacklist rejecting requests by URL path or User-Agent
+  - HMAC-SHA256 signed, time-limited URLs (tokens) to share ephemeral links without sessions, cookies or server-side storage — no `itsdangerous`, no `PyJWT`
+* Serve static files only after checking Unix read permissions (owner/group/others), so a misconfigured file is never served by accident
 
 
 ### Main advantages
 
->Creating and manipulating HTML from the power of Python!
+>Build, secure and serve dynamic HTML web applications with nothing but the power of Python!
+
+* easy to learn: one consistent, explicit syntax, from the HTML tag tree to the HTTP response
+* a single dependency-free package: HTML generation, HTTPD/WSGI serving, security policy and upload parsing all ship in the Python Standard Library only
+* open-source and easily customizable: pure-Python, Object-Oriented, no compiled extension
+* portable: runs anywhere Python runs, from a local script to a production WSGI deployment
+
+
+## How it works
+
+WhakerPy is not Flask, not Django, and does not try to be. There is no template engine and nothing to render: 
+a page **is** a tree of Python objects.
+
+### No templates — an HTML tree, in Python
+
+Flask and Django keep a page as a text file (Jinja2 / Django templates) with placeholders (`{% if %}`, `{% for %}`, `{{ variable }}`) filled from a context dictionary at render time. 
+That file is not Python: it has its own syntax, its own scoping rules, and its own way of drifting out of sync with the code that feeds it.
+
+WhakerPy has no such file. An `HTMLTree` is a tree of `HTMLNode` objects — `<head>`, `<body>` and every element inside are Python instances, built and traversed with ordinary Python: `if`, `for`, functions, classes. 
+To change what gets rendered, write Python; there is no second language to learn:
+
+```python
+>>> if user.is_admin:
+...     htree.body_main.append_child(HTMLNode(main_id, None, "p", value="Admin panel"))
+```
+
+That is the whole of "the WhakerPy templating language".
 
-* easy to learn, consistent, simple syntax
-* flexible and easy usage
-* open-source: easily add new features and functionalities 
-* easily customizable: it's a pure python library in Object-Oriented Programming
-* portable: can be hosted on any web server - as soon as python is available, or used locally
-* it is distributed as a single folder module and has no dependencies other than the Python Standard Library.
+### One page class, three ways to serve it
+
+A page is a subclass of `BaseResponseRecipe`. `create()` builds the parts of the tree that never change; `bake(events)` runs on every request, decides from the incoming `events` (query string or POST data) whether anything changed, and only rebuilds the dynamic part when it did — a static page is never re-serialized for nothing.
+
+The same recipe instances can then be exposed three ways, without touching the page code:
+
+- `tree.serialize_to_file(...)` — dumped once to a static `.html` file;
+- `BaseHTTPDServer` / `HTTPDHandler` — the stdlib `http.server`, for local development or a small deployment with zero extra process;
+- `WSGIApplication` — the same recipes, the same bakery, behind any production WSGI server (Apache, nginx + gunicorn/uWSGI, ...).
+
+### Security is a policy, not a decorator
+
+`HTTPDPolicy` sits in front of both servers and is configured once: a blacklist of paths/User-Agents, and a set of HMAC-signed, time-limited URLs. 
+It applies identically whether a request comes through the dev HTTPD server or through WSGI in production — one place to configure it, not one per route.
+
+### Minimalism as a security stance
+
+WhakerPy is deliberately small: code that is not written cannot be exploited. The handlers only emit the status codes their own logic actually needs — 200 (OK), 205 (Reset Content, an unhandled GET is still served), 403 (Forbidden), 404 (Not Found, including an expired signed URL), 410 (Gone, shuts the server down), 418 (I'm a Teapot, a blacklisted request), 500 (Internal Server Error) — which covers the large majority of real needs, instead of a generic status-code framework bolted onto every route.
+
+`HTTPDStatus` still validates against the full IANA status registry, so any `BaseResponseRecipe` is free to return whichever code its page actually needs. If the built-in handlers should react to more of them, that is what contributions are for.
 
 
 ## Get and install WhakerPy
 
-Get it from its repository <https://sourceforge.net/projects/whakerpy/> or from Pypi <https://pypi.org/project/whakerpy/>, and get documentation <https://whakerpy.sourceforge.io>.
+Get it from its repository <https://github.com/brigitte-bigi/WhakerPy> or from Pypi <https://pypi.org/project/whakerpy/>, and get documentation <https://whakerpy.sourceforge.io>.
 
 ### Install from pypi.org:
 
@@ -119,8 +158,8 @@ Download the latest ".zip" from it's web page and unpack it, or clone the reposi
 4. "sample": a web application sample 
 
 ```bash
-> unzip WhakerPy-1.1.zip 
-> git clone https://git.code.sf.net/p/whakerpy/code whakerpy-code
+> unzip WhakerPy-2.2.zip 
+> git clone https://github.com/brigitte-bigi/WhakerPy.git whakerpy-code
 > python -m pip install .
 ```
 
@@ -197,23 +236,15 @@ created from a custom `BaseResponseRecipe()` object, available in the file
 `sample/response.py`. The response is the interface between a local back-end 
 python application and the web front-end.
 
-For a more complex example of an already in-used application web frontend, see: 
-<https://sourceforge.net/p/sppas/code/ci/master/tree/sppas/ui/swapp/app_setup/setupmaker.py>.
-
 
 ## Projects using WhakerPy
 
-WhakerPy was initially developed within SPPAS <https://sppas.org>. 
-It was extracted from its original software by the author to lead its own life as standalone package. 
-The "setup" of SPPAS is entirely based on `whakerpy` API.
-
-Other projects: 
-
 - the website <https://auto-cuedspeech.org>
 - the website <https://sppas.org>
-- the web appis of SPPAS
+- the SPPAS graphical user interface
 - the intranet of the Laboratoire Parole et Langage
-- *contact the author if your project is based on WhakerPy*
+- *contact the author if your project is based on WhakerPy* and you want it to be included in this list.
+
 
 
 # The developer's corner
@@ -313,4 +344,4 @@ or products, in accordance with the best practices of the AGPL license.
 Use the following reference to cite WhakerPy:
 
 > Brigitte Bigi. WhakerPy, a Python library to create dynamic HTML content and
-> web applications. Version 1.x. 202x. <https://hal.science/hal-04743687>
+> web applications. Version 2.2. 2026. <https://hal.science/hal-04743687>

{whakerpy-2.2.dist-info → whakerpy-2.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
 sample/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sample/response.py,sha256=_jAaWLrHuGBYy0Y0aywxGrSDX365MSfASqWTISIotqw,12532
-whakerpy/__init__.py,sha256=DA3YMbr2kjiqkDY-v5PFzQu-OWWw3PAUtzgSkdXVJDQ,1827
+whakerpy/__init__.py,sha256=5YZutVN8zQxpO9NNL-lL2TGUkaBv3dH70yZpOWoVz80,1827
 whakerpy/messages.py,sha256=NSnQYFfarU16T59Zryuy2g2x7UwA8xgY_UDwRLQqPm4,2385
 whakerpy/htmlmaker/__init__.py,sha256=zCHYhW37cyK68u90w2tFBLJx59ApGvqgNkxiIzuVtTM,3333
 whakerpy/htmlmaker/hconsts.py,sha256=6I0Mmp72ZBzePGw-nH4qjD7TvENxXUPAT-qTeljwGe8,12115
@@ -16,25 +16,25 @@ whakerpy/htmlmaker/emptynodes/emptyelts.py,sha256=wqCtFMZU_bTCP4Z63Q3Pgwo1pNC1tM
 whakerpy/htmlmaker/emptynodes/emptynode.py,sha256=caUy9V7CG-G_lgVwBAjMNKEdVeI8FBkTT28aREuuyXA,9920
 whakerpy/htmlmaker/htmnodes/__init__.py,sha256=hOrs9nhL2aMCvukuPoOxRdinPAK_QFpWBpmTnp-iTQ8,1547
 whakerpy/htmlmaker/htmnodes/htmelts.py,sha256=CTLX6hQWpulJuwW5F75gLTbKiiERkAkRLZ0LiHz9_lE,5398
-whakerpy/htmlmaker/htmnodes/htmnode.py,sha256=gM3c-9dj9kBO_8JGHOqca1ZDIOWdEgNy1_BIwcUtDqI,11603
+whakerpy/htmlmaker/htmnodes/htmnode.py,sha256=XpFspvlC5uFOPa723txR72OOZRPTGUFWVIPm0QjFIvw,12827
 whakerpy/httpd/__init__.py,sha256=A4_Y6oN-8PY3TmGssX6DGKlUsE0wAGsNc5N1oo8HDK8,2031
-whakerpy/httpd/handler.py,sha256=EecczKlv8HMTWthJgXJLRLGlgTELnYnUmoTa1LkGR14,11007
+whakerpy/httpd/handler.py,sha256=7hZc2rMALqRK2qKI1hYeN6FrrhBNDVcil5hjNdCpO4I,11518
 whakerpy/httpd/hblacklist.py,sha256=H9-hhLGx9StYGo7ThBs23dVuqNRTveGvkt_SftH_oIc,6605
 whakerpy/httpd/hpolicy.py,sha256=LZBY3eSz9xrpPUlV-ymQxdx34LN33acX9SBsqaNVrm0,9827
 whakerpy/httpd/hresponse.py,sha256=bjv-PS0xQ3RR7z9XvzOptxWkSdmlutRuFWqgdUqmDVI,9412
 whakerpy/httpd/hserver.py,sha256=1X8lGKIZNBFyoNHcLHtQPkOkEORvZ19HLGahOeE8uiY,6302
 whakerpy/httpd/hsignedurl.py,sha256=ZLGENB3-Y1jOANaMP0E71s3xqFmdbBb8hgJf7IODG1g,13295
 whakerpy/httpd/hstatus.py,sha256=rrWDvPXTyAh8l4IJY0xBDkZxeKC7t3_5-XlVHtUDSo8,7998
-whakerpy/httpd/hutils.py,sha256=C7gkMka-dEpK_Bt6RhCSDdrSjZO1sgZkuAMIWTPSZSk,28631
-whakerpy/httpd/permissions.py,sha256=PNl2XQwYtpJVzXaPgWVT-2TqnN8jsr-b6ZhZasFbono,8463
+whakerpy/httpd/hutils.py,sha256=OaEpCm54PfY8jNQePszKFUoSh8Kr_3iUkAWIEZ687hc,28951
+whakerpy/httpd/permissions.py,sha256=KUpLR_qB_mjCzrg3xcCIgErSxD9OJQl72HTaqiOJeyw,8511
 whakerpy/webapp/__init__.py,sha256=FCeq1HYEqFhGyquWajWVhWJbAsOYihBedtdUwpnQvis,276
-whakerpy/webapp/webconfig.py,sha256=8JAWncQip-uAeLQaIWzcmZIczRWlaKRbR5ZJAdEPoWs,11222
+whakerpy/webapp/webconfig.py,sha256=LmGUrfZ3btFSY3DoMpme2UXgiyHl48VlpnSXUyMk3MM,11215
 whakerpy/webapp/weblocalserver.py,sha256=XjtVkUQPeFsVvX4ARLc_2_9eqc2KBmuQHMlxbr7DMUE,3180
 whakerpy/webapp/webresponse.py,sha256=q4p12QHRFmq52K0lLkdqPJfexkG2SqZLluYF7Zg406g,4430
-whakerpy/webapp/webwsgi.py,sha256=wmdN5MemNqFqrOhQVlpvp0-XSCGGdQ3SF8H4_qJMNG4,11554
-whakerpy-2.2.dist-info/licenses/AUTHORS.md,sha256=VrCusdQ56bvNDiq7w_MA5mZoZXuP_JOG-ybTwpRT_u4,805
-whakerpy-2.2.dist-info/licenses/LICENSE.md,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-whakerpy-2.2.dist-info/METADATA,sha256=9UQr1f52WX1jijHmnoYZ9HNca3CVU9OPA74smalza_I,12055
-whakerpy-2.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-whakerpy-2.2.dist-info/top_level.txt,sha256=ZqGTnE-rI2S_jcI0kxnNeKd0z25TBv8Vkbe2iJ74-E0,16
-whakerpy-2.2.dist-info/RECORD,,
+whakerpy/webapp/webwsgi.py,sha256=6gmF9JxGn6pu3jYrJGGEnQG1msM3oi9q3y3sKQJmk2U,12511
+whakerpy-2.4.dist-info/licenses/AUTHORS.md,sha256=VrCusdQ56bvNDiq7w_MA5mZoZXuP_JOG-ybTwpRT_u4,805
+whakerpy-2.4.dist-info/licenses/LICENSE.md,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+whakerpy-2.4.dist-info/METADATA,sha256=oEM8cZQGhSD4gWNLBCvvwmWMGcc31Kf0bekFYVH20q4,15095
+whakerpy-2.4.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+whakerpy-2.4.dist-info/top_level.txt,sha256=ZqGTnE-rI2S_jcI0kxnNeKd0z25TBv8Vkbe2iJ74-E0,16
+whakerpy-2.4.dist-info/RECORD,,