WuttaWeb 0.25.0__tar.gz → 0.25.1__tar.gz

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to wuttaweb will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## v0.25.1 (2025-12-20)
+
+### Fix
+
+- add `WebDiff` class now that `Diff` lives in wuttjamaican
+- expose fallback key for email settings
+- expose transaction comment for version history
+- show display text for related objects, in version diff
+- discard non-declared field values for grid vue data
+- prevent error in DateTime schema type if no widget/request set
+
 ## v0.25.0 (2025-12-17)
 
 ### Feat

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: WuttaWeb
-Version: 0.25.0
+Version: 0.25.1
 Summary: Web App for Wutta Framework
 Project-URL: Homepage, https://wuttaproject.org/
 Project-URL: Repository, https://forgejo.wuttaproject.org/wutta/wuttaweb
@@ -39,10 +39,10 @@ Requires-Dist: pyramid-tm
 Requires-Dist: pyramid>=2
 Requires-Dist: waitress
 Requires-Dist: webhelpers2
-Requires-Dist: wuttjamaican[db]>=0.26.0
+Requires-Dist: wuttjamaican[db]>=0.27.0
 Requires-Dist: zope-sqlalchemy>=1.5
 Provides-Extra: continuum
-Requires-Dist: wutta-continuum>=0.2.2; extra == 'continuum'
+Requires-Dist: wutta-continuum>=0.3.0; extra == 'continuum'
 Provides-Extra: docs
 Requires-Dist: furo; extra == 'docs'
 Requires-Dist: sphinx; extra == 'docs'

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "WuttaWeb"
-version = "0.25.0"
+version = "0.25.1"
 description = "Web App for Wutta Framework"
 readme = "README.md"
 authors = [{name = "Lance Edgar", email = "lance@wuttaproject.org"}]
@@ -44,13 +44,13 @@ dependencies = [
         "pyramid_tm",
         "waitress",
         "WebHelpers2",
-        "WuttJamaican[db]>=0.26.0",
+        "WuttJamaican[db]>=0.27.0",
         "zope.sqlalchemy>=1.5",
 ]
 
 
 [project.optional-dependencies]
-continuum = ["Wutta-Continuum>=0.2.2"]
+continuum = ["Wutta-Continuum>=0.3.0"]
 docs = ["Sphinx", "furo", "sphinxcontrib-programoutput"]
 tests = ["pylint", "pytest", "pytest-cov", "tox"]
 

