WuttaWeb 0.19.0__tar.gz → 0.19.2__tar.gz

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/CHANGELOG.md

@@ -5,6 +5,36 @@ 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.19.2 (2025-01-07)
+
+### Fix
+
+- always use prop key for default grid filters
+- avoid `request.current_route_url()` for user menu
+- add `scale` kwarg for `WuttaMoney` schema type, widget
+- make WuttaQuantity serialize w/ app handler, remove custom widget
+- bugfix for bool simple settings with default value
+
+## v0.19.1 (2025-01-06)
+
+### Fix
+
+- improve built-in grid renderer logic
+- allow session injection for ObjectRef constructor
+- improve rendering for batch row status
+- add basic support for row grid "view" action links
+- add "xref buttons" tool panel for master view
+- add WuttaQuantity schema type, widget
+- remove `session` param from some form schema, widget classes
+- add grid renderers for bool, currency, quantity
+- use proper bulma styles for markdown content
+- use span element for readonly money field widget render
+- include grid filters for all column properties of model class
+- use app handler to render error string, when progress fails
+- add schema node type, widget for "money" (currency) fields
+- exclude FK fields by default, for model forms
+- fix style for header title text
+
 ## v0.19.0 (2024-12-23)
 
 ### Feat

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/PKG-INFO

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

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "WuttaWeb"
-version = "0.19.0"
+version = "0.19.2"
 description = "Web App for Wutta Framework"
 readme = "README.md"
 authors = [{name = "Lance Edgar", email = "lance@wuttaproject.org"}]
@@ -44,7 +44,7 @@ dependencies = [
         "pyramid_tm",
         "waitress",
         "WebHelpers2",
-        "WuttJamaican[db]>=0.19.0",
+        "WuttJamaican[db]>=0.19.2",
         "zope.sqlalchemy>=1.5",
 ]
 

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/src/wuttaweb/forms/schema.py

@@ -155,25 +155,75 @@ class WuttaEnum(colander.Enum):
         return widgets.SelectWidget(**kwargs)
 
 
+class WuttaMoney(colander.Money):
+    """
+    Custom schema type for "money" fields.
+
+    This is a subclass of :class:`colander:colander.Money`, but uses
+    the custom :class:`~wuttaweb.forms.widgets.WuttaMoneyInputWidget`
+    by default.
+
+    :param request: Current :term:`request` object.
+
+    :param scale: If this kwarg is specified, it will be passed along
+       to the widget constructor.
+    """
+
+    def __init__(self, request, *args, **kwargs):
+        self.scale = kwargs.pop('scale', None)
+        super().__init__(*args, **kwargs)
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
+    def widget_maker(self, **kwargs):
+        """ """
+        if self.scale:
+            kwargs.setdefault('scale', self.scale)
+        return widgets.WuttaMoneyInputWidget(self.request, **kwargs)
+
+
+class WuttaQuantity(colander.Decimal):
+    """
+    Custom schema type for "quantity" fields.
+
+    This is a subclass of :class:`colander:colander.Decimal` but will
+    serialize values via
+    :meth:`~wuttjamaican:wuttjamaican.app.AppHandler.render_quantity()`.
+
+    :param request: Current :term:`request` object.
+    """
+
+    def __init__(self, request, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
+    def serialize(self, node, appstruct):
+        """ """
+        if appstruct in (colander.null, None):
+            return colander.null
+
+        # nb. we render as quantity here to avoid values like 12.0000,
+        # so we just show value like 12 instead
+        return self.app.render_quantity(appstruct)
+
+
 class WuttaSet(colander.Set):
     """
     Custom schema type for :class:`python:set` fields.
 
-    This is a subclass of :class:`colander.Set`, but adds
-    Wutta-related params to the constructor.
+    This is a subclass of :class:`colander.Set`.
 
     :param request: Current :term:`request` object.
-
-    :param session: Optional :term:`db session` to use instead of
-       :class:`wuttaweb.db.sess.Session`.
     """
 
-    def __init__(self, request, session=None):
+    def __init__(self, request):
         super().__init__()
         self.request = request
         self.config = self.request.wutta_config
         self.app = self.config.get_app()
-        self.session = session or Session()
 
 
 class ObjectRef(colander.SchemaType):
@@ -209,16 +259,16 @@ class ObjectRef(colander.SchemaType):
             self,
             request,
             empty_option=None,
-            session=None,
             *args,
             **kwargs,
     ):
