dwipe 3.2.0__tar.gz → 3.2.2__tar.gz

{dwipe-3.2.0 → dwipe-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dwipe
-Version: 3.2.0
+Version: 3.2.2
 Summary: A tool to wipe disks and partitions for Linux
 Keywords: disk,partition,wipe,clean,scrub
 Author-email: Joe Defen <joedef@google.com>
@@ -15,15 +15,17 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: POSIX :: Linux
 License-File: LICENSE
-Requires-Dist: console-window == 2.1.3
+Requires-Dist: console-window == 2.2.2
 Requires-Dist: pytest >= 7.0 ; extra == "dev"
 Requires-Dist: pytest-cov >= 4.0 ; extra == "dev"
 Requires-Dist: ruff >= 0.9 ; extra == "dev"
 Requires-Dist: build >= 1.2 ; extra == "dev"
 Requires-Dist: twine >= 7 ; extra == "dev"
 Requires-Dist: packaging >= 26 ; extra == "dev"
+Requires-Dist: tomli >= 2.0 ; extra == "dev" and ( python_version < "3.11")
 Requires-Dist: pytest >= 7.0 ; extra == "test"
 Requires-Dist: pytest-cov >= 4.0 ; extra == "test"
+Requires-Dist: tomli >= 2.0 ; extra == "test" and ( python_version < "3.11")
 Project-URL: Bug Tracker, https://github.com/joedefen/dwipe/issues
 Project-URL: Homepage, https://github.com/joedefen/dwipe
 Provides-Extra: dev
@@ -33,7 +35,7 @@ Import-Name: dwipe
 # dwipe
 `dwipe` is a tool to wipe disks and partitions for Linux to help secure your data. `dwipe` aims to reduce mistakes by providing ample information about your devices during selection.
 
-![Demo of dwipe](https://raw.githubusercontent.com/joedefen/dwipe/master/images/dwipe-2026-02-05.07-58.gif)
+![Demo of dwipe](https://raw.githubusercontent.com/joedefen/dwipe/main/images/dwipe-2026-02-05.07-58.gif)
 ### Quick Comparison
 
 | Feature | dwipe | nwipe | shred | dd |
@@ -137,6 +139,8 @@ Simply run `dwipe` from the command line without arguments: `dwipe`
   - Percentage of disk to verify after wipe (1% = quick spot-check, 100% = full verify)
 
 #### Display and Performance
+- `--theme {default,dark-mono,light-mono,solarized-dark,solarized-light,gruvbox,nord}` - Color palette
+- `--no-color` - Draw semantic roles with attributes (bold/reverse) instead of color; also honored when the `NO_COLOR` environment variable is set
 - `--dense {True,False}` - Compact view mode (default: your last preference)
   - `True` - Compact spacing (fewer blank lines between disks)
   - `False` - Spaced view (blank lines between disks for readability)
@@ -190,11 +194,13 @@ Simply run `dwipe` from the command line without arguments: `dwipe`
 - `solarized-light` - Solarized Light palette (for light terminal backgrounds)
 - `gruvbox` - Gruvbox Dark palette
 - `nord` - Nord palette
+- `mono` - Draw without color at all, using bold/reverse attributes instead (also available as `--no-color` and through the `NO_COLOR` environment variable)
 
 **Changing themes:**
 - Press **t** from the main screen to open the theme preview screen
 - The theme screen shows color examples for each color purpose (DANGER, SUCCESS, WARNING, etc.)
 - Press **t** while on the theme screen to cycle through available themes and preview them live
+- The list ends with **mono**, which turns color off and leaves the selected palette underneath
 - Press **ESC** or **ENTER** to return to the main screen
 - Selected theme is saved and persists across sessions
 

{dwipe-3.2.0 → dwipe-3.2.2}/README.md

@@ -1,7 +1,7 @@
 # dwipe
 `dwipe` is a tool to wipe disks and partitions for Linux to help secure your data. `dwipe` aims to reduce mistakes by providing ample information about your devices during selection.
 
-![Demo of dwipe](https://raw.githubusercontent.com/joedefen/dwipe/master/images/dwipe-2026-02-05.07-58.gif)
+![Demo of dwipe](https://raw.githubusercontent.com/joedefen/dwipe/main/images/dwipe-2026-02-05.07-58.gif)
 ### Quick Comparison
 
 | Feature | dwipe | nwipe | shred | dd |
@@ -105,6 +105,8 @@ Simply run `dwipe` from the command line without arguments: `dwipe`
   - Percentage of disk to verify after wipe (1% = quick spot-check, 100% = full verify)
 
 #### Display and Performance
+- `--theme {default,dark-mono,light-mono,solarized-dark,solarized-light,gruvbox,nord}` - Color palette
+- `--no-color` - Draw semantic roles with attributes (bold/reverse) instead of color; also honored when the `NO_COLOR` environment variable is set
 - `--dense {True,False}` - Compact view mode (default: your last preference)
   - `True` - Compact spacing (fewer blank lines between disks)
   - `False` - Spaced view (blank lines between disks for readability)
@@ -158,11 +160,13 @@ Simply run `dwipe` from the command line without arguments: `dwipe`
 - `solarized-light` - Solarized Light palette (for light terminal backgrounds)
 - `gruvbox` - Gruvbox Dark palette
 - `nord` - Nord palette
+- `mono` - Draw without color at all, using bold/reverse attributes instead (also available as `--no-color` and through the `NO_COLOR` environment variable)
 
 **Changing themes:**
 - Press **t** from the main screen to open the theme preview screen
 - The theme screen shows color examples for each color purpose (DANGER, SUCCESS, WARNING, etc.)
 - Press **t** while on the theme screen to cycle through available themes and preview them live
+- The list ends with **mono**, which turns color off and leaves the selected palette underneath
 - Press **ESC** or **ENTER** to return to the main screen
 - Selected theme is saved and persists across sessions
 

{dwipe-3.2.0 → dwipe-3.2.2}/dwipe/DeviceInfo.py

@@ -13,7 +13,7 @@ import traceback
 from fnmatch import fnmatch
 from types import SimpleNamespace
 
-from console_window import Theme
+from console_window import Theme, appearance
 
 from .DeviceWorker import DeviceWorkerManager, ProbeState
 from .DrivePreChecker import DrivePreChecker
@@ -1045,38 +1045,40 @@ class DeviceInfo:
             else:
                 emit += f'{sep}{ns.marker}'
 
-        # Determine color attribute based on state
+        # Determine color attribute based on state.  Semantic attributes, not
+        # pairs: the same states must degrade to the monochrome hierarchy when
+        # color is off (--no-color or NO_COLOR).
         attr = None
         # Check for newly inserted flag first (hot-swapped devices should always show orange)
         if getattr(ns, 'newly_inserted', False):
             # Newly inserted device - orange/bright
             if ns.state in ('Mnt', 'iMnt', 'Blk', 'iBlk'):
                 # Dim the orange for mounted/blocked devices
-                attr = curses.color_pair(Theme.HOTSWAP) | curses.A_DIM
+                attr = appearance.semantic_attr(Theme.HOTSWAP) | curses.A_DIM
             else:
-                attr = curses.color_pair(Theme.HOTSWAP) | curses.A_BOLD
+                attr = appearance.semantic_attr(Theme.HOTSWAP) | curses.A_BOLD
         elif ns.state == 's':
             # Yellow/warning color for stopped/partial wipes (with bold for visibility)
-            attr = curses.color_pair(Theme.WARNING) | curses.A_BOLD
+            attr = appearance.semantic_attr(Theme.WARNING) | curses.A_BOLD
         elif ns.state == 'W' and getattr(ns, 'wiped_this_session', False):
             # Green/success color for completed wipes (done in THIS session only) - bold and bright
-            attr = curses.color_pair(Theme.SUCCESS) | curses.A_BOLD
+            attr = appearance.semantic_attr(Theme.SUCCESS) | curses.A_BOLD
         elif ns.state == 'W':
             # Green/success color for completed wipes before this session
-            attr = curses.color_pair(Theme.OLD_SUCCESS) | curses.A_BOLD
+            attr = appearance.semantic_attr(Theme.OLD_SUCCESS) | curses.A_BOLD
         elif ns.state.endswith('%') and ns.state not in ('100%',):
             # Active wipe in progress - bright cyan/blue with bold
-            attr = curses.color_pair(Theme.INFO) | curses.A_BOLD
+            attr = appearance.semantic_attr(Theme.INFO) | curses.A_BOLD
         elif ns.state == '^':
             # Newly inserted device (hot-swapped) - orange/bright
-            attr = curses.color_pair(Theme.HOTSWAP) | curses.A_BOLD
+            attr = appearance.semantic_attr(Theme.HOTSWAP) | curses.A_BOLD
         elif ns.state in ('Mnt', 'iMnt', 'Blk', 'iBlk'):
             # Dim mounted or blocked devices
             attr = curses.A_DIM
 
         # Override with red/danger color if verify failed
         if hasattr(ns, 'verify_failed_msg') and ns.verify_failed_msg:
-            attr = curses.color_pair(Theme.DANGER) | curses.A_BOLD
+            attr = appearance.semantic_attr(Theme.DANGER) | curses.A_BOLD
 
         # Make disk lines bold
         if ns.parent is None:

{dwipe-3.2.0 → dwipe-3.2.2}/dwipe/DiskWipe.py

@@ -29,6 +29,7 @@ from console_window import (
     Screen,
     ScreenStack,
     Theme,
+    appearance,
 )
 
 from .DeviceChangeMonitor import DeviceChangeMonitor
@@ -61,6 +62,52 @@ LOG_ST = 2
 THEME_ST = 3
 SCREEN_NAMES = ('MAIN', 'HELP', 'HISTORY', 'THEMES')
 
+#: dwipe's own pseudo-theme.  ``mono`` is not a palette: choosing it turns
+#: semantic color off for the whole process, exactly like ``--no-color``.  The
+#: library leaves pseudo-themes to the application (``console_window.appearance``
+#: names ``mono`` as its standing example), so dwipe owns the name and the
+#: switch behind it.
+MONO_THEME = 'mono'
+#: The entries the theme picker cycles through: every library palette, then the
+#: mono pseudo-theme, so ``t`` wraps from the last palette into mono.
+THEME_CHOICES = (*Theme.list_all(), MONO_THEME)
+
+
+def resolve_theme_selection(cli_theme=None, no_color=False,
+                            saved_theme='', environ=None):
+    """Resolve startup appearance into ``(selected, theme, colors)``.
+
+    ``selected`` is the value the theme option should hold: a palette name or
+    :data:`MONO_THEME`.  ``theme`` is the palette to install (``''`` keeps the
+    library default) and ``colors`` is the process-wide switch.
+
+    Precedence is the library's: ``--no-color``, an explicit ``--theme``, the
+    ``NO_COLOR`` convention, then the remembered choice.  A remembered ``mono``
+    is normalized to "no palette plus color off" before resolving.
+
+    A per-run ``--no-color``/``NO_COLOR`` keeps the remembered palette in
+    ``selected`` rather than replacing it with ``mono``.  The switch is not a
+    saved preference, so the next ordinary start has to come back to the same
+    palette; only choosing ``mono`` in the picker saves it.
+    """
+    saved_theme = saved_theme or ''
+    saved_colors = saved_theme != MONO_THEME
+    saved_palette = '' if saved_theme == MONO_THEME else saved_theme
+    theme, colors = appearance.resolve_appearance(
+        cli_theme=cli_theme,
+        no_color=no_color,
+        saved_theme=saved_palette,
+        saved_colors=saved_colors,
+        environ=environ,
+    )
+    if cli_theme:
+        selected = Theme.resolve(cli_theme)
+    elif not colors and saved_theme == MONO_THEME:
+        selected = MONO_THEME
+    else:
+        selected = Theme.resolve(theme or Theme.get_current())
+    return selected, theme, colors
+
 
 class DiskWipe:
     """Main application controller and UI manager"""
@@ -118,6 +165,47 @@ class DiskWipe:
             on_cancel=self._on_filter_cancel
         )
 
+    def _settle_appearance(self, environ=None):
+        """Apply the startup color decision to the process and the theme option.
+
+        The remembered theme, ``--theme``, ``--no-color`` and the ``NO_COLOR``
+        convention all meet here; see :func:`resolve_theme_selection` for the
+        precedence and for why a per-run ``--no-color`` does not overwrite the
+        remembered palette.
+        """
+        saved_theme = self.persistent_state.state.get('theme', '') or ''
+        selected, theme, colors = resolve_theme_selection(
+            cli_theme=getattr(self.opts, 'theme', None),
+            no_color=bool(getattr(self.opts, 'no_color', False)),
+            saved_theme=saved_theme,
+            environ=environ,
+        )
+        appearance.set_colors_enabled(colors)
+        if theme:
+            Theme.set(theme)
+        self.opts.theme = selected
+        return selected, colors
+
+    def apply_theme_choice(self, choice):
+        """Make a theme-picker *choice* live and remember it.
+
+        ``mono`` is the pseudo-theme: a color mode rather than a palette, so it
+        flips the process-wide switch and leaves the installed palette where it
+        was (the same way ``--no-color`` keeps ``--theme``).  Choosing a real
+        palette is a request for color, so it lifts the switch again.
+        """
+        self.opts.theme = choice
+        if choice == MONO_THEME:
+            appearance.set_colors_enabled(False)
+        else:
+            appearance.set_colors_enabled(True)
+            self.win.set_theme(choice)
+        # A picker choice is a preference, so write it now: quitting from the
+        # same frame must not lose it.
+        self.persistent_state.state['theme'] = choice
+        self.persistent_state.dirty = True
+        self.persistent_state.save()
+
     def _start_wipe(self):
         """Start the wipe job after confirmation"""
         if self.confirmation.identity and self.confirmation.identity in self.partitions:
@@ -513,8 +601,8 @@ class DiskWipe:
     def main_loop(self):
         """Main event loop"""
 
-        # Create screen instances
-        ThemeScreen = Theme.create_picker_screen(DiskWipeScreen)
+        # Create screen instances.  ThemeScreen is defined below with the other
+        # screens; it adds dwipe's ``mono`` entry to the library's palette list.
         self.screens = {
             MAIN_ST: MainScreen(self),
             HELP_ST: HelpScreen(self),
@@ -553,6 +641,10 @@ class DiskWipe:
             exit(1)
 
         self.win = ConsoleWindow(opts=win_opts)
+        # Color is one decision with two parts: which palette and whether to use
+        # it.  Settle both before the first draw so NO_COLOR works as well as
+        # the switches.
+        self._settle_appearance()
         # Initialize screen stack
         self.stack = ScreenStack(self.win, None, SCREEN_NAMES, self.screens)
 
@@ -585,9 +677,8 @@ class DiskWipe:
         spin.add_key('expand', 'e - expand history entry', genre='action', scope=LOG_ST)
         spin.add_key('copy', 'c - copy entry to clipboard', genre='action', scope=LOG_ST)
         spin.add_key('show_keys', 'K - show keys (demo mode)', genre='action')
-        # Load theme from persistent state
-        self.opts.theme = self.persistent_state.state.get('theme', '')
-        Theme.set(self.opts.theme)
+        # The appearance (and therefore opts.theme) was settled when the window
+        # was created, so the picker and the saved preference already agree.
         self.win.set_handled_keys(self.spin.keys)
 
         # Background device change monitor started above
@@ -687,6 +778,28 @@ class DiskWipeScreen(Screen):
         """ Show last key for demo"""
         self.app.win.set_demo_mode(enabled=None) # toggle it
 
+
+class ThemeScreen(Theme.create_picker_screen(DiskWipeScreen, cycle_key='t')):
+    """The library's theme picker plus dwipe's ``mono`` pseudo-theme.
+
+    ``mono`` is a color mode, not a palette, so the picker's swatches follow the
+    shared switch and show the monochrome role hierarchy while it is selected.
+    Overriding ``theme_label`` names that choice in the header instead of naming
+    the palette left installed underneath it.
+    """
+
+    def theme_label(self, theme_name):
+        if not appearance.colors_enabled():
+            return MONO_THEME
+        return super().theme_label(theme_name)
+
+    def spin_theme_ACTION(self):
+        app = self.app
+        current = getattr(app.opts, 'theme', None)
+        index = THEME_CHOICES.index(current) if current in THEME_CHOICES else -1
+        app.apply_theme_choice(THEME_CHOICES[(index + 1) % len(THEME_CHOICES)])
+
+
 class MainScreen(DiskWipeScreen):
     """Main device list screen"""
 
@@ -1064,14 +1177,15 @@ class MainScreen(DiskWipeScreen):
                 msg = ' ' * 5 + msg
 
                 # Add confirmation message base as DECOR (non-pickable)
-                app.win.add_body(msg, attr=cs.color_pair(Theme.DANGER) | cs.A_BOLD,
+                app.win.add_body(msg,
+                               attr=appearance.semantic_attr(Theme.DANGER) | cs.A_BOLD,
                                context=Context(genre='DECOR'))
 
                 # Add input or hint on same line
                 if app.confirmation.input_buffer:
                     # Show current input with cursor
                     app.win.add_body(app.confirmation.input_buffer + '_',
-                                   attr=cs.color_pair(Theme.DANGER) | cs.A_BOLD,
+                                   attr=appearance.semantic_attr(Theme.DANGER) | cs.A_BOLD,
                                    resume=True)
                 else:
                     # Show hint in dimmed italic
@@ -1402,9 +1516,13 @@ class HelpScreen(DiskWipeScreen):
             f'--slowdown-stop: {opts.slowdown_stop:<{wid}} Stop if disk slows',
             f'--stall-timeout: {opts.stall_timeout:<{wid}} Stall timeout in sec',
             f'--auto-block: .  {"on" if getattr(opts, "auto_block_containers", True) else "off":<{wid}} Auto-block containers',
+            f'--theme: . . . .  {(getattr(opts, "theme", None) or "-"):<{wid}} Color palette (or mono)',
+            f'--no-color: . . . {"on" if getattr(opts, "no_color", False) else "off":<{wid}} Draw without color',
         ]
         for opt in cli_options:
             app.win.add_body(opt, attr=cs.A_DIM)
+        app.win.add_body('Theme "mono" (last in the picker) turns color off; '
+                         'NO_COLOR does the same at startup.', attr=cs.A_DIM)
 
 
 class HistoryScreen(DiskWipeScreen):
@@ -1547,13 +1665,14 @@ class HistoryScreen(DiskWipeScreen):
             # Add deep match indicator if this entry matched only in JSON
             deep_indicator = " *" if timestamp in self.search_matches else ""
 
-            # Choose color based on log level
+            # Choose color based on log level.  Semantic attributes, not pairs:
+            # the same rows must degrade to bold/reverse when color is off.
             if level == 'ERR':
-                level_attr = cs.color_pair(Theme.ERROR) | cs.A_BOLD
+                level_attr = appearance.semantic_attr(Theme.ERROR) | cs.A_BOLD
             elif level in ('WIPE_STOPPED', 'VERIFY_STOPPED'):
-                level_attr = cs.color_pair(Theme.WARNING) | cs.A_BOLD
+                level_attr = appearance.semantic_attr(Theme.WARNING) | cs.A_BOLD
             elif level in ('WIPE_COMPLETE', 'VERIFY_COMPLETE'):
-                level_attr = cs.color_pair(Theme.SUCCESS) | cs.A_BOLD
+                level_attr = appearance.semantic_attr(Theme.SUCCESS) | cs.A_BOLD
             else:
                 level_attr = cs.A_BOLD
 

{dwipe-3.2.0 → dwipe-3.2.2}/dwipe/README-DEV.md

@@ -14,7 +14,8 @@ to the modules it describes; every path below is therefore relative to
 | --- | --- |
 | [`dwipe/__init__.py`](../dwipe/__init__.py) | `__version__`, and nothing else. The build backend reads it, `dwipe --version` prints it, `bless` reads the line without importing the package. |
 | [`pyproject.toml`](../pyproject.toml) | Name, description, keywords, `requires-python`, runtime dependencies, the SPDX `license` and `license-files`, the `test`/`dev` extras, and the pytest, coverage and ruff configuration. |
-| [`bless`](../bless) | The release gate. Copied verbatim from `pwr-tray`/`my-snaps`; it holds no copy of this project's identity. |
+| [`bless`](../bless) | The release gate. Emitted from `~/Projects/blessd/bless` by that repository's `build.py` and never edited here; it holds no copy of this project's identity. |
+| `~/Projects/blessd/docs/release-strategy.md` | The shared rationale behind the gate: why the upload is local and irreversible, and how the branch model follows from that. |
 | [`tests/inspect_dist.py`](../tests/inspect_dist.py) | The distribution inspector. `bless` refuses to upload a wheel and sdist it has not inspected with this file. |
 | [`runner`](../runner) | Runs the tree from source (`python -m dwipe.main`) for debugging. |
 | [`linter`](../linter) | The advisory pylint run for one file, with the project root on `sys.path`. |
@@ -82,7 +83,7 @@ again. Enter, `quit` or Ctrl-C stops with nothing tagged, uploaded or pushed.
 **Stages, in order**
 
 1. **preflight** -- clean tree, the `vX.Y.Z` tag absent, `twine>=7` and
-   `packaging>=26` present, and `main`/`dev` both local and on `origin`.
+   `packaging>=26` present, and `python -m build` answering.
 2. **index check** -- refuses if `__version__` is already on PyPI, printing
    every published version, before anything is built or uploaded.
 3. **gates** -- the three commands above.
@@ -170,17 +171,31 @@ the tagged commit. Everything else about the release is one of the stages above.
 
 ## Notes on this adoption
 
-* [`bless`](../bless) was copied byte-for-byte from `../pwr-tray/bless` (SHA-256
-  `4f756337840b0619fbf6f077b00d4bb3fb9aee95ff18bbeb6a0521d39d52131e`) and is
-  not edited here: reuse is "copy verbatim", and any later upstream change is
-  adopted as a new copy.
-* `dwipe` needed four things `pwr-tray` already had: one version location
-  (`dynamic = ["version"]`), an inspector, the `dev` extra with `build`,
-  `twine>=7` and `packaging>=26`, and a console script that answers
-  `--version`. The metadata was moved to the PEP 639 `license` expression and
-  `license-files` at the same time, which is why the build backend floor is
-  `flit_core>=3.12`.
+* [`bless`](../bless) is emitted from `~/Projects/blessd/bless` by that
+  repository's `build.py`; it is never edited here. The policy the gate
+  enforces -- the branch plan, the prompt, the index check, the build, the
+  emitter -- and the tests of that policy live in `~/Projects/blessd`, once.
+  This tree carries the build with SHA-256
+  `3ef60e9e806ca58a3d900dd6622bb8be0052210da1ef26f9918bf0a1deb1e3b2`
+  (55222 bytes), which
+
+      python3 ~/Projects/blessd/build.py --into . --force
+
+  reproduces byte for byte, so `cmp ~/Projects/blessd/bless bless` is silent.
+  A later gate is adopted the same way, as a new emission rather than an edit.
+* `dwipe` had to provide what the gate reads instead of being told it: one
+  version location (`dynamic = ["version"]`, the line in
+  [`dwipe/__init__.py`](../dwipe/__init__.py)), an inspector
+  ([`tests/inspect_dist.py`](../tests/inspect_dist.py)), a console script that
+  answers `--version` (`dwipe`), the `dev` extra with `build`, `twine>=7` and
+  `packaging>=26`, and the `main`/`dev` branch pair -- the gate's default
+  model, so no `[tool.bless]` table is needed. The metadata was moved to the
+  PEP 639 `license` expression and `license-files` at the same time, which is
+  why the build backend floor is `flit_core>=3.12`.
 * The ruff rule set was added with the gate, so the whole tree was brought to a
-  clean `ruff check .` once. [`tests/test_bless.py`](../tests/test_bless.py) and
-  [`tests/test_repo_hygiene.py`](../tests/test_repo_hygiene.py) keep the gate,
-  the inspector and the single version location from drifting.
+  clean `ruff check .` once. [`tests/test_bless.py`](../tests/test_bless.py) now
+  covers only this tree's identity -- the name, module, console script and
+  branch model `bless` derives from `pyproject.toml`, the version reported by
+  `dwipe --version` -- and the inspector; the gate's policy tests are part of
+  the shared repository. [`tests/test_repo_hygiene.py`](../tests/test_repo_hygiene.py)
+  keeps the gate, the dev extra and the single version location from drifting.

{dwipe-3.2.0 → dwipe-3.2.2}/dwipe/Utils.py

@@ -71,7 +71,14 @@ class Utils:
         """Rerun using the module name"""
         if os.geteuid() != 0:  # Re-run the script with sudo
             os.chdir(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-            vp = ['sudo', sys.executable, '-m', module_name] + sys.argv[1:]
+            args = sys.argv[1:]
+            # sudo resets the environment by default, so an exported NO_COLOR
+            # would not reach the process that actually draws the UI.  Carry it
+            # across as the equivalent switch; --no-color already wins over
+            # --theme, matching the no-color.org convention.
+            if os.environ.get('NO_COLOR') and '--no-color' not in args:
+                args = ['--no-color', *args]
+            vp = ['sudo', sys.executable, '-m', module_name] + args
             os.execvp('sudo', vp)
 
     @staticmethod

{dwipe-3.2.0 → dwipe-3.2.2}/dwipe/__init__.py

@@ -7,4 +7,4 @@ upload, ``dwipe --version`` prints it, and ``tests/inspect_dist.py`` checks the
 built artifacts against it.
 """
 
-__version__ = "3.2.0"
+__version__ = "3.2.2"

{dwipe-3.2.0 → dwipe-3.2.2}/dwipe/main.py

@@ -12,6 +12,8 @@ import os
 import sys
 import traceback
 
+from console_window import cli
+
 from . import __version__
 from .DiskWipe import DiskWipe
 from .PersistentState import PersistentState
@@ -55,6 +57,11 @@ def main():
     parser.add_argument('--auto-block-containers', choices=['on', 'off'],
                         default='on' if persist.state['auto_block_containers'] else 'off',
                         help='auto-block LUKS/LVM/RAID/swap containers on first sight (on/off)')
+    # --theme / --no-color come from the library, so the appearance switch and
+    # palette live in its one process-wide implementation rather than a copy
+    # here.  --no-color is a per-run switch; the remembered choice is settled
+    # later by DiskWipe, alongside NO_COLOR.
+    cli.add_display_arguments(parser, prog='dwipe')
     opts = parser.parse_args()
 
     # Convert string booleans to actual booleans
@@ -67,6 +74,10 @@ def main():
             # Re-run the script with sudo needed and opted
             Utils.rerun_module_as_root('dwipe.main')
 
+        # Apply --ascii/--glyphs/--theme/--no-color once, in the process that
+        # will draw the UI: a sudo re-run starts over from the same argv.
+        cli.apply_display_arguments(opts, prog='dwipe')
+
         prereqs = Prereqs(verbose=True)
         # blkid for filesystem detection; hdparm and nvme for firmware wipes
         prereqs.check_all(['blkid', 'hdparm', 'nvme'])

{dwipe-3.2.0 → dwipe-3.2.2}/pyproject.toml

@@ -79,15 +79,18 @@ classifiers = [
     "Operating System :: POSIX :: Linux"
 ]
 dependencies = [
-    'console-window == 2.1.3',
+    'console-window == 2.2.2',
 ]
 
 [project.optional-dependencies]
 # The minimum a contributor needs to run the suite (what CI installs on every
-# supported Python).
+# supported Python).  `tomli` only appears below 3.11, where the stdlib has no
+# `tomllib`, yet tests and `bless` read pyproject.toml on every interpreter
+# `requires-python` allows.
 test = [
     'pytest >= 7.0',
     'pytest-cov >= 4.0',
+    'tomli >= 2.0; python_version < "3.11"',
 ]
 # The release toolchain.  `./bless` refuses to start unless `twine` and
 # `packaging` meet its own floors (`twine>=7`, `packaging>=26`), so declaring
@@ -100,6 +103,7 @@ dev = [
     'build >= 1.2',
     'twine >= 7',
     'packaging >= 26',
+    'tomli >= 2.0; python_version < "3.11"',
 ]
 
 [project.urls]