wuttaweb-0.25.1/src/wuttaweb/diffs.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8; -*-
+################################################################################
+#
+#  wuttaweb -- Web App for Wutta Framework
+#  Copyright © 2024-2025 Lance Edgar
+#
+#  This file is part of Wutta Framework.
+#
+#  Wutta Framework is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License as published by the Free
+#  Software Foundation, either version 3 of the License, or (at your option) any
+#  later version.
+#
+#  Wutta Framework is distributed in the hope that it will be useful, but
+#  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+#  more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  Wutta Framework.  If not, see <http://www.gnu.org/licenses/>.
+#
+################################################################################
+"""
+Tools for displaying simple data diffs
+"""
+
+import sqlalchemy as sa
+
+from pyramid.renderers import render
+from webhelpers2.html import HTML
+
+from wuttjamaican.diffs import Diff
+
+
+class WebDiff(Diff):
+    """
+    Simple diff class for the web app.
+
+    This is based on the
+    :class:`~wuttjamaican:wuttjamaican.diffs.Diff` class; it just
+    tweaks :meth:`render_html()` to use the web template lookup
+    engine.
+    """
+
+    cell_padding = None
+
+    def render_html(self, template="/diff.mako", **kwargs):
+        """
+        Render the diff as HTML table.
+
+        :param template: Name of template to render, if you need to
+           override the default.
+
+        :param \\**kwargs: Remaining kwargs are passed as context to
+           the template renderer.
+
+        :returns: HTML literal string
+        """
+        context = kwargs
+        context["diff"] = self
+        html = render(template, context)
+        return HTML.literal(html)
+
+
+class VersionDiff(WebDiff):
+    """
+    Special diff class for use with version history views.  While
+    based on :class:`WebDiff`, this class uses a different signature
+    for the constructor.
+
+    :param config: The app :term:`config object`.
+
+    :param version: Reference to a Continuum version record object.
+
+    :param \\**kwargs: Remaining kwargs are passed as-is to the
+       :class:`WebDiff` constructor.
+    """
+
+    def __init__(self, config, version, **kwargs):
+        import sqlalchemy_continuum as continuum  # pylint: disable=import-outside-toplevel
+        from wutta_continuum.util import (  # pylint: disable=import-outside-toplevel
+            render_operation_type,
+        )
+
+        self.version = version
+        self.model_class = continuum.parent_class(type(self.version))
+        self.mapper = sa.inspect(self.model_class)
+        self.version_mapper = sa.inspect(type(self.version))
+        self.title = kwargs.pop("title", self.model_class.__name__)
+
+        self.operation_title = render_operation_type(self.version.operation_type)
+
+        if "nature" not in kwargs:
+            if (
+                version.previous
+                and version.operation_type == continuum.Operation.DELETE
+            ):
+                kwargs["nature"] = "delete"
+            elif version.previous:
+                kwargs["nature"] = "update"
+            else:
+                kwargs["nature"] = "create"
+
+        if "fields" not in kwargs:
+            kwargs["fields"] = self.get_default_fields()
+
+        old_data = {}
+        new_data = {}
+        for field in kwargs["fields"]:
+            if version.previous:
+                old_data[field] = getattr(version.previous, field)
+            new_data[field] = getattr(version, field)
+
+        super().__init__(config, old_data, new_data, **kwargs)
+
+    def get_default_fields(self):  # pylint: disable=missing-function-docstring
+        fields = sorted(self.version_mapper.columns.keys())
+
+        unwanted = [
+            "transaction_id",
+            "end_transaction_id",
+            "operation_type",
+        ]
+
+        return [field for field in fields if field not in unwanted]
+
+    def render_version_value(self, version, field, value):
+        """
+        Render the cell value HTML for a given version + field.
+
+        This method is used to render both sides of the diff (old +
+        new values).  It will just render the field value using a
+        monospace font by default.  However:
+
+        If the field is involved in a mapper relationship (i.e. it is
+        the "foreign key" to a related table), the logic here will
+        also (try to) traverse that show display text for the related
+        object (if found).
+
+        :param version: Reference to the Continuum version object.
+
+        :param field: Name of the field, as string.
+
+        :param value: Raw value for the field, as obtained from the
+           version object.
+
+        :returns: Rendered cell value as HTML literal
+        """
+        # first render normal span; this is our fallback but also may
+        # be embedded within a more complex result.
+        text = HTML.tag("span", c=[repr(value)], style="font-family: monospace;")
+
+        # loop thru all mapped relationship props
+        for prop in self.mapper.relationships:
+
+            # we only want singletons
+            if prop.uselist:
+                continue
+
+            # loop thru columns for prop
+            # nb. there should always be just one colum for a
+            # singleton prop, but technically a list is used, so no
+            # harm in looping i assume..
+            for col in prop.local_columns:
+
+                # we only want the matching column
+                if col.name != field:
+                    continue
+
+                # grab "related version" reference via prop key.  this
+                # would be like a UserVersion for instance.
+                if ref := getattr(version, prop.key):
+
+                    # grab "related object" reference.  this would be
+                    # like a User for instance.
+                    if ref := getattr(ref, "version_parent", None):
+
+                        # render text w/ related object as bold string
+                        style = (
+                            "margin-left: 2rem; font-style: italic; font-weight: bold;"
+                        )
+                        return HTML.tag(
+                            "span",
+                            c=[text, HTML.tag("span", c=[str(ref)], style=style)],
+                        )
+
+        return text
+
+    def render_old_value(self, field):
+        if self.nature == "create":
+            return ""
+        value = self.old_value(field)
+        return self.render_version_value(self.version.previous, field, value)
+
+    def render_new_value(self, field):
+        if self.nature == "delete":
+            return ""
+        value = self.new_value(field)
+        return self.render_version_value(self.version, field, value)

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/src/wuttaweb/forms/schema.py

@@ -31,6 +31,7 @@ import colander
 import sqlalchemy as sa
 
 from wuttjamaican.conf import parse_list
+from wuttjamaican.util import localtime
 
 from wuttaweb.db import Session
 from wuttaweb.forms import widgets