+        # nb. allow session injection for tests
+        self.session = kwargs.pop('session', Session())
         super().__init__(*args, **kwargs)
         self.request = request
         self.config = self.request.wutta_config
         self.app = self.config.get_app()
         self.model_instance = None
-        self.session = session or Session()
 
         if empty_option:
             if empty_option is True:
@@ -450,7 +500,7 @@ class RoleRefs(WuttaSet):
         :returns: Instance of
            :class:`~wuttaweb.forms.widgets.RoleRefsWidget`.
         """
-        kwargs.setdefault('session', self.session)
+        session = kwargs.setdefault('session', Session())
 
         if 'values' not in kwargs:
             model = self.app.model
@@ -458,20 +508,20 @@ class RoleRefs(WuttaSet):
 
             # avoid built-ins which cannot be assigned to users
             avoid = {
-                auth.get_role_authenticated(self.session),
-                auth.get_role_anonymous(self.session),
+                auth.get_role_authenticated(session),
+                auth.get_role_anonymous(session),
             }
             avoid = set([role.uuid for role in avoid])
 
             # also avoid admin unless current user is root
             if not self.request.is_root:
-                avoid.add(auth.get_role_administrator(self.session).uuid)
+                avoid.add(auth.get_role_administrator(session).uuid)
 
             # everything else can be (un)assigned for users
-            roles = self.session.query(model.Role)\
-                                .filter(~model.Role.uuid.in_(avoid))\
-                                .order_by(model.Role.name)\
-                                .all()
+            roles = session.query(model.Role)\
+                           .filter(~model.Role.uuid.in_(avoid))\
+                           .order_by(model.Role.name)\
+                           .all()
             values = [(role.uuid.hex, role.name) for role in roles]
             kwargs['values'] = values
 
@@ -496,7 +546,7 @@ class UserRefs(WuttaSet):
         :returns: Instance of
            :class:`~wuttaweb.forms.widgets.UserRefsWidget`.
         """
-        kwargs.setdefault('session', self.session)
+        kwargs.setdefault('session', Session())
         return widgets.UserRefsWidget(self.request, **kwargs)
 
 
@@ -526,7 +576,7 @@ class Permissions(WuttaSet):
         :returns: Instance of
            :class:`~wuttaweb.forms.widgets.PermissionsWidget`.
         """
-        kwargs.setdefault('session', self.session)
+        kwargs.setdefault('session', Session())
         kwargs.setdefault('permissions', self.permissions)
 
         if 'values' not in kwargs:

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/src/wuttaweb/forms/widgets.py

@@ -41,6 +41,7 @@ in the namespace:
 """
 
 import datetime
+import decimal
 import os
 
 import colander
@@ -135,26 +136,21 @@ class WuttaCheckboxChoiceWidget(CheckboxChoiceWidget):
     Custom widget for :class:`python:set` fields.
 
     This is a subclass of
-    :class:`deform:deform.widget.CheckboxChoiceWidget`, but adds
-    Wutta-related params to the constructor.
+    :class:`deform:deform.widget.CheckboxChoiceWidget`.
 
     :param request: Current :term:`request` object.
 
