bootstack 0.1.7__tar.gz → 0.2.0__tar.gz

{bootstack-0.1.7/src/bootstack.egg-info → bootstack-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bootstack
-Version: 0.1.7
+Version: 0.2.0
 Summary: Build desktop GUI apps in pure Python and ship them as a standalone executable — built on Tk, no Tkinter boilerplate.
 Author-email: Israel Dryer <israel.dryer@gmail.com>
 License-Expression: MIT

{bootstack-0.1.7 → bootstack-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bootstack"
-version = "0.1.7"
+version = "0.2.0"
 description = "Build desktop GUI apps in pure Python and ship them as a standalone executable — built on Tk, no Tkinter boilerplate."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -114,7 +114,7 @@ where = ["src"]
 ]
 
 [tool.bumpversion]
-current_version = "0.1.7"
+current_version = "0.2.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)((?P<pre>a|b|rc)(?P<pre_n>\\d+))?"
 serialize = [
     "{major}.{minor}.{patch}{pre}{pre_n}",

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/_runtime/events.py

@@ -32,6 +32,7 @@ Note:
     applied globally and affect all tkinter widgets in the application.
 """
 
+import itertools
 import tkinter as tk
 import uuid
 import weakref
@@ -43,9 +44,35 @@ from typing import Any, Callable, Optional, Union
 _event_data_cache: OrderedDict[str, Any] = OrderedDict()
 _MAX_CACHE_SIZE = 100  # Prevent unbounded growth
 
+# Serial number used to give every registered handler a unique name. See
+# `_unique_name` for why the stock naming scheme is not safe here.
+_binding_seq = itertools.count()
+
+
+def _unique_name(prefix: str) -> str:
+    """Return a handler name that can never collide with a previous one.
+
+    Tkinter names the Tcl command behind a binding `repr(id(f)) + f.__name__`,
+    where `f` is a bound method created for that registration alone. Nothing
+    else refers to it, so releasing the command frees the method and CPython is
+    free to hand the very same address to the next one — measured at 498 out of
+    499 consecutive bind/cancel/bind cycles. Every wrapper registered here has
+    the same `__name__`, so the whole name would repeat with it.
+
+    That is harmless while removals delete the command immediately, but
+    `_patched_unbind` defers the deletion to the next idle point. A repeated
+    name means a binding created in the meantime inherits the name a deletion is
+    already pending on, and that deletion then takes out a live handler — the
+    #392 failure again, on a new trigger. A serial number in the name keeps the
+    two apart no matter what the allocator does.
+    """
+    return '%s%d' % (prefix, next(_binding_seq))
+
+
 # Store original tkinter methods before patching
 _original_event_generate: Callable = tk.Misc.event_generate
 _original_bind: Callable = tk.Misc.bind
+_original_unbind: Callable = tk.Misc.unbind
 
 
 def _patched_event_generate(
@@ -219,23 +246,60 @@ def _patched_bind(
                 # Attach custom data (don't pop yet - multiple handlers may need it)
                 if data_guid and data_guid in _event_data_cache:
                     event.data = _event_data_cache[data_guid]
-                    # Schedule cleanup after all handlers have run
-                    widget.after_idle(lambda: _event_data_cache.pop(data_guid, None))
+                    # Schedule cleanup after all handlers have run. On the root,
+                    # not on `widget`: deferred work owned by a widget is torn
+                    # down with it, so a handler that destroys its own widget
+                    # would leave this callback pointing at a command destroy()
+                    # had already swept — a silent background error. The root
+                    # outlives every widget. (Same rule as `_patched_unbind`.)
+                    try:
+                        widget._root().after_idle(
+                            lambda: _event_data_cache.pop(data_guid, None)
+                        )
+                    except (tk.TclError, AttributeError):
+                        # No event loop left to defer onto; the LRU cap reclaims
+                        # the entry instead.
+                        pass
                 else:
                     # Data might have been evicted from cache already
                     event.data = None
 
                 return func(event)
 
-            # Register wrapper function with tkinter
+            # Register wrapper function with tkinter. The name tkinter builds
+            # ends with the function's `__name__`, so making that unique is
+            # enough to keep a deferred deletion off a later binding.
+            wrapper.__name__ = _unique_name('bsvirtual')
             name = self._register(wrapper)
 
-            # Build command with all substitutions including %d for data GUID
+            # Build the binding script. Its exact shape is load-bearing, and
+            # this must stay byte-for-byte what stock `Misc._bind` emits:
+            #
+            #   * Removing a single handler works by matching the line prefix
+            #     `if {"[<funcid> ` — note the TRAILING SPACE, which means the
+            #     substitution list below must never be empty. A script in any
+            #     other shape is invisible to the matcher, so the handler
+            #     survives while its command is deleted, leaving an orphan that
+            #     aborts every handler after it. All handlers for an event share
+            #     ONE concatenated script, so that took out every handler
+            #     registered after the cancelled one (#392).
+            #   * The `if {...} == "break"` test is what lets a handler return
+            #     'break' to stop the remaining handlers for that event.
+            #
+            # (The trailing newline only separates this line from the next
+            # handler's; Tk inserts its own separator when appending a `+`
+            # script. It is kept to match stock exactly.)
+            #
+            # The substitution list carries %d (our data token) ahead of the
+            # standard values; its order must match `wrapper`'s parameters.
             # Substitution codes: https://tcl.tk/man/tcl8.6/TkCmd/bind.htm
-            cmd = f'{name} %d %# %b %h %w %k %s %t %x %y %X %Y %A %K %N %T %E %D'
+            subst = '%d %# %b %h %w %k %s %t %x %y %X %Y %A %K %N %T %E %D'
+            cmd = '%sif {"[%s %s]" == "break"} break\n' % (
+                '+' if add else '', name, subst
+            )
 
             # Bind to widget
-            self.tk.call('bind', self._w, sequence, cmd if not add else '+' + cmd)
+            self.tk.call('bind', self._w, sequence, cmd)
 
             return name
         else:
@@ -246,12 +310,92 @@ def _patched_bind(
                     event.data = None
                 return func(event)
 
+            # Real events are removed by the same patched `unbind`, so they need
+            # the same protection from a recycled name. See `_unique_name`.
+            regular_wrapper.__name__ = _unique_name('bsregular')
             return _original_bind(self, sequence, regular_wrapper, add)
 
     # No function or sequence provided, pass through to original
     return _original_bind(self, sequence, func, add)
 
 
+def _patched_unbind(
+    self: tk.Misc,
+    sequence: str,
+    funcid: Optional[str] = None
+) -> None:
+    """Enhanced unbind that cannot disturb the other handlers for an event.
+
+    Stock tkinter removes one handler in two steps: rewrite the binding script
+    without that handler's line, then delete the Tcl command behind it. The
+    rewrite is correct, but the deletion is immediate — and all handlers for an
+    event share ONE script, so if the removal happens *while that script is
+    running* (a handler cancelling another handler's subscription), execution
+    later reaches the deleted command and the whole script aborts. Every handler
+    after the cancelled one is skipped for that dispatch, and the error surfaces
+    nowhere Python can see it.
+
+    This version neutralizes the command in place instead, then deletes it once
+    the current dispatch has finished. An already-running script then evaluates
+    a harmless no-op where the cancelled handler used to be and carries on to
+    the handlers after it.
+
+    Args:
+        self: The widget instance (automatically provided)
+        sequence: Event sequence the handler was bound to
+        funcid: Identifier returned by `bind`. When omitted, every handler for
+            the sequence is removed and the original implementation is used.
+    """
+    if funcid is None:
+        # Removing everything replaces the whole script, so there is no
+        # surviving line that could reference a deleted command.
+        return _original_unbind(self, sequence)
+
+    what = ('bind', self._w, sequence)
+    try:
+        script = self.tk.call(what)
+        lines = str(script).split('\n')
+        # Must match what `_patched_bind` emits (and stock `Misc._bind`).
+        prefix = 'if {"[%s ' % funcid
+        keep = [line for line in lines if not line.startswith(prefix)]
+        if len(keep) == len(lines):
+            # This funcid is not bound to this widget and sequence, so it is
+            # not ours to delete — the live binding may be somewhere else, and
+            # deleting its command would orphan it. Leave everything alone.
+            return
+        remaining = '\n'.join(keep)
+        self.tk.call(*what, remaining if remaining.strip() else '')
+        # Replace the command rather than deleting it, so an in-flight copy of
+        # the concatenated script has something harmless to call.
+        self.tk.createcommand(funcid, lambda *args: '')
+    except tk.TclError:
+        return
+
+    def _delete_command() -> None:
+        try:
+            self.deletecommand(funcid)
+        except (tk.TclError, AttributeError):
+            # Already swept, most likely because the widget was destroyed
+            # before the interpreter went idle. `AttributeError` is that same
+            # case seen from the other side: destroy() clears the widget's
+            # command bookkeeping, which `deletecommand` then cannot update.
+            pass
+
+    try:
+        # Deliberately scheduled on the root, not on `self`. Deferred work owned
+        # by a widget is torn down with it, and destroying a widget between the
+        # cancellation and the next idle point would leave the pending callback
+        # referring to a command that destroy() had already deleted — a silent
+        # error of exactly the kind this function exists to avoid. The root
+        # outlives every widget, and when the root itself goes the pending
+        # callback goes with it, which is equally fine: there is nothing left to
+        # clean up.
+        self._root().after_idle(_delete_command)
+    except (tk.TclError, AttributeError):
+        # No event loop left to defer onto; nothing can be mid-dispatch either.
+        _delete_command()
+
+
 def cleanup_event_cache() -> None:
     """Manually clear the entire event data cache.
 
@@ -342,9 +486,10 @@ def get_cache_size() -> int:
 def install_enhanced_events() -> None:
     """Install the enhanced event system by patching tkinter methods.
 
-    This function applies monkey patches to tkinter's Misc class,
-    replacing event_generate and bind with enhanced versions that
-    support passing custom data through virtual events.
+    This function applies monkey patches to tkinter's Misc class, replacing
+    event_generate and bind with enhanced versions that support passing custom
+    data through virtual events, and unbind with a version that cannot disturb
+    the other handlers for an event while one is being removed.
 
     The patches are applied globally and affect all tkinter widgets
     in the application. This function is called automatically when
@@ -364,6 +509,7 @@ def install_enhanced_events() -> None:
     """
     tk.Misc.event_generate = _patched_event_generate
     tk.Misc.bind = _patched_bind
+    tk.Misc.unbind = _patched_unbind
 
 
 def uninstall_enhanced_events() -> None:
@@ -387,6 +533,7 @@ def uninstall_enhanced_events() -> None:
     """
     tk.Misc.event_generate = _original_event_generate
     tk.Misc.bind = _original_bind
+    tk.Misc.unbind = _original_unbind
     cleanup_event_cache()
 
 

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/_runtime/utility.py

@@ -30,11 +30,18 @@ def _platform_baseline() -> float:
 
     Tk scaling is measured in pixels-per-point (72 points per inch).
     - Windows/Linux default DPI is 96  → baseline = 96/72 ≈ 1.334
-    - macOS default DPI is 72          → baseline = 72/72 = 1.0
+    - macOS default DPI is 72 on Tk 8.6 → baseline = 72/72 = 1.0
       (Retina pixel-doubling is handled by the OS, not Tk scaling)
+
+    Tk 9 changed Aqua's nominal resolution from 72 to 96 DPI, aligning it with
+    Windows/X11 (#375). The pixel grid is unchanged — only the physical-size
+    claim moved — so the baseline must key off the Tk version, not the platform
+    alone. Keying off platform alone reports ui_scale ~1.333 instead of 1.0 on
+    macOS + Tk 9 and inflates every DPI-derived measurement by a third.
     """
     import platform
-    if platform.system() == 'Darwin':
+    import tkinter
+    if platform.system() == 'Darwin' and tkinter.TkVersion < 9.0:
         return 1.0
     return 1.33398982438864281  # 96 DPI / 72
 
@@ -54,6 +61,11 @@ class _ScalingState:
         """Get the current global scale factor."""
         return cls._scale_factor
 
+    @classmethod
+    def get_baseline(cls) -> float:
+        """Get the platform's nominal Tk scaling (pixels per point)."""
+        return cls._baseline
+
     @classmethod
     def get_ui_scale(cls) -> float:
         """Get the UI scale factor (relative to baseline)."""

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/errors.py

@@ -31,6 +31,17 @@ class SerializationError(BootstackError):
     """
 
 
+class InvalidChoiceError(BootstackError, ValueError):
+    """Raised when a keyword argument is given a value outside its valid set.
+
+    Applies to arguments that name a behavior mode drawn from a closed set,
+    such as `selection_mode` or `scrollbars`. The message names the value that
+    was rejected and lists the values that are accepted.
+
+    Also a `ValueError`, so either `BootstackError` or `ValueError` catches it.
+    """
+
+
 class NavigationError(BootstackError):
     """Raised when a navigation operation references a wrong key.
 
@@ -58,6 +69,7 @@ class StyleBuilderError(BootstackError):
 __all__ = [
     "BootstackError",
     "DuplicateIdError",
+    "InvalidChoiceError",
     "NavigationError",
     "ParentResolutionError",
     "SerializationError",

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/style/typography.py

@@ -8,6 +8,8 @@ from tkinter import Misc, font as tkfont
 from tkinter.font import Font as TkFont
 from typing import Any, Literal, NamedTuple
 
+from bootstack._runtime.utility import _ScalingState
+
 
 # =============================================================================
 # Token model
@@ -90,12 +92,19 @@ def build_desktop_tokens(
     elif system == "darwin":
         default_ui = "SF Pro Text"
         default_mono = "Menlo"
-        # Tk's pt-to-pixel conversion uses the active scaling factor.
-        # macOS defaults to 1.0 (72 DPI baseline) vs ~1.334 on Win/Linux,
-        # so the same point size renders ~25% smaller on Mac. Bump the
-        # base to keep visual parity across platforms and align with the
-        # macOS HIG default control text size (13pt).
-        base = _clamp_base_size(base + 2)
+        # Tk's pt-to-pixel conversion uses the active scaling factor. On Tk 8.6
+        # macOS defaults to 1.0 (72 DPI baseline) vs ~1.334 on Win/Linux, so
+        # the same point size renders ~25% smaller on Mac. Bump the base to
+        # align with the macOS HIG default control text size (13pt).
+        #
+        # Tk 9 moved Aqua to a 96 DPI baseline (#375), so a "point" is no
+        # longer the same physical size and the raw bump double-counts (a
+        # `body` label rendered at 20px linespace instead of 16px). The target
+        # is a physical size, so express it in the active point unit: divide by
+        # the baseline ratio. Tk 8.6 -> 13pt (unchanged), Tk 9 -> 10pt, which
+        # is the same rendered size and matches the point size Tk 9 itself
+        # picks for TkDefaultFont.
+        base = _clamp_base_size(round((base + 2) / _ScalingState.get_baseline()))
     else:
         default_ui = "DejaVu Sans"
         default_mono = "DejaVu Sans Mono"

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/widgets/_core/base.py

@@ -13,20 +13,30 @@ if TYPE_CHECKING:
     from bootstack.streams import Stream
 
 
-def adapt_handler(handler: Callable[[Any], Any]) -> Callable[[Any], Any]:
+def adapt_handler(handler: Callable[[Any], Any]) -> Callable[[Any], None]:
     """Wrap a public handler so it receives a bootstack event, not a raw one.
 
     Data-carrying events (emitted with `data=<payload>`) deliver the payload
     object directly — the handler argument *is* the payload. Native/context
     events carry no payload, so the raw toolkit event is curated into a clean
     :class:`~bootstack.events.Event` first.
+
+    A handler's return value is deliberately discarded. The underlying toolkit
+    treats one particular return value as "stop the remaining handlers for this
+    event", which would make any handler that happens to return that value drop
+    its siblings — silently, and with nothing in the public API to explain it.
+    Suppressing later handlers is a capability worth designing on purpose rather
+    than inheriting, so nothing is promised here. Handlers bound internally do
+    not pass through this wrapper and are unaffected.
     """
 
-    def _wrapped(raw: Any) -> Any:
+    def _wrapped(raw: Any) -> None:
         payload = getattr(raw, "data", None)
         if payload is not None:
-            return handler(payload)
-        return handler(Event._from_tk(raw))
+            handler(payload)
+        else:
+            handler(Event._from_tk(raw))
+        return None
 
     return _wrapped
 

bootstack-0.2.0/src/bootstack/widgets/_core/choices.py

@@ -0,0 +1,56 @@
+"""Construction-time checking for keyword arguments with a closed value set.
+
+Many widget keyword arguments name a behavior mode drawn from a small, closed
+set — `selection_mode`, `sorting_mode`, `scrollbars`. The widgets read those
+values by comparing against one literal (`mode == 'multi'`), so a near-miss
+spelling does not fail: it just takes the other branch. `selection_mode='multiple'`
+turns multi-select off and reports nothing, which reads as a broken widget rather
+than a typo.
+
+`validate_choice` closes that gap. It runs at construction, names the value it
+rejected and the set it accepts, and raises `InvalidChoiceError` — both a
+`BootstackError` and a `ValueError`, so either is a valid thing to catch. Call it
+before anything else in `__init__`, ahead of parent resolution: a bad value
+should be reported as a bad value, not masked by whatever fails next.
+
+Only use it for a genuinely closed set. Arguments that widen their literal with
+`| str` — `accent`, `surface` — accept values the alias does not spell out
+(`'primary[+1]'`, `'primary[500]'`) and must not be checked this way.
+"""
+from __future__ import annotations
+
+from typing import Any, Sequence, TypeVar, get_args
+
+from bootstack.errors import InvalidChoiceError
+from bootstack.widgets.types import SelectionMode
+
+T = TypeVar("T")
+
+SELECTION_MODES = get_args(SelectionMode)
+"""Accepted `selection_mode` values, read from the `SelectionMode` alias so the
+check cannot drift from the type."""
+
+
+def validate_choice(value: T, valid: Sequence[Any], *, param: str, widget: str) -> T:
+    """Return `value` if it is in `valid`, otherwise raise.
+
+    Args:
+        value: The value the caller supplied.
+        valid: The accepted values, in the order they should be listed back.
+        param: Name of the keyword argument being checked, e.g.
+            `'selection_mode'`.
+        widget: Name of the public widget or method the caller used, e.g.
+            `'DataTable'`, used to open the message.
+
+    Returns:
+        The value, unchanged.
+
+    Raises:
+        InvalidChoiceError: If `value` is not in `valid`.
+    """
+    if value in valid:
+        return value
+    listed = ", ".join(repr(v) for v in valid)
+    raise InvalidChoiceError(
+        f"{widget}({param}={value!r}) is not a valid {param}. Valid values: {listed}."
+    )

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/widgets/_core/container.py

@@ -255,17 +255,74 @@ def grid_sticky(horizontal: str | None, vertical: str | None) -> str:
     return sticky
 
 
+def resolve_layout_items(
+    layout: str,
+    horizontal_items: str | None,
+    vertical_items: str | None,
+    *,
+    column_horizontal: str | None = None,
+) -> tuple[str | None, str | None]:
+    """Fill in a multi-mode container's unset `*_items` for its layout mode.
+
+    Containers that can lay out as a column, a row, or a grid (`Card`, `GroupBox`,
+    `Expander`, `Tabs`, `PageStack`, `SplitView`, the AppShell page) take
+    `horizontal_items`/`vertical_items` as `None`-means-unset and need a default
+    that depends on the mode.
+
+    A **grid** gets concrete values, because the grid engine has no notion of an
+    unset axis — cells stretch unless told otherwise. A **column** or **row**
+    keeps `None` and lets `FlexFrame` resolve it: the engine's own defaults are
+    exactly what these containers used to hard-code (the stacking axis starts at
+    its leading edge, the cross axis centers), and leaving the cross axis unset is
+    what allows a child to contribute its own default — which is how a row of
+    input fields stays aligned whether or not each field carries a validation
+    message (#394). Pre-resolving to `'center'` here silently suppressed that.
+
+    Args:
+        layout: The container's layout mode — `'column'`, `'row'` or `'grid'`.
+        horizontal_items: The x-axis value as given, or None if unset.
+        vertical_items: The y-axis value as given, or None if unset.
+        column_horizontal: Cross-axis override for column mode, for a container
+            whose column should not center — the AppShell page stretches instead.
+            Defaults to None (use the engine default).
+
+    Returns:
+        The pair to hand the layout frame. Either element may be None in column or
+        row mode, meaning "unset — let the engine decide"; both are concrete for a
+        grid. The None is only ever passed to `FlexFrame`; the grid path
+        (`_merge_layout_options`) runs solely in grid mode, where both are set.
+    """
+    if layout == "grid":
+        return (horizontal_items or "stretch", vertical_items or "stretch")
+    if layout == "column" and horizontal_items is None:
+        horizontal_items = column_horizontal
+    return (horizontal_items, vertical_items)
+
+
 def _flex_child_opts(child: PublicWidgetBase, layout_kw: dict) -> dict:
     """Build the FlexFrame per-child opts dict from resolved layout kwargs.
 
     Expects `_expand_margin` to have already converted margins to padx/pady.
     Carries spacer metadata when `child` is a `Spacer` (duck-typed to avoid a
     circular import).
+
+    A widget may also declare its own preferred cross-axis alignment via a
+    `_flex_horizontal_default` / `_flex_vertical_default` class attribute (same
+    duck-typing). That is a *soft* default: it applies only when neither the
+    child nor the container was given an explicit alignment, so it can never
+    override an instruction the author actually wrote. The field family uses it
+    to sit top-aligned in a Row instead of centering, since a field carrying a
+    validation message is taller than one that isn't (#394).
     """
     opts: dict[str, Any] = {}
     for key in ("grow", "horizontal", "vertical", "padx", "pady"):
         if key in layout_kw:
             opts[key] = layout_kw[key]
+    for axis in ("horizontal", "vertical"):
+        if axis not in opts:
+            declared = getattr(child, f"_flex_{axis}_default", None)
+            if declared is not None:
+                opts[f"_{axis}_default"] = declared
     if getattr(child, "_is_spacer", False):
         opts["_spacer"] = True
         opts["_spacer_size"] = getattr(child, "_spacer_size", None)

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/widgets/_core/field_mixin.py

@@ -23,6 +23,13 @@ class FieldAddonMixin:
     #: field wrappers override it (`'number'`, `'date'`, `'time'`).
     _VALIDATION_KIND: str = "text"
 
+    #: Cross-axis alignment a field contributes when the author set none. A
+    #: field that shows a validation message is taller than one that doesn't, so
+    #: centering them in a Row leaves the shorter ones sitting low; top-aligning
+    #: lines their labels and entries up instead. Soft — an explicit `vertical`
+    #: on the field or `vertical_items` on the container still wins (#394).
+    _flex_vertical_default: str = "top"
+
     _ADDON_TYPES = {
         "button":  "bootstack.widgets._impl.primitives.button::Button",
         "label":   "bootstack.widgets._impl.primitives.label::Label",

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/widgets/_impl/_parts/spinnerentry_part.py

@@ -13,6 +13,7 @@ from bootstack.i18n import MessageCatalog, IntlFormatter
 from bootstack.widgets._impl.primitives.spinbox import Spinbox
 from bootstack.widgets._impl.mixins import ValidationMixin
 from bootstack.widgets._impl.mixins.configure_mixin import configure_delegate
+from bootstack.widgets._impl._parts.textentry_part import _UNSET
 
 
 class SpinnerEntryPart(ValidationMixin, Spinbox):
@@ -307,16 +308,17 @@ class SpinnerEntryPart(ValidationMixin, Spinbox):
         """Remove callback from <<Change>> event."""
         self.unbind('<<Change>>', bind_id)
 
-    def value(self, value=None):
+    def value(self, value=_UNSET):
         """Get or set the parsed/committed value.
 
         Args:
-            value: If provided, sets the display text and internal value with formatting
+            value: If provided, sets the display text and internal value with
+                formatting. Pass `None` to clear the field.
 
         Returns:
             Current parsed value if no argument provided, None otherwise
         """
-        if value is None:
+        if value is _UNSET:
             return self._value
         else:
             # Store the value and format it for display

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/widgets/_impl/_parts/textentry_part.py

@@ -7,6 +7,11 @@ from bootstack.widgets._impl.primitives.entry import Entry
 from bootstack.widgets._impl.mixins import ValidationMixin
 from bootstack.widgets._impl.mixins.configure_mixin import configure_delegate
 
+#: Sentinel marking "no argument passed" for the combined get/set accessors below.
+#: `None` cannot serve as that sentinel — it is a real value meaning "empty", and
+#: using it to mean "get" made `value(None)` a silent no-op instead of clearing.
+_UNSET: Any = object()
+
 
 class TextEntryPart(ValidationMixin, Entry):
     """Internationalization-aware entry widget with deferred parsing and formatting.
@@ -250,16 +255,17 @@ class TextEntryPart(ValidationMixin, Entry):
         """Unbind from `<<Change>>`."""
         self.unbind('<<Change>>', bind_id)
 
-    def value(self, value=None):
+    def value(self, value=_UNSET):
         """Get or set the parsed/committed value.
 
         Args:
-            value: If provided, sets the display text and internal value with formatting
+            value: If provided, sets the display text and internal value with
+                formatting. Pass `None` to clear the field.
 
         Returns:
             Current parsed value if no argument provided, None otherwise
         """
-        if value is None:
+        if value is _UNSET:
             return self._value
         else:
             # Store the value and format it for display

{bootstack-0.1.7 → bootstack-0.2.0}/src/bootstack/widgets/_impl/composites/dateentry.py

@@ -269,6 +269,31 @@ class DateEntry(Field):
                 self.date_picker_button.pack_forget()
         return None
 
+    def _apply_picked(self, val) -> None:
+        """Apply a value chosen in the picker and announce it as a user commit.
+
+        Choosing a date is a commit, exactly like typing one and pressing
+        Return, so it has to emit `<<Change>>` — bound signals, `on_change`
+        handlers, and form change tracking all listen for that event. Assigning
+        `value` alone does not emit it: the event comes from the entry's own
+        change detection, which otherwise only runs on FocusOut and Return.
+
+        `_check_if_changed` also advances the entry's last-seen value, so a
+        later focus-out cannot fire a second `<<Change>>` for this same
+        selection — which hand-building the event here would allow whenever the
+        entry already held focus. It is safe to call twice: the second call
+        sees no difference and does nothing.
+
+        Range mode is left alone; `_set_range` already emits its own event.
+        """
+        if self._selection_mode == "range":
+            self.value = val
+            return
+        if isinstance(val, datetime):
+            val = val.date()
+        self.value = val
+        self._entry._check_if_changed()
+
     def _show_date_picker(self):
         """Open the calendar picker dialog.
 
@@ -336,10 +361,10 @@ class DateEntry(Field):
             result = payload.get('result') if isinstance(payload, dict) else payload
             if self._selection_mode == "range":
                 if isinstance(result, tuple) and len(result) == 2:
-                    self.value = result
+                    self._apply_picked(result)
             else:
                 if isinstance(result, (date, datetime)):
-                    self.value = result
+                    self._apply_picked(result)
 
         dialog.on_result(lambda x: _on_result(x))
         dialog.show(
@@ -366,12 +391,10 @@ class DateEntry(Field):
         selected = dialog.result
         if self._selection_mode == "range":
             if isinstance(selected, tuple) and len(selected) == 2:
-                self.value = selected
+                self._apply_picked(selected)
         else:
-            if isinstance(selected, datetime):
-                selected = selected.date()
-            if isinstance(selected, date):
-                self.value = selected
+            if isinstance(selected, (date, datetime)):
+                self._apply_picked(selected)
 
         # Return focus to the entry after dialog closes
         # Note: focus_force() is needed on Windows after override-redirect dialogs