@@ -38,28 +39,38 @@ from wuttaweb.forms import widgets
 
 class WuttaDateTime(colander.DateTime):
     """
-    Custom schema type for ``datetime`` fields.
+    Custom schema type for :class:`~python:datetime.datetime` fields.
 
     This should be used automatically for
-    :class:`sqlalchemy:sqlalchemy.types.DateTime` columns unless you
-    register another default.
+    :class:`~sqlalchemy:sqlalchemy.types.DateTime` ORM columns unless
+    you register another default.
 
     This schema type exists for sake of convenience, when working with
     the Buefy datepicker + timepicker widgets.
+
+    It also follows the datetime handling "rules" as outlined in
+    :doc:`wuttjamaican:narr/datetime`.  On the Python side, values
+    should be naive/UTC datetime objects.  On the HTTP side, values
+    will be ISO-format strings representing aware/local time.
     """
 
     def serialize(self, node, appstruct):
         if not appstruct:
             return colander.null
 
-        request = node.widget.request
-        config = request.wutta_config
-        app = config.get_app()
+        # nb. request should be present when it matters
+        if node.widget and node.widget.request:
+            request = node.widget.request
+            config = request.wutta_config
+            app = config.get_app()
+            appstruct = app.localtime(appstruct)
+        else:
+            # but if not, fallback to config-less logic
+            appstruct = localtime(appstruct)
 
-        dt = app.localtime(appstruct)
         if self.format:
-            return dt.strftime(self.format)
-        return dt.isoformat()
+            return appstruct.strftime(self.format)
+        return appstruct.isoformat()
 
     def deserialize(  # pylint: disable=inconsistent-return-statements
         self, node, cstruct
@@ -72,6 +83,7 @@ class WuttaDateTime(colander.DateTime):
             "%Y-%m-%dT%I:%M %p",
         ]
 
+        # nb. request is always assumed to be present here
         request = node.widget.request
         config = request.wutta_config
         app = config.get_app()

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/src/wuttaweb/grids/base.py

@@ -2390,6 +2390,9 @@ class Grid:  # pylint: disable=too-many-instance-attributes,too-many-public-meth
             # convert record to new dict
             record = self.object_to_dict(record)
 
+            # discard non-declared fields
+            record = {field: record[field] for field in record if field in self.columns}
+
             # make all values safe for json
             record = make_json_safe(record, warn=False)
 

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/src/wuttaweb/templates/master/view_version.mako

@@ -24,6 +24,10 @@
       <span>${transaction.id}</span>
     </b-field>
 
+    <b-field label="Comment" horizontal>
+      <span>${transaction.meta.get("comment", "")}</span>
+    </b-field>
+
   </div>
 
   <div style="padding: 2rem;">

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/src/wuttaweb/views/email.py