-    :param session: Optional :term:`db session` to use instead of
-       :class:`wuttaweb.db.sess.Session`.
-
     It uses these Deform templates:
 
     * ``checkbox_choice``
     * ``readonly/checkbox_choice``
     """
 
-    def __init__(self, request, session=None, *args, **kwargs):
+    def __init__(self, request, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.request = request
         self.config = self.request.wutta_config
         self.app = self.config.get_app()
-        self.session = session or Session()
 
 
 class WuttaDateTimeWidget(DateTimeInputWidget):
@@ -194,6 +190,47 @@ class WuttaDateTimeWidget(DateTimeInputWidget):
         return super().serialize(field, cstruct, **kw)
 
 
+class WuttaMoneyInputWidget(MoneyInputWidget):
+    """
+    Custom widget for "money" fields.  This is used by default for
+    :class:`~wuttaweb.forms.schema.WuttaMoney` type nodes.
+
+    The main purpose of this widget is to leverage
+    :meth:`~wuttjamaican:wuttjamaican.app.AppHandler.render_currency()`
+    for the readonly display.
+
+    This is a subclass of
+    :class:`deform:deform.widget.MoneyInputWidget` and uses these
+    Deform templates:
+
+    * ``moneyinput``
+
+    :param request: Current :term:`request` object.
+
+    :param scale: If this kwarg is specified, it will be passed along
+       to ``render_currency()`` call.
+    """
+
+    def __init__(self, request, *args, **kwargs):
+        self.scale = kwargs.pop('scale', 2)
+        super().__init__(*args, **kwargs)
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
+
+    def serialize(self, field, cstruct, **kw):
+        """ """
+        readonly = kw.get('readonly', self.readonly)
+        if readonly:
+            if cstruct in (colander.null, None):
+                return HTML.tag('span')
+            cstruct = decimal.Decimal(cstruct)
+            text = self.app.render_currency(cstruct, scale=self.scale)
+            return HTML.tag('span', c=[text])
+
+        return super().serialize(field, cstruct, **kw)
+
+
 class FileDownloadWidget(Widget):
     """
     Widget for use with :class:`~wuttaweb.forms.schema.FileDownload`

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/src/wuttaweb/grids/base.py

@@ -115,7 +115,8 @@ class Grid:
 
        Dict of column (cell) value renderer overrides.
 
-       See also :meth:`set_renderer()`.
+       See also :meth:`set_renderer()` and
+       :meth:`set_default_renderers()`.
 
     .. attribute:: row_class
 
@@ -387,7 +388,6 @@ class Grid:
         self.key = key
         self.data = data
         self.labels = labels or {}
-        self.renderers = renderers or {}
         self.row_class = row_class
         self.actions = actions or []
         self.linked_columns = linked_columns or []
@@ -397,6 +397,10 @@ class Grid:
         self.app = self.config.get_app()
 
         self.set_columns(columns or self.get_columns())
+        self.renderers = {}
+        if renderers:
+            for key, val in renderers.items():
+                self.set_renderer(key, val)
         self.set_default_renderers()
         self.set_tools(tools)
 
@@ -591,8 +595,29 @@ class Grid:
            grid = Grid(request, columns=['foo', 'bar'])
            grid.set_renderer('foo', render_foo)
 
+        For convenience, in lieu of a renderer callable, you may
+        specify one of the following strings, which will be
+        interpreted as a built-in renderer callable, as shown below:
+
+        * ``'batch_id'`` -> :meth:`render_batch_id()`
+        * ``'boolean'`` -> :meth:`render_boolean()`
+        * ``'currency'`` -> :meth:`render_currency()`
+        * ``'datetime'`` -> :meth:`render_datetime()`
+        * ``'quantity'`` -> :meth:`render_quantity()`
+
         Renderer overrides are tracked via :attr:`renderers`.
         """
+        builtins = {
+            'batch_id': self.render_batch_id,
+            'boolean': self.render_boolean,
+            'currency': self.render_currency,
+            'datetime': self.render_datetime,
+            'quantity': self.render_quantity,
+        }
+
+        if renderer in builtins:
+            renderer = builtins[renderer]
+
         if kwargs:
             renderer = functools.partial(renderer, **kwargs)
         self.renderers[key] = renderer
@@ -601,15 +626,18 @@ class Grid:
         """
         Set default column value renderers, where applicable.
 
-        This will add new entries to :attr:`renderers` for columns
-        whose data type implies a default renderer should be used.
-        This is generally only possible if :attr:`model_class` is set
-        to a valid SQLAlchemy mapped class.
+        This is called automatically from the class constructor.  It
+        will add new entries to :attr:`renderers` for columns whose
+        data type implies a default renderer.  This is only possible
+        if :attr:`model_class` is set to a SQLAlchemy mapped class.
+
+        This only looks for a couple of data types, and configures as
+        follows:
 
-        This (for now?) only looks for
-        :class:`sqlalchemy:sqlalchemy.types.DateTime` columns and if
-        any are found, they are configured to use
-        :meth:`render_datetime()`.
+        * :class:`sqlalchemy:sqlalchemy.types.Boolean` ->
+          :meth:`render_boolean()`
+        * :class:`sqlalchemy:sqlalchemy.types.DateTime` ->
+          :meth:`render_datetime()`
         """
         if not self.model_class:
             return
@@ -625,6 +653,8 @@ class Grid:
                     column = prop.columns[0]
                     if isinstance(column.type, sa.DateTime):
                         self.set_renderer(key, self.render_datetime)
+                    elif isinstance(column.type, sa.Boolean):
+                        self.set_renderer(key, self.render_boolean)
 
     def set_link(self, key, link=True):
         """
@@ -1116,19 +1146,29 @@ class Grid:
         filters = filters or {}
 
         if self.model_class:
-            # TODO: i tried using self.get_model_columns() here but in
-            # many cases that will be too aggressive.  however it is
-            # often the case that the *grid* columns are a subset of
-            # the unerlying *table* columns.  so until a better way
-            # is found, we choose "too few" instead of "too many"
-            # filters here.  surely must improve it at some point.
-            for key in self.columns:
-                if key in filters:
-                    continue
-                prop = getattr(self.model_class, key, None)
-                if (prop and hasattr(prop, 'property')
-                    and isinstance(prop.property, orm.ColumnProperty)):
-                    filters[prop.key] = self.make_filter(prop)
+
+            # nb. i have found this confusing for some reason.  some
+            # things i've tried so far include:
+            #
+            # i first tried self.get_model_columns() but my notes say
+            # that was too aggressive in many cases.
+            #
+            # then i tried using the *subset* of self.columns, just
+            # the ones which correspond to a property on the model
+            # class.  but sometimes that skips filters we need.
+            #
+            # then i tried get_columns() from sa-utils to give the
+            # "true" column list, but that fails when the underlying
+            # column has different name than the prop/attr key.
+            #
+            # so now, we are looking directly at the sa mapper, for
+            # all column attrs and then using the prop key.
+
+            inspector = sa.inspect(self.model_class)
+            for prop in inspector.column_attrs:
+                if prop.key not in filters:
+                    attr = getattr(self.model_class, prop.key)
+                    filters[prop.key] = self.make_filter(attr)
 
         return filters
 
@@ -1755,23 +1795,80 @@ class Grid:
     # rendering methods
     ##############################
 
+    def render_batch_id(self, obj, key, value):
+        """
+        Column renderer for batch ID values.
+
+        This is not used automatically but you can use it explicitly::
+
+            grid.set_renderer('foo', 'batch_id')
+        """
+        if value is None:
+            return ""
+
+        batch_id = int(value)
+        return f'{batch_id:08d}'
+
+    def render_boolean(self, obj, key, value):
+        """
+        Column renderer for boolean values.
+
+        This calls
+        :meth:`~wuttjamaican:wuttjamaican.app.AppHandler.render_boolean()`
+        for the return value.
+
+        This may be used automatically per
+        :meth:`set_default_renderers()` or you can use it explicitly::
+
+            grid.set_renderer('foo', grid.render_boolean)
+        """
+        return self.app.render_boolean(value)
+
+    def render_currency(self, obj, key, value, **kwargs):
+        """
+        Column renderer for currency values.
+
+        This calls
+        :meth:`~wuttjamaican:wuttjamaican.app.AppHandler.render_currency()`
+        for the return value.
+
+        This is not used automatically but you can use it explicitly::
+
+            grid.set_renderer('foo', 'currency')
+            grid.set_renderer('foo', 'currency', scale=4)
+        """
+        return self.app.render_currency(value, **kwargs)
+
     def render_datetime(self, obj, key, value):
         """
-        Default cell value renderer for
-        :class:`sqlalchemy:sqlalchemy.types.DateTime` columns, which
-        calls
+        Column renderer for :class:`python:datetime.datetime` values.
+
+        This calls
         :meth:`~wuttjamaican:wuttjamaican.app.AppHandler.render_datetime()`
         for the return value.
 
         This may be used automatically per
-        :meth:`set_default_renderers()` or you can use it explicitly
-        for any :class:`python:datetime.datetime` column with::
+        :meth:`set_default_renderers()` or you can use it explicitly::
 
             grid.set_renderer('foo', grid.render_datetime)
         """
         dt = getattr(obj, key)
         return self.app.render_datetime(dt)
 
