redwood-view 0.1.0__tar.gz

redwood_view-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

redwood_view-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: redwood-view
+Version: 0.1.0
+Summary: Console disk usage viewer: a treemap with an ncdu-style folder list
+Keywords: disk usage,treemap,ncdu,diskonaut,sequoiaview,curses,tui
+Author: Mykhailo Odintsov
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Filesystems
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/Templarrr/redwood_view
+Project-URL: Source, https://github.com/Templarrr/redwood_view
+Project-URL: Issues, https://github.com/Templarrr/redwood_view/issues
+Description-Content-Type: text/markdown
+
+# Redwood View
+
+A console disk usage viewer in the spirit of SequoiaView: a treemap fills most of the
+window, and an ncdu-style folder list on the right is used for navigation. The selected
+entry is highlighted on the treemap, and blocks are coloured by file type so you can see
+not only which folder is big but what is filling it.
+
+Pure Python standard library (`curses`), so it works on any server you can `ssh` into.
+
+![Home folder overview with the file type legend open](https://raw.githubusercontent.com/Templarrr/redwood_view/main/docs/screenshots/overview.png)
+
+Inside a folder: nested blocks of the same type are told apart by a dotted texture. Files too
+small to get a cell of their own are merged into one block labelled "+N small items",
+which keeps folders with tens of thousands of files quick to draw.
+
+![Videos folder](https://raw.githubusercontent.com/Templarrr/redwood_view/main/docs/screenshots/videos.png)
+
+Without colour (`--no-color`, or a terminal that has none) each file type gets its own
+character instead.
+
+![Monochrome mode](https://raw.githubusercontent.com/Templarrr/redwood_view/main/docs/screenshots/nocolor.png)
+
+## Install
+
+```sh
+uv tool install redwood-view
+```
+
+or `pipx install redwood-view`. Either puts the `redwood` command on your `PATH`.
+
+To get the latest unreleased code instead, install from the repo:
+`uv tool install git+https://github.com/Templarrr/redwood_view`, or from a checkout,
+`uv tool install .`
+
+## Update
+
+```sh
+uv tool upgrade redwood-view   # or: pipx upgrade redwood-view
+```
+
+If you installed from the repo, the same command fetches the latest commit, even when the
+version number hasn't changed. A pinned commit or tag (`...redwood_view@<ref>`) stays
+pinned, so install again without it instead:
+
+```sh
+uv tool install --reinstall git+https://github.com/Templarrr/redwood_view
+```
+
+From a checkout, `git pull` and then `uv tool install --reinstall .`
+
+## Use
+
+```sh
+redwood /          # scan everything
+redwood ~/Videos   # scan one folder
+redwood -x /       # stay on the root filesystem (skip /proc, mounted drives, ...)
+```
+
+Folders that can't be read are skipped and marked with `!` in the list.
+
+| Key                    | Action                    |
+|------------------------|---------------------------|
+| Up / Down, `j` / `k`   | move selection            |
+| PgUp / PgDn, Home / End| jump                      |
+| Right / Enter          | open folder               |
+| Left / Backspace       | go to parent              |
+| `l`                    | toggle file type legend   |
+| `q`                    | quit                      |
+
+Letter keys work by position on Russian, Ukrainian, Belarusian and Greek layouts too,
+so `й` acts as `q` without switching to English.
+
+Options: `--apparent-size` uses file sizes instead of disk usage, `--no-color` draws
+file types with characters instead of colours.
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+uv run ruff check . && uv run ruff format --check .
+```
+
+### Releasing
+
+Bump the version with `uv version --bump minor` (or `patch`, `major`), commit, then push a
+matching tag:
+
+```sh
+git tag v0.2.0
+git push origin v0.2.0
+```
+
+The release workflow checks that the tag matches the version in `pyproject.toml`, runs
+the tests, builds the package and publishes it to PyPI.

redwood_view-0.1.0/README.md

@@ -0,0 +1,95 @@
+# Redwood View
+
+A console disk usage viewer in the spirit of SequoiaView: a treemap fills most of the
+window, and an ncdu-style folder list on the right is used for navigation. The selected
+entry is highlighted on the treemap, and blocks are coloured by file type so you can see
+not only which folder is big but what is filling it.
+
+Pure Python standard library (`curses`), so it works on any server you can `ssh` into.
+
+![Home folder overview with the file type legend open](https://raw.githubusercontent.com/Templarrr/redwood_view/main/docs/screenshots/overview.png)
+
+Inside a folder: nested blocks of the same type are told apart by a dotted texture. Files too
+small to get a cell of their own are merged into one block labelled "+N small items",
+which keeps folders with tens of thousands of files quick to draw.
+
+![Videos folder](https://raw.githubusercontent.com/Templarrr/redwood_view/main/docs/screenshots/videos.png)
+
+Without colour (`--no-color`, or a terminal that has none) each file type gets its own
+character instead.
+
+![Monochrome mode](https://raw.githubusercontent.com/Templarrr/redwood_view/main/docs/screenshots/nocolor.png)
+
+## Install
+
+```sh
+uv tool install redwood-view
+```
+
+or `pipx install redwood-view`. Either puts the `redwood` command on your `PATH`.
+
+To get the latest unreleased code instead, install from the repo:
+`uv tool install git+https://github.com/Templarrr/redwood_view`, or from a checkout,
+`uv tool install .`
+
+## Update
+
+```sh
+uv tool upgrade redwood-view   # or: pipx upgrade redwood-view
+```
+
+If you installed from the repo, the same command fetches the latest commit, even when the
+version number hasn't changed. A pinned commit or tag (`...redwood_view@<ref>`) stays
+pinned, so install again without it instead:
+
+```sh
+uv tool install --reinstall git+https://github.com/Templarrr/redwood_view
+```
+
+From a checkout, `git pull` and then `uv tool install --reinstall .`
+
+## Use
+
+```sh
+redwood /          # scan everything
+redwood ~/Videos   # scan one folder
+redwood -x /       # stay on the root filesystem (skip /proc, mounted drives, ...)
+```
+
+Folders that can't be read are skipped and marked with `!` in the list.
+
+| Key                    | Action                    |
+|------------------------|---------------------------|
+| Up / Down, `j` / `k`   | move selection            |
+| PgUp / PgDn, Home / End| jump                      |
+| Right / Enter          | open folder               |
+| Left / Backspace       | go to parent              |
+| `l`                    | toggle file type legend   |
+| `q`                    | quit                      |
+
+Letter keys work by position on Russian, Ukrainian, Belarusian and Greek layouts too,
+so `й` acts as `q` without switching to English.
+
+Options: `--apparent-size` uses file sizes instead of disk usage, `--no-color` draws
+file types with characters instead of colours.
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+uv run ruff check . && uv run ruff format --check .
+```
+
+### Releasing
+
+Bump the version with `uv version --bump minor` (or `patch`, `major`), commit, then push a
+matching tag:
+
+```sh
+git tag v0.2.0
+git push origin v0.2.0
+```
+
+The release workflow checks that the tag matches the version in `pyproject.toml`, runs
+the tests, builds the package and publishes it to PyPI.

redwood_view-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[project]
+name = "redwood-view"
+version = "0.1.0"
+description = "Console disk usage viewer: a treemap with an ncdu-style folder list"
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+dependencies = []
+keywords = [
+    "disk usage",
+    "treemap",
+    "ncdu",
+    "diskonaut",
+    "sequoiaview",
+    "curses",
+    "tui",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console :: Curses",
+    "Intended Audience :: System Administrators",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: System :: Filesystems",
+    "Topic :: Utilities",
+]
+
+[[project.authors]]
+name = "Mykhailo Odintsov"
+
+[project.urls]
+Homepage = "https://github.com/Templarrr/redwood_view"
+Source = "https://github.com/Templarrr/redwood_view"
+Issues = "https://github.com/Templarrr/redwood_view/issues"
+
+[project.scripts]
+redwood = "redwood.cli:main"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "ruff>=0.6",
+]
+
+[build-system]
+requires = ["uv_build>=0.8,<0.12"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "redwood"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "W",
+    "I",
+    "B",
+    "UP",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

redwood_view-0.1.0/pyproject.toml.orig

@@ -0,0 +1,56 @@
+[project]
+name = "redwood-view"
+version = "0.1.0"
+description = "Console disk usage viewer: a treemap with an ncdu-style folder list"
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{ name = "Mykhailo Odintsov" }]
+requires-python = ">=3.10"
+dependencies = []
+keywords = ["disk usage", "treemap", "ncdu", "diskonaut", "sequoiaview", "curses", "tui"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console :: Curses",
+    "Intended Audience :: System Administrators",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: System :: Filesystems",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/Templarrr/redwood_view"
+Source = "https://github.com/Templarrr/redwood_view"
+Issues = "https://github.com/Templarrr/redwood_view/issues"
+
+[project.scripts]
+redwood = "redwood.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8", "ruff>=0.6"]
+
+[build-system]
+requires = ["uv_build>=0.8,<0.12"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "redwood"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

redwood_view-0.1.0/src/redwood/__main__.py

@@ -0,0 +1,3 @@
+from redwood.cli import main
+
+main()

redwood_view-0.1.0/src/redwood/browser.py

@@ -0,0 +1,36 @@
+from redwood.scanner import Node
+
+
+class Browser:
+    def __init__(self, root: Node):
+        self.root = root
+        self.current = root
+        self.index = 0
+
+    @property
+    def entries(self) -> list[Node]:
+        return self.current.children
+
+    @property
+    def selected(self) -> Node | None:
+        return self.entries[self.index] if self.entries else None
+
+    def move(self, delta: int) -> None:
+        if self.entries:
+            self.index = max(0, min(len(self.entries) - 1, self.index + delta))
+
+    def move_to(self, index: int) -> None:
+        self.move(index - self.index)
+
+    def enter(self) -> None:
+        node = self.selected
+        if node is not None and node.is_dir:
+            self.current = node
+            self.index = 0
+
+    def leave(self) -> None:
+        if self.current.parent is None:
+            return
+        came_from = self.current
+        self.current = came_from.parent
+        self.index = self.current.children.index(came_from)

redwood_view-0.1.0/src/redwood/categories.py

@@ -0,0 +1,60 @@
+import os
+import stat
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Category:
+    name: str
+    color: int  # ANSI colour index, same numbering as curses.COLOR_*
+    char: str  # fill used when the terminal has no colour
+
+
+_EXTENSIONS = {
+    "video": "mp4 mkv avi mov wmv flv webm m4v mpg mpeg vob 3gp m2ts mts",
+    "audio": "mp3 flac wav ogg oga m4a aac wma opus aiff ape mid midi",
+    "image": "jpg jpeg png gif bmp tif tiff webp svg heic heif raw cr2 nef arw dng psd xcf ico",
+    "archive": (
+        "zip tar gz tgz bz2 xz zst 7z rar lz4 lzma iso img dmg deb rpm jar whl apk "
+        "snap squashfs qcow2 vmdk vdi vhd vhdx"
+    ),
+    "document": (
+        "pdf doc docx xls xlsx ppt pptx odt ods odp rtf txt md rst epub djvu csv tex "
+        "html htm xml json yaml yml toml log"
+    ),
+    "code": (
+        "py pyi c h cc cpp hpp cxx js mjs ts tsx jsx java kt scala go rs rb php pl sh bash "
+        "zsh lua cs swift sql css scss vue ipynb el hs ml"
+    ),
+    "binary": "so dll exe bin o a lib dylib pyc class ko wasm dat db sqlite pack idx",
+}
+
+CATEGORIES = [
+    Category("video", 1, "#"),
+    Category("audio", 5, "~"),
+    Category("image", 3, "%"),
+    Category("archive", 4, "="),
+    Category("document", 6, "+"),
+    Category("code", 2, "*"),
+    Category("binary", 7, "@"),
+    Category("other", 0, "."),
+]
+OTHER = len(CATEGORIES) - 1
+BINARY = next(i for i, c in enumerate(CATEGORIES) if c.name == "binary")
+
+_BY_EXT = {
+    ext: next(i for i, c in enumerate(CATEGORIES) if c.name == name)
+    for name, exts in _EXTENSIONS.items()
+    for ext in exts.split()
+}
+
+
+def categorize(name: str, mode: int = 0) -> int:
+    lower = name.lower()
+    ext = os.path.splitext(lower)[1][1:]
+    if ext in _BY_EXT:
+        return _BY_EXT[ext]
+    # Versioned shared libraries (libfoo.so.6) and executables like python3.13.
+    if ".so." in lower or (stat.S_ISREG(mode) and mode & 0o111):
+        return BINARY
+    return OTHER

redwood_view-0.1.0/src/redwood/cli.py

@@ -0,0 +1,64 @@
+import argparse
+import os
+import sys
+import time
+
+from redwood.humanize import human_size
+from redwood.scanner import scan
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="redwood", description="Show disk usage as a treemap with a navigable folder list."
+    )
+    parser.add_argument("path", nargs="?", default=".", help="folder to scan (default: .)")
+    parser.add_argument(
+        "-x", "--one-file-system", action="store_true", help="don't cross filesystem boundaries"
+    )
+    parser.add_argument(
+        "--apparent-size", action="store_true", help="use file sizes instead of disk usage"
+    )
+    parser.add_argument("--no-color", action="store_true", help="draw with characters only")
+    return parser.parse_args(argv)
+
+
+class _Progress:
+    def __init__(self):
+        self.last = 0.0
+
+    def __call__(self, count: int, path: str) -> None:
+        now = time.monotonic()
+        if now - self.last < 0.1:
+            return
+        self.last = now
+        width = os.get_terminal_size(sys.stderr.fileno()).columns if sys.stderr.isatty() else 80
+        line = f"Scanning: {count} items  {path}"
+        sys.stderr.write("\r" + line[: width - 1].ljust(width - 1))
+        sys.stderr.flush()
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = parse_args(argv)
+    if not os.path.isdir(args.path):
+        sys.exit(f"redwood: not a directory: {args.path}")
+
+    progress = _Progress() if sys.stderr.isatty() else None
+    try:
+        root = scan(args.path, args.one_file_system, args.apparent_size, progress)
+    except KeyboardInterrupt:
+        sys.exit(130)
+    except OSError as e:
+        sys.exit(f"redwood: {e}")
+    if progress:
+        sys.stderr.write("\r\033[K")
+
+    if not sys.stdout.isatty():
+        print(f"{human_size(root.size)}\t{root.path}")
+        return
+
+    from redwood.ui import run
+
+    try:
+        run(root, color=not args.no_color)
+    except KeyboardInterrupt:
+        pass

redwood_view-0.1.0/src/redwood/humanize.py

@@ -0,0 +1,12 @@
+_UNITS = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]
+
+
+def human_size(size: int) -> str:
+    value = float(size)
+    for unit in _UNITS:
+        if value < 1024 or unit == _UNITS[-1]:
+            break
+        value /= 1024
+    if unit == "B":
+        return f"{int(value)} B"
+    return f"{value:.1f} {unit}"

redwood_view-0.1.0/src/redwood/keys.py

@@ -0,0 +1,38 @@
+import curses
+
+# Terminals report characters, not physical keys, so letters typed on a non-Latin
+# layout are translated back to the US QWERTY key in the same position.
+_QWERTY = "`qwertyuiop[]asdfghjkl;'zxcvbnm,."
+_LAYOUTS = {
+    "russian": "ёйцукенгшщзхъфывапролджэячсмитьбю",
+    "ukrainian": "'йцукенгшщзхїфівапролджєячсмитьбю",
+    "belarusian": "ёйцукенгшўзх'фывапролджэячсмітьбю",
+    "greek": "`;ςερτυθιοπ[]ασδφγηξκλ΄'ζχψωβνμ,.",
+}
+
+
+def _build() -> dict[str, str]:
+    table: dict[str, str] = {}
+    for chars in _LAYOUTS.values():
+        for char, latin in zip(chars, _QWERTY, strict=True):
+            if char.isascii():
+                continue
+            table.setdefault(char, latin)
+            # Skips final sigma, whose upper case belongs to σ.
+            if char.upper().lower() == char:
+                table.setdefault(char.upper(), latin.upper())
+    return table
+
+
+_TO_LATIN = _build()
+
+
+def normalize(key: int | str) -> int:
+    """Turn a get_wch() result into a getch()-style code, mapping layouts to QWERTY."""
+    if isinstance(key, int):
+        return key
+    return ord(_TO_LATIN.get(key, key))
+
+
+def read_key(screen: curses.window) -> int:
+    return normalize(screen.get_wch())

redwood_view-0.1.0/src/redwood/scanner.py

@@ -0,0 +1,111 @@
+import os
+import stat
+from collections.abc import Callable
+
+from redwood.categories import CATEGORIES, OTHER, categorize
+
+
+class Node:
+    __slots__ = ("name", "parent", "size", "children", "category", "cat_sizes", "error")
+
+    def __init__(self, name: str, parent: "Node | None", size: int = 0, category: int = OTHER):
+        self.name = name
+        self.parent = parent
+        self.size = size
+        self.category = category
+        self.children: list[Node] | None = None
+        self.cat_sizes: list[int] | None = None
+        self.error = False
+
+    @property
+    def is_dir(self) -> bool:
+        return self.children is not None
+
+    @property
+    def path(self) -> str:
+        if self.parent is None:
+            return self.name
+        return os.path.join(self.parent.path, self.name)
+
+    def __repr__(self) -> str:
+        return f"Node({self.path!r}, {self.size})"
+
+
+def _dir_node(name: str, parent: Node | None) -> Node:
+    node = Node(name, parent)
+    node.children = []
+    node.cat_sizes = [0] * len(CATEGORIES)
+    return node
+
+
+def scan(
+    root: str,
+    one_file_system: bool = False,
+    apparent_size: bool = False,
+    progress: Callable[[int, str], None] | None = None,
+) -> Node:
+    root = os.path.abspath(root)
+    root_dev = os.stat(root).st_dev
+    root_node = _dir_node(root, None)
+    # Iterative walk so very deep trees can't hit the recursion limit.
+    stack = [(root_node, root)]
+    visited: list[Node] = []
+    seen_inodes: set[tuple[int, int]] = set()
+    count = 0
+
+    while stack:
+        node, path = stack.pop()
+        visited.append(node)
+        try:
+            with os.scandir(path) as it:
+                entries = list(it)
+        except OSError:
+            node.error = True
+            continue
+
+        for entry in entries:
+            try:
+                st = entry.stat(follow_symlinks=False)
+            except OSError:
+                continue
+            count += 1
+            if stat.S_ISDIR(st.st_mode):
+                if one_file_system and st.st_dev != root_dev:
+                    continue
+                child = _dir_node(entry.name, node)
+                stack.append((child, entry.path))
+            else:
+                # Hard links share storage, so only count the first one we meet.
+                if st.st_nlink > 1:
+                    key = (st.st_dev, st.st_ino)
+                    if key in seen_inodes:
+                        continue
+                    seen_inodes.add(key)
+                child = Node(
+                    entry.name, node, _size(st, apparent_size), categorize(entry.name, st.st_mode)
+                )
+            node.children.append(child)
+        if progress:
+            progress(count, path)
+
+    # Parents were visited before their children, so reversing gives a bottom-up order.
+    for node in reversed(visited):
+        node.children.sort(key=lambda n: n.size, reverse=True)
+        for child in node.children:
+            node.size += child.size
+            if child.is_dir:
+                for i, size in enumerate(child.cat_sizes):
+                    node.cat_sizes[i] += size
+            else:
+                node.cat_sizes[child.category] += child.size
+        if node.size:
+            node.category = max(range(len(CATEGORIES)), key=node.cat_sizes.__getitem__)
+    return root_node
+
+
+def _size(st: os.stat_result, apparent_size: bool) -> int:
+    blocks = getattr(st, "st_blocks", None)
+    if apparent_size or blocks is None:
+        return st.st_size
+    # Allocated size, like du/ncdu; also keeps sparse files such as /proc/kcore at their real cost.
+    return blocks * 512

redwood_view-0.1.0/src/redwood/treemap.py

@@ -0,0 +1,98 @@
+from typing import NamedTuple
+
+# Terminal cells are roughly twice as tall as they are wide.
+CELL_ASPECT = 2.0
+
+
+class Rect(NamedTuple):
+    x: int
+    y: int
+    w: int
+    h: int
+
+
+def squarify(
+    sizes: list[float], x: float, y: float, w: float, h: float
+) -> list[tuple[float, float, float, float]]:
+    """Squarified treemap (Bruls et al.); `sizes` must be sorted in descending order."""
+    total = sum(sizes)
+    if total <= 0 or w <= 0 or h <= 0:
+        return [(x, y, 0.0, 0.0)] * len(sizes)
+    scale = w * h / total
+    areas = [s * scale for s in sizes]
+    rects = []
+    i = 0
+    while i < len(areas):
+        if areas[i] <= 0 or w <= 0 or h <= 0:
+            rects.extend([(x, y, 0.0, 0.0)] * (len(areas) - i))
+            break
+        short = min(w, h)
+        # Sizes are sorted, so the row's largest area is its first and the smallest its last;
+        # that keeps each aspect-ratio check O(1) instead of rescanning the row.
+        row = [areas[i]]
+        row_sum = areas[i]
+        i += 1
+        while i < len(areas) and areas[i] > 0:
+            grown = row_sum + areas[i]
+            if _worst(grown, row[0], areas[i], short) > _worst(row_sum, row[0], row[-1], short):
+                break
+            row.append(areas[i])
+            row_sum = grown
+            i += 1
+        if w >= h:
+            col_w = row_sum / h
+            cy = y
+            for area in row:
+                rects.append((x, cy, col_w, area / col_w))
+                cy += area / col_w
+            x += col_w
+            w -= col_w
+        else:
+            row_h = row_sum / w
+            cx = x
+            for area in row:
+                rects.append((cx, y, area / row_h, row_h))
+                cx += area / row_h
+            y += row_h
+            h -= row_h
+    return rects
+
+
+def _worst(total: float, largest: float, smallest: float, short: float) -> float:
+    side2 = short * short
+    total2 = total * total
+    return max(side2 * largest / total2, total2 / (side2 * smallest))
+
+
+def layout(sizes: list[float], area: Rect) -> tuple[list[Rect], Rect]:
+    """Lay sizes out on the character grid.
+
+    Items too small to get a cell of their own are merged into one block, so huge folders cost
+    no more than the screen can show. Returns rects for the leading, visible items (possibly
+    fewer than `sizes`) and the merged block's rect, which is empty when nothing was merged.
+    """
+    total = sum(sizes)
+    cells = area.w * area.h
+    if total <= 0 or cells <= 0:
+        return [Rect(area.x, area.y, 0, 0)] * len(sizes), Rect(area.x, area.y, 0, 0)
+    shown = 0
+    while shown < len(sizes) and sizes[shown] * cells >= total:
+        shown += 1
+    if shown == len(sizes):
+        return _grid(sizes, area), Rect(area.x, area.y, 0, 0)
+    rest = total - sum(sizes[:shown])
+    # Squarify wants descending sizes, so the merged block goes in at its sorted position.
+    pos = next((i for i in range(shown) if sizes[i] < rest), shown)
+    rects = _grid(sizes[:pos] + [rest] + sizes[pos:shown], area)
+    return rects, rects.pop(pos)
+
+
+def _grid(sizes: list[float], area: Rect) -> list[Rect]:
+    rects = squarify(sizes, 0.0, 0.0, float(area.w), area.h * CELL_ASPECT)
+    result = []
+    # Rounding shared edges the same way keeps neighbours from overlapping or leaving gaps.
+    for fx, fy, fw, fh in rects:
+        x0, x1 = round(fx), round(fx + fw)
+        y0, y1 = round(fy / CELL_ASPECT), round((fy + fh) / CELL_ASPECT)
+        result.append(Rect(area.x + x0, area.y + y0, max(0, x1 - x0), max(0, y1 - y0)))
+    return result

redwood_view-0.1.0/src/redwood/ui.py

@@ -0,0 +1,307 @@
+import curses
+import locale
+
+from redwood.browser import Browser
+from redwood.categories import CATEGORIES, OTHER
+from redwood.humanize import human_size
+from redwood.keys import read_key
+from redwood.scanner import Node
+from redwood.treemap import Rect, layout
+
+HELP = "↑↓ move  →/Enter open  ←/Bksp up  l legend  q quit"
+HELP_ASCII = "Up/Down move  Right/Enter open  Left/Bksp up  l legend  q quit"
+BAR_WIDTH = 8
+
+_HIGHLIGHT_PAIR = len(CATEGORIES) + 1
+
+
+class Styles:
+    def __init__(self, color: bool):
+        self.color = color and curses.has_colors()
+        if self.color:
+            curses.start_color()
+            try:
+                curses.use_default_colors()
+                default_bg = -1
+            except curses.error:
+                default_bg = curses.COLOR_BLACK
+            for i, cat in enumerate(CATEGORIES):
+                if i == OTHER:
+                    curses.init_pair(i + 1, curses.COLOR_WHITE, default_bg)
+                else:
+                    curses.init_pair(i + 1, curses.COLOR_BLACK, cat.color)
+            curses.init_pair(_HIGHLIGHT_PAIR, curses.COLOR_YELLOW, default_bg)
+            self.highlight = curses.color_pair(_HIGHLIGHT_PAIR) | curses.A_BOLD | curses.A_REVERSE
+        else:
+            self.highlight = curses.A_BOLD | curses.A_REVERSE
+
+    def fill(self, category: int, alt: bool) -> tuple[str, int]:
+        # Alternating texture keeps neighbouring blocks of the same type apart.
+        if self.color:
+            if category == OTHER:
+                char = ":" if alt else "."
+            else:
+                char = "." if alt else " "
+            return char, curses.color_pair(category + 1)
+        return CATEGORIES[category].char, curses.A_BOLD if alt else curses.A_NORMAL
+
+    def swatch(self, category: int) -> tuple[str, int]:
+        char, attr = self.fill(category, False)
+        return char * 2, attr
+
+
+class App:
+    def __init__(self, screen, root: Node, color: bool):
+        self.screen = screen
+        self.browser = Browser(root)
+        self.styles = Styles(color)
+        self.show_legend = False
+        self.list_top = 0
+        self.encoding = screen.encoding or locale.getpreferredencoding()
+        self.unicode = "utf" in self.encoding.lower()
+        self.unreadable = _count_errors(root)
+        self._tiles_key = None
+        self._tiles: list[tuple[Rect, int, bool]] = []
+        self._top_rects: list[Rect] = []
+        self._rest_rect = Rect(0, 0, 0, 0)
+
+    def run(self) -> None:
+        curses.curs_set(0)
+        while True:
+            self.draw()
+            key = read_key(self.screen)
+            if key in (ord("q"), ord("Q")):
+                return
+            self.handle(key)
+
+    def handle(self, key: int) -> None:
+        b = self.browser
+        page = max(1, self.screen.getmaxyx()[0] - 3)
+        actions = {
+            curses.KEY_UP: lambda: b.move(-1),
+            ord("k"): lambda: b.move(-1),
+            curses.KEY_DOWN: lambda: b.move(1),
+            ord("j"): lambda: b.move(1),
+            curses.KEY_PPAGE: lambda: b.move(-page),
+            curses.KEY_NPAGE: lambda: b.move(page),
+            curses.KEY_HOME: lambda: b.move_to(0),
+            curses.KEY_END: lambda: b.move_to(len(b.entries) - 1),
+            curses.KEY_RIGHT: b.enter,
+            curses.KEY_ENTER: b.enter,
+            10: b.enter,
+            13: b.enter,
+            curses.KEY_LEFT: b.leave,
+            curses.KEY_BACKSPACE: b.leave,
+            127: b.leave,
+            8: b.leave,
+            ord("l"): self.toggle_legend,
+        }
+        action = actions.get(key)
+        if action:
+            action()
+
+    def toggle_legend(self) -> None:
+        self.show_legend = not self.show_legend
+
+    def text(self, y: int, x: int, s: str, width: int, attr: int = 0) -> None:
+        if width <= 0:
+            return
+        s = s.encode(self.encoding, "replace").decode(self.encoding)
+        s = "".join(c if c.isprintable() else "?" for c in s)
+        try:
+            self.screen.addnstr(y, x, s, width, attr)
+        except curses.error:
+            pass  # writing the bottom-right cell moves the cursor off-screen
+
+    def draw(self) -> None:
+        self.screen.erase()
+        height, width = self.screen.getmaxyx()
+        if width < 40 or height < 8:
+            self.text(0, 0, "Terminal too small", width)
+            self.screen.refresh()
+            return
+        list_w = min(max(width * 2 // 5, 36), 64)
+        map_area = Rect(0, 1, width - list_w - 1, height - 2)
+        self.draw_header(width)
+        self.draw_treemap(map_area)
+        self.draw_separator(width - list_w - 1, 1, height - 2)
+        self.draw_list(Rect(width - list_w, 1, list_w, height - 2))
+        if self.show_legend:
+            self.draw_legend(map_area)
+        self.text(
+            height - 1,
+            0,
+            (HELP if self.unicode else HELP_ASCII).ljust(width),
+            width,
+            curses.A_REVERSE,
+        )
+        self.screen.refresh()
+
+    def draw_header(self, width: int) -> None:
+        cur = self.browser.current
+        right = f" {human_size(cur.size)}  {len(cur.children)} items "
+        if self.unreadable:
+            right = f" {self.unreadable} unreadable |" + right
+        left = f" redwood  {cur.path}"
+        line = left[: max(0, width - len(right))].ljust(width - len(right)) + right
+        self.text(0, 0, line, width, curses.A_REVERSE)
+
+    def draw_separator(self, x: int, y: int, h: int) -> None:
+        try:
+            self.screen.vline(y, x, curses.ACS_VLINE, h)
+        except curses.error:
+            pass
+
+    def draw_treemap(self, area: Rect) -> None:
+        cur = self.browser.current
+        key = (id(cur), area)
+        if key != self._tiles_key:
+            self._tiles = []
+            self._top_rects, self._rest_rect = layout([c.size for c in cur.children], area)
+            for i, (child, rect) in enumerate(zip(cur.children, self._top_rects, strict=False)):
+                self._collect(child, _frame_inner(child, rect), i % 2 == 1)
+            self._add_rest_tile(self._rest_rect, cur, len(self._top_rects))
+            self._tiles_key = key
+
+        for rect, category, alt in self._tiles:
+            char, attr = self.styles.fill(category, alt)
+            for row in range(rect.y, rect.y + rect.h):
+                self.text(row, rect.x, char * rect.w, rect.w, attr)
+
+        rest = self._rest_rect
+        if rest.w >= 6:
+            label = f"+{len(cur.children) - len(self._top_rects)} small items"
+            self.text(rest.y, rest.x, label, rest.w, curses.A_BOLD)
+
+        for i, (child, rect) in enumerate(zip(cur.children, self._top_rects, strict=False)):
+            if not rect.w or not rect.h:
+                continue
+            selected = i == self.browser.index
+            label = f" {child.name}{'/' if child.is_dir else ''} {human_size(child.size)} "
+            if _frame_inner(child, rect) != rect:
+                self.draw_frame(rect, self.styles.highlight if selected else curses.A_NORMAL)
+                self.text(
+                    rect.y, rect.x + 1, label, rect.w - 2, self.styles.highlight if selected else 0
+                )
+            elif selected:
+                attr = self.styles.highlight
+                for row in range(rect.y, rect.y + rect.h):
+                    self.text(row, rect.x, " " * rect.w, rect.w, attr)
+                self.text(rect.y, rect.x, label.strip(), rect.w, attr)
+            elif rect.w >= 6:
+                self.text(
+                    rect.y,
+                    rect.x,
+                    label.strip(),
+                    rect.w,
+                    self.styles.fill(child.category, i % 2 == 1)[1],
+                )
+
+    def _collect(self, node: Node, rect: Rect, alt: bool) -> None:
+        if not rect.w or not rect.h:
+            return
+        if not node.is_dir or not node.size or rect.w * rect.h < 2:
+            self._tiles.append((rect, node.category, alt))
+            return
+        rects, rest = layout([c.size for c in node.children], rect)
+        for i, (child, child_rect) in enumerate(zip(node.children, rects, strict=False)):
+            self._collect(child, child_rect, alt ^ (i % 2 == 1))
+        self._add_rest_tile(rest, node, len(rects), alt)
+
+    def _add_rest_tile(self, rect: Rect, parent: Node, index: int, alt: bool = False) -> None:
+        # The parent's dominant type is close enough for a block of items too small to see.
+        if rect.w and rect.h:
+            self._tiles.append((rect, parent.category, alt ^ (index % 2 == 1)))
+
+    def draw_frame(self, r: Rect, attr: int) -> None:
+        s = self.screen
+        right, bottom = r.x + r.w - 1, r.y + r.h - 1
+        try:
+            s.hline(r.y, r.x + 1, curses.ACS_HLINE | attr, r.w - 2)
+            s.hline(bottom, r.x + 1, curses.ACS_HLINE | attr, r.w - 2)
+            s.vline(r.y + 1, r.x, curses.ACS_VLINE | attr, r.h - 2)
+            s.vline(r.y + 1, right, curses.ACS_VLINE | attr, r.h - 2)
+            s.addch(r.y, r.x, curses.ACS_ULCORNER, attr)
+            s.addch(r.y, right, curses.ACS_URCORNER, attr)
+            s.addch(bottom, r.x, curses.ACS_LLCORNER, attr)
+            s.addch(bottom, right, curses.ACS_LRCORNER, attr)
+        except curses.error:
+            pass
+
+    def draw_list(self, area: Rect) -> None:
+        b = self.browser
+        entries = b.entries
+        if not entries:
+            msg = "(unreadable)" if b.current.error else "(empty)"
+            self.text(area.y, area.x + 1, msg, area.w - 1)
+            return
+        if b.index < self.list_top:
+            self.list_top = b.index
+        elif b.index >= self.list_top + area.h:
+            self.list_top = b.index - area.h + 1
+        self.list_top = max(0, min(self.list_top, len(entries) - area.h))
+
+        biggest = entries[0].size or 1
+        total = b.current.size or 1
+        for row, i in enumerate(range(self.list_top, min(len(entries), self.list_top + area.h))):
+            node = entries[i]
+            y = area.y + row
+            swatch, swatch_attr = self.styles.swatch(node.category)
+            filled = round(BAR_WIDTH * node.size / biggest)
+            bar = "#" * filled + " " * (BAR_WIDTH - filled)
+            mark = "!" if node.error else " "
+            name = node.name + ("/" if node.is_dir else "")
+            line = f"{human_size(node.size):>9} {node.size * 100 / total:5.1f}% [{bar}]{mark}{name}"
+            attr = curses.A_REVERSE if i == b.index else 0
+            self.text(y, area.x + 1, swatch, 2, swatch_attr)
+            self.text(y, area.x + 3, line.ljust(area.w), area.w - 3, attr)
+
+    def draw_legend(self, area: Rect) -> None:
+        cur = self.browser.current
+        cats = sorted(
+            (i for i in range(len(CATEGORIES)) if cur.cat_sizes[i]),
+            key=lambda i: cur.cat_sizes[i],
+            reverse=True,
+        )
+        total = cur.size or 1
+        lines = []
+        for i in cats:
+            size = cur.cat_sizes[i]
+            lines.append(
+                (i, f"{CATEGORIES[i].name:<9}{human_size(size):>10} {size * 100 / total:5.1f}%")
+            )
+        w = 2 + 3 + max((len(t) for _, t in lines), default=16)
+        h = len(lines) + 2
+        box = Rect(area.x + 1, area.y + area.h - h - 1, w + 1, h)
+        if box.y < area.y or box.w > area.w:
+            return
+        for row in range(box.y, box.y + box.h):
+            self.text(row, box.x, " " * box.w, box.w)
+        self.draw_frame(box, curses.A_BOLD)
+        self.text(box.y, box.x + 2, " legend ", box.w - 3, curses.A_BOLD)
+        if not lines:
+            self.text(box.y + 1, box.x + 2, "(nothing here)", box.w - 3)
+        for row, (i, line) in enumerate(lines):
+            swatch, attr = self.styles.swatch(i)
+            self.text(box.y + 1 + row, box.x + 2, swatch, 2, attr)
+            self.text(box.y + 1 + row, box.x + 5, line, box.w - 6)
+
+
+def _frame_inner(node: Node, rect: Rect) -> Rect:
+    if node.is_dir and rect.w >= 6 and rect.h >= 3:
+        return Rect(rect.x + 1, rect.y + 1, rect.w - 2, rect.h - 2)
+    return rect
+
+
+def _count_errors(root: Node) -> int:
+    count, stack = 0, [root]
+    while stack:
+        node = stack.pop()
+        count += node.error
+        stack.extend(c for c in node.children if c.is_dir)
+    return count
+
+
+def run(root: Node, color: bool = True) -> None:
+    locale.setlocale(locale.LC_ALL, "")
+    curses.wrapper(lambda screen: App(screen, root, color).run())