@@ -63,6 +63,7 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
 
     form_fields = [
         "key",
+        "fallback_key",
         "description",
         "subject",
         "sender",
@@ -92,9 +93,11 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
     def normalize_setting(self, setting):  # pylint: disable=empty-docstring
         """ """
         key = setting.__name__
+        setting = setting(self.config)
         return {
             "key": key,
-            "description": setting.__doc__,
+            "fallback_key": setting.fallback_key or "",
+            "description": setting.get_description() or "",
             "subject": self.email_handler.get_auto_subject(
                 key, rendered=False, setting=setting
             ),
@@ -158,8 +161,12 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
         f = form
         super().configure_form(f)
 
+        # fallback_key
+        f.set_readonly("fallback_key")
+
         # description
         f.set_readonly("description")
+        f.set_widget("description", "notes")
 
         # replyto
         f.set_required("replyto", False)
@@ -247,11 +254,12 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
         if self.viewing:
             setting = context["instance"]
             context["setting"] = setting
+
             context["has_html_template"] = self.email_handler.get_auto_body_template(
-                setting["key"], "html"
+                setting["key"], "html", fallback_key=setting["fallback_key"]
             )
             context["has_txt_template"] = self.email_handler.get_auto_body_template(
-                setting["key"], "txt"
+                setting["key"], "txt", fallback_key=setting["fallback_key"]
             )
 
         return super().render_to_response(template, context)
@@ -269,11 +277,15 @@ class EmailSettingView(MasterView):  # pylint: disable=abstract-method
         mode = self.request.params.get("mode", "html")
 
         if mode == "txt":
-            body = self.email_handler.get_auto_txt_body(key, context)
+            body = self.email_handler.get_auto_txt_body(
+                key, context, fallback_key=setting.fallback_key
+            )
             self.request.response.content_type = "text/plain"
 
         else:  # html
-            body = self.email_handler.get_auto_html_body(key, context)
+            body = self.email_handler.get_auto_html_body(
+                key, context, fallback_key=setting.fallback_key
+            )
 
         self.request.response.text = body
         return self.request.response

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/src/wuttaweb/views/master.py

@@ -1145,6 +1145,7 @@ class MasterView(View):  # pylint: disable=too-many-public-methods
             "issued_at",
             "user",
             "remote_addr",
+            "comment",
         ]
 
     def get_version_grid_data(self, instance):
@@ -1197,6 +1198,14 @@ class MasterView(View):  # pylint: disable=too-many-public-methods
         # remote_addr
         g.set_label("remote_addr", "IP Address")
 
+        # comment
+        g.set_renderer("comment", self.render_version_comment)
+
+    def render_version_comment(  # pylint: disable=missing-function-docstring,unused-argument
+        self, txn, key, value
+    ):
+        return txn.meta.get("comment", "")
+
     def view_version(self):  # pylint: disable=too-many-locals
         """
         View to show diff details for a particular object version.
@@ -1260,7 +1269,7 @@ class MasterView(View):  # pylint: disable=too-many-public-methods
             )
 
         version_diffs = [
-            VersionDiff(version)
+            VersionDiff(self.config, version)
             for version in self.get_relevant_versions(txn, instance)
         ]
 

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/tests/forms/test_schema.py

@@ -62,6 +62,13 @@ class TestWuttaDateTime(WebTestCase):
             )
             self.assertEqual(result, "2024-12-11 02:33 PM")
 
+            # missing widget/request/config
+            typ = mod.WuttaDateTime()
+            node = colander.SchemaNode(typ)
+            result = typ.serialize(node, datetime.datetime(2024, 12, 11, 22, 33))
+            # nb. not possible to know which timezone is system-local
+            self.assertTrue(result.startswith("2024-12-"))
+
     def test_deserialize(self):
         tzlocal = get_timezone_by_name("America/Los_Angeles")
         with patch.object(self.app, "get_timezone", return_value=tzlocal):

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/tests/grids/test_base.py

@@ -1867,7 +1867,19 @@ class TestGrid(WebTestCase):
         context = grid.get_vue_context()
         self.assertEqual(context, {"data": [{"foo": "bar"}], "row_classes": {}})
 
+        # non-declared columns are discarded
+        mydata = [
+            {"foo": "a", "bar": "b", "baz": "c"},
+        ]
+        grid = self.make_grid(columns=["bar"], data=mydata)
+        context = grid.get_vue_context()
+        self.assertEqual(context, {"data": [{"bar": "b"}], "row_classes": {}})
+
         # if grid has actions, that list may be supplemented
+        mydata = [
+            {"foo": "bar"},
+        ]
+        grid = self.make_grid(columns=["foo"], data=mydata)
         grid.actions.append(mod.GridAction(self.request, "view", url="/blarg"))
         context = grid.get_vue_context()
         self.assertIsNot(context["data"], mydata)

wuttaweb-0.25.1/tests/test_diffs.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8; -*-
+
+from wuttaweb import diffs as mod
+from wuttaweb.testing import WebTestCase, VersionWebTestCase
+
+
+class TestWebDiff(WebTestCase):
+
+    def make_diff(self, *args, **kwargs):
+        return mod.WebDiff(self.config, *args, **kwargs)
+
+    def test_render_html(self):
+        old_data = {"foo": "bar"}
+        new_data = {"foo": "baz"}
+        diff = self.make_diff(old_data, new_data)
+        html = diff.render_html()
+        self.assertIn("<table", html)
+        self.assertIn("<tr>", html)
+        self.assertIn("&#39;bar&#39;", html)
+        self.assertIn(f'style="background-color: {diff.old_color}"', html)
+        self.assertIn("&#39;baz&#39;", html)
+        self.assertIn(f'style="background-color: {diff.new_color}"', html)
+        self.assertIn("</tr>", html)
+        self.assertIn("</table>", html)
+
+
+class TestVersionDiff(VersionWebTestCase):
+
+    def make_diff(self, *args, **kwargs):
+        return mod.VersionDiff(self.config, *args, **kwargs)
+
+    def test_constructor(self):
+        import sqlalchemy_continuum as continuum
+
+        model = self.app.model
+        user = model.User(username="fred")
+        self.session.add(user)
+        self.session.commit()
+        user.username = "freddie"
+        self.session.commit()
+        self.session.delete(user)
+        self.session.commit()
+
+        txncls = continuum.transaction_class(model.User)
+        vercls = continuum.version_class(model.User)
+        versions = self.session.query(vercls).order_by(vercls.transaction_id).all()
+        self.assertEqual(len(versions), 3)
+
+        version = versions[0]
+        diff = self.make_diff(version)
+        self.assertEqual(diff.nature, "create")
+        self.assertEqual(
+            diff.fields,
+            ["active", "person_uuid", "prevent_edit", "username", "uuid"],
+        )
+
+        version = versions[1]
+        diff = self.make_diff(version)
+        self.assertEqual(diff.nature, "update")
+        self.assertEqual(
+            diff.fields,
+            ["active", "person_uuid", "prevent_edit", "username", "uuid"],
+        )
+
+        version = versions[2]
+        diff = self.make_diff(version)
+        self.assertEqual(diff.nature, "delete")
+        self.assertEqual(
+            diff.fields,
+            ["active", "person_uuid", "prevent_edit", "username", "uuid"],
+        )
+
+    def test_render_version_value(self):
+        import sqlalchemy_continuum as continuum
+
+        model = self.app.model
+        person = model.Person(full_name="Fred Flintstone")
+        self.session.add(person)
+
+        # create, update, delete user
+        user = model.User(username="fred", person=person)
+        self.session.add(user)
+        self.session.commit()
+        user.username = "freddie"
+        self.session.commit()
+        self.session.delete(user)
+        self.session.commit()
+
+        txncls = continuum.transaction_class(model.User)
+        vercls = continuum.version_class(model.User)
+        versions = self.session.query(vercls).order_by(vercls.transaction_id).all()
+        self.assertEqual(len(versions), 3)
+
+        # create (1st version)
+        version = versions[0]
+        diff = self.make_diff(version)
+        self.assertEqual(diff.nature, "create")
+        self.assertEqual(diff.render_old_value("username"), "")
+        self.assertIn("fred", diff.render_new_value("username"))
+        self.assertNotIn("freddie", diff.render_new_value("username"))
+        self.assertEqual(diff.render_old_value("person_uuid"), "")
+        # rendered person_uuid includes display name
+        html = diff.render_new_value("person_uuid")
+        self.assertIn(str(person.uuid), html)
+        self.assertIn("Fred Flintstone", html)
+
+        # update (2nd version)
+        version = versions[1]
+        diff = self.make_diff(version)
+        self.assertEqual(diff.nature, "update")
+        self.assertIn("fred", diff.render_old_value("username"))
+        self.assertNotIn("freddie", diff.render_old_value("username"))
+        self.assertIn("freddie", diff.render_new_value("username"))
+        # rendered person_uuid includes display name
+        html = diff.render_old_value("person_uuid")
+        self.assertIn(str(person.uuid), html)
+        self.assertIn("Fred Flintstone", html)
+        html = diff.render_new_value("person_uuid")
+        self.assertIn(str(person.uuid), html)
+        self.assertIn("Fred Flintstone", html)
+
+        # delete (3rd version)
+        version = versions[2]
+        diff = self.make_diff(version)
+        self.assertEqual(diff.nature, "delete")
+        self.assertIn("freddie", diff.render_old_value("username"))
+        self.assertEqual(diff.render_new_value("username"), "")
+        # rendered person_uuid includes display name
+        html = diff.render_old_value("person_uuid")
+        self.assertIn(str(person.uuid), html)
+        self.assertIn("Fred Flintstone", html)
+        self.assertEqual(diff.render_new_value("person_uuid"), "")

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/tests/views/test_master.py

@@ -2115,7 +2115,7 @@ class TestVersionedMasterView(VersionWebTestCase):
             view = self.make_view()
             self.assertEqual(
                 view.get_version_grid_columns(),
-                ["id", "issued_at", "user", "remote_addr"],
+                ["id", "issued_at", "user", "remote_addr", "comment"],
             )
 
             # custom

{wuttaweb-0.25.0 → wuttaweb-0.25.1}/tests/views/test_settings.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8; -*-
 
+import sys
 from unittest.mock import patch
 
 import colander
@@ -57,9 +58,11 @@ class TestAppInfoView(WebTestCase):
         # invalid
         with patch.object(self.request, "GET", new={"tzname": "bad_name"}):
             result = view.configure_check_timezone()
-            self.assertEqual(
-                result["invalid"], "'No time zone found with key bad_name'"
-            )
+            # nb. this check won't work for python 3.8
+            if sys.version_info >= (3, 9):
+                self.assertEqual(
+                    result["invalid"], "'No time zone found with key bad_name'"
+                )
 
         # missing input
         with patch.object(self.request, "GET", new={}):