+    def render_quantity(self, obj, key, value):
+        """
+        Column renderer for quantity values.
+
+        This calls
+        :meth:`~wuttjamaican:wuttjamaican.app.AppHandler.render_quantity()`
+        for the return value.
+
+        This is not used automatically but you can use it explicitly::
+
+            grid.set_renderer('foo', grid.render_quantity)
+        """
+        return self.app.render_quantity(value)
+
     def render_table_element(
             self,
             form=None,

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/src/wuttaweb/progress.py

@@ -92,6 +92,9 @@ class SessionProgress(ProgressBase):
     """
 
     def __init__(self, request, key, success_msg=None, success_url=None, error_url=None):
+        self.request = request
+        self.config = self.request.wutta_config
+        self.app = self.config.get_app()
         self.key = key
         self.success_msg = success_msg
         self.success_url = success_url
@@ -137,7 +140,7 @@ class SessionProgress(ProgressBase):
         """
         self.session.load()
         self.session['error'] = True
-        self.session['error_msg'] = str(error)
+        self.session['error_msg'] = self.app.render_error(error)
         self.session['error_url'] = error_url or self.error_url
         self.session.save()
 

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/src/wuttaweb/templates/base.mako

@@ -155,7 +155,7 @@
     }
 
     #content-title h1 {
-        max-width: 50%;
+        max-width: 80%;
         overflow: hidden;
         padding-left: 0.5rem;
         text-overflow: ellipsis;
@@ -659,7 +659,7 @@
           % if request.is_root:
               ${h.form(url('stop_root'), ref='stopBeingRootForm')}
               ${h.csrf_token(request)}
-              <input type="hidden" name="referrer" value="${request.current_route_url()}" />
+              <input type="hidden" name="referrer" value="${request.url}" />
               <a @click="stopBeingRoot()"
                  class="navbar-item has-background-danger has-text-white">
                 Stop being root

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/src/wuttaweb/templates/batch/view.mako

@@ -1,19 +1,6 @@
 ## -*- coding: utf-8; -*-
 <%inherit file="/master/view.mako" />
 
-<%def name="extra_styles()">
-  ${parent.extra_styles()}
-  <style>
-
-    ## TODO: should we do something like this site-wide?
-    ## (so far this is the only place we use markdown)
-    .markdown p {
-        margin-bottom: 1.5rem;
-    }
-
-  </style>
-</%def>
-
 <%def name="tool_panels()">
   ${parent.tool_panels()}
   ${self.tool_panel_execution()}
@@ -65,7 +52,7 @@
                     <p class="block has-text-weight-bold">
                       What will happen when this batch is executed?
                     </p>
-                    <div class="markdown">
+                    <div class="content">
                       ${execution_described|n}
                     </div>
                     ${h.form(master.get_action_url('execute', batch), ref='executeForm')}

{wuttaweb-0.19.0 → wuttaweb-0.19.2}/src/wuttaweb/templates/master/view.mako

@@ -33,6 +33,21 @@
   % endif
 </%def>
 
+<%def name="tool_panels()">
+  ${parent.tool_panels()}
+  ${self.tool_panel_xref()}
+</%def>
+
+<%def name="tool_panel_xref()">
+  % if xref_buttons:
+      <wutta-tool-panel heading="Cross-Reference">
+        % for button in xref_buttons:
+            ${button}
+        % endfor
+      </wutta-tool-panel>
+  % endif
+</%def>
+
 <%def name="render_vue_templates()">
   ${parent.render_vue_templates()}
   % if master.has_rows: