je-file-tree 0.1.1__tar.gz

je_file_tree-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JE-Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

je_file_tree-0.1.1/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: je_file_tree
+Version: 0.1.1
+Summary: See where your disk space goes: a fast folder-size scanner with a tree, a treemap and a list of the largest files.
+Author-email: JE-Chen <jechenmailman@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/JeffreyChen-s-Utils/FileTree
+Project-URL: Code, https://github.com/JeffreyChen-s-Utils/FileTree
+Keywords: disk-usage,disk-space,folder-size,treemap,treesize,pyside6,qt
+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: Development Status :: 3 - Alpha
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: MacOS X
+Classifier: Environment :: X11 Applications :: Qt
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Natural Language :: English
+Classifier: Natural Language :: Chinese (Simplified)
+Classifier: Natural Language :: Chinese (Traditional)
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Filesystems
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PySide6>=6.8
+Dynamic: license-file
+
+# FileTree
+
+**See where your disk space goes.** FileTree scans a folder or a whole drive, adds up every file inside
+it, and shows you the biggest folders and files first — in a folder tree, a colourful treemap and a list
+of the largest files. When you find something you no longer need, move it to the Recycle Bin right from
+the window.
+
+[English](README.md) | [繁體中文](README/README_zh-TW.md) | [简体中文](README/README_zh-CN.md)
+
+![FileTree showing a home folder: the folder tree on the left, the treemap on the right](docs/images/main_window_en.png)
+
+## Features
+
+- **One click to start**: pick a folder, click a drive, drag a folder onto the window, or paste a path.
+- **Fast, and live**: several folders are read at once; about 740,000 files and folders are scanned in
+  6–8 seconds on an SSD. The tree fills in while the scan runs, biggest folders first, and Stop keeps
+  what was read so far.
+- **Folder tree** sorted largest first, with the space each entry takes on disk, a bar showing its share of
+  its folder, file and folder counts, and the last change inside it.
+- **Chart**, three ways to see a folder, switched in the corner of the tab: the **treemap** (every file a
+  rectangle sized by the space it takes), **bars** (one bar per entry of the folder, largest first, with
+  its size and share: easiest to read exactly) and the **sunburst** (the folder in the centre, each deeper
+  level a ring: the whole hierarchy at a glance). Click to find an entry in the tree, double-click to go
+  into a folder; all three follow.
+- **Largest files**: the 1,000 biggest files anywhere in the scan, with a filter box.
+- **Search** (Ctrl+F): find files and folders by name, or by a pattern such as `*.mp4`, anywhere in the scan.
+- **Duplicates**: files with the same content, grouped, with the space the extra copies take; select the
+  extra copies with one click and move them to the Recycle Bin.
+- **Compare with an earlier scan**: save a scan as JSON, and later see which folders grew, shrank,
+  appeared or disappeared since.
+- **File types** and **Age**: space used per extension and kind (pictures, videos, archives…) and by when
+  files last changed; double-click a row to list its largest files.
+- **Free space safely**: *Move to Recycle Bin* always asks first and never deletes permanently; the
+  numbers update immediately, without a rescan.
+- **Export** the folder list or the largest files to CSV (opens in Excel), or the folder tree to JSON.
+- **English, 繁體中文 and 简体中文**, switchable at any time; a built-in *How to use* guide.
+- Links and junctions are listed but never followed, so nothing is counted twice and a link loop cannot
+  trap a scan. Folders that cannot be read are listed under *Problems* instead of stopping the scan.
+
+## Install
+
+FileTree needs Python 3.10 or newer. It runs on Windows, macOS and Linux.
+
+```bash
+pip install git+https://github.com/JeffreyChen-s-Utils/FileTree.git
+je-file-tree
+```
+
+Or run it from a copy of the source:
+
+```bash
+git clone https://github.com/JeffreyChen-s-Utils/FileTree.git
+cd FileTree
+pip install -r requirements.txt
+python start_file_tree.py
+```
+
+`python -m je_file_tree` does the same.
+
+### Build a stand-alone program
+
+To give FileTree to someone without Python, compile it with Nuitka into a program folder or a single
+`.exe`: see [nuitka.md](nuitka.md) for the commands and what each option does.
+
+## How to use
+
+1. **Choose what to scan**: click *Choose a folder…* or one of the drives on the start page, drag a
+   folder onto the window, or type a path in the box at the top and press Enter. You can also start a
+   scan from the command line: `je-file-tree D:\Projects` (or `python start_file_tree.py D:\Projects`).
+2. **Watch it fill in**: the tree appears right away and the biggest folders move to the top while
+   FileTree works; the largest files and file types follow when the scan ends. *Stop* (or Esc) ends the
+   scan at any time and keeps what was read so far, marked as incomplete.
+3. **Find what takes the space**: the biggest folders are at the top of the tree. Open a folder with the
+   arrow next to it, or explore the chart on the right.
+
+### Reading the results
+
+| Where | What it tells you |
+|---|---|
+| Folder tree | Size, *On disk* (the space really taken: whole clusters, so usually a little more; less for compressed files, nothing for files kept only online), *% of parent* (the share of the folder above), number of files and folders inside, last change |
+| Chart | *Treemap*: one rectangle per file, sized by space used; each folder has a strip with its name and size, and tiles show their size. *Levels* sets how many levels are drawn (2 at first, up to all), *Colours* colours by file type (the legend is under it) or by top-level folder. *Bars*: one bar per entry of the folder shown, largest first, with its size and share of the folder. *Sunburst*: the folder in the centre and each deeper level as a ring, the angles by size, each top-level folder in its own colour; click the centre to go up. Double-click a folder to go into it and *Up* to go back; the three views always show the same folder, and FileTree remembers which one you chose |
+| Largest files | The 1,000 biggest files; type in the filter box to narrow the list, double-click to find a file in the tree |
+| Search | Files and folders whose name contains what you type; a pattern (`*.mp4`) must match the whole name, several are separated by `;` (`*.iso;*.zip`); the 1,000 largest matches are listed with the count and total size of all |
+| Duplicates | Press *Find duplicates*: files of the same size are compared, first by their first 64 KB, then by their whole content (hard links count once). Files under 1 MB are left out unless you choose a smaller size, because reading takes time. Each group lists its copies oldest first; *Select extra copies* selects all but the oldest, ready for Delete |
+| File types | Space per extension; choose a kind above the table to see only that kind, double-click a row to list the largest files of that type |
+| Age | Space by when files last changed (within a month … over two years ago); double-click a row to list its largest files |
+| Problems | Folders FileTree was not allowed to read; their contents are not counted |
+
+### Freeing space
+
+Right-click any entry to open it, show it in your file manager, copy its path, show it in the chart,
+rescan that folder after changes made outside FileTree (the rest of the results stay), scan that folder on
+its own, or move it to the Recycle Bin (the Trash on macOS and Linux). To move several entries at once,
+pick them with Ctrl+click or Shift+click in the folder tree, the Largest files list or the search results:
+FileTree asks once, listing them with their total size. It always asks before moving anything and never
+deletes permanently.
+
+### Seeing what grew
+
+Save a scan with **File → Export → Folder tree (JSON)**. Later, after a new scan, choose **File → Compare with a
+saved scan…** and open that file: a **Changes** tab lists every folder that changed, with its size then and
+now, the biggest growth first; new folders say *new* and removed ones *gone*. The comparison follows further
+rescans until you press *Stop comparing*. Folders are matched by their path below the scanned folder, so a
+scan can also be compared with a copy of the same tree elsewhere, such as a backup.
+
+### Keyboard shortcuts
+
+| Key | Action |
+|---|---|
+| Ctrl+O | Choose a folder |
+| F5 | Rescan |
+| Esc | Stop the scan |
+| Ctrl+F | Search by name |
+| Delete | Move the selected entries to the Recycle Bin |
+| F1 | How to use |
+| Ctrl+Q | Quit |
+
+On macOS use ⌘ instead of Ctrl (⌘R rescans).
+
+### Good to know
+
+- Sizes are real file sizes in binary units (1 KB = 1,024 bytes), the same as Windows Explorer. Pick a
+  fixed unit under *View → Size unit*.
+- On Windows, FileTree asks for administrator rights when it starts, like TreeSize, so it can read protected
+  folders too. Say no and it runs normally; folders it could not read are listed under *Problems*, with a
+  *Restart as administrator* button (also in the *File* menu). Turn the question off under
+  *View → Ask for administrator rights at start*.
+- Hidden files are counted. Turn off *View → Include hidden files* to leave them out of the next scan.
+- Your language, size unit, window layout and recently scanned folders are remembered (on Windows in the
+  registry under `HKEY_CURRENT_USER\Software\JE-Chen\FileTree`).
+
+## Development
+
+```bash
+pip install -r dev_requirements.txt
+python -m pytest
+python -m ruff check .
+python tools/make_screenshots.py
+```
+
+`tools/make_screenshots.py` redraws the README pictures from a made-up folder, in every language. The
+code layout, the main flows and the design rules are described in [architecture.md](architecture.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

je_file_tree-0.1.1/README.md

@@ -0,0 +1,146 @@
+# FileTree
+
+**See where your disk space goes.** FileTree scans a folder or a whole drive, adds up every file inside
+it, and shows you the biggest folders and files first — in a folder tree, a colourful treemap and a list
+of the largest files. When you find something you no longer need, move it to the Recycle Bin right from
+the window.
+
+[English](README.md) | [繁體中文](README/README_zh-TW.md) | [简体中文](README/README_zh-CN.md)
+
+![FileTree showing a home folder: the folder tree on the left, the treemap on the right](docs/images/main_window_en.png)
+
+## Features
+
+- **One click to start**: pick a folder, click a drive, drag a folder onto the window, or paste a path.
+- **Fast, and live**: several folders are read at once; about 740,000 files and folders are scanned in
+  6–8 seconds on an SSD. The tree fills in while the scan runs, biggest folders first, and Stop keeps
+  what was read so far.
+- **Folder tree** sorted largest first, with the space each entry takes on disk, a bar showing its share of
+  its folder, file and folder counts, and the last change inside it.
+- **Chart**, three ways to see a folder, switched in the corner of the tab: the **treemap** (every file a
+  rectangle sized by the space it takes), **bars** (one bar per entry of the folder, largest first, with
+  its size and share: easiest to read exactly) and the **sunburst** (the folder in the centre, each deeper
+  level a ring: the whole hierarchy at a glance). Click to find an entry in the tree, double-click to go
+  into a folder; all three follow.
+- **Largest files**: the 1,000 biggest files anywhere in the scan, with a filter box.
+- **Search** (Ctrl+F): find files and folders by name, or by a pattern such as `*.mp4`, anywhere in the scan.
+- **Duplicates**: files with the same content, grouped, with the space the extra copies take; select the
+  extra copies with one click and move them to the Recycle Bin.
+- **Compare with an earlier scan**: save a scan as JSON, and later see which folders grew, shrank,
+  appeared or disappeared since.
+- **File types** and **Age**: space used per extension and kind (pictures, videos, archives…) and by when
+  files last changed; double-click a row to list its largest files.
+- **Free space safely**: *Move to Recycle Bin* always asks first and never deletes permanently; the
+  numbers update immediately, without a rescan.
+- **Export** the folder list or the largest files to CSV (opens in Excel), or the folder tree to JSON.
+- **English, 繁體中文 and 简体中文**, switchable at any time; a built-in *How to use* guide.
+- Links and junctions are listed but never followed, so nothing is counted twice and a link loop cannot
+  trap a scan. Folders that cannot be read are listed under *Problems* instead of stopping the scan.
+
+## Install
+
+FileTree needs Python 3.10 or newer. It runs on Windows, macOS and Linux.
+
+```bash
+pip install git+https://github.com/JeffreyChen-s-Utils/FileTree.git
+je-file-tree
+```
+
+Or run it from a copy of the source:
+
+```bash
+git clone https://github.com/JeffreyChen-s-Utils/FileTree.git
+cd FileTree
+pip install -r requirements.txt
+python start_file_tree.py
+```
+
+`python -m je_file_tree` does the same.
+
+### Build a stand-alone program
+
+To give FileTree to someone without Python, compile it with Nuitka into a program folder or a single
+`.exe`: see [nuitka.md](nuitka.md) for the commands and what each option does.
+
+## How to use
+
+1. **Choose what to scan**: click *Choose a folder…* or one of the drives on the start page, drag a
+   folder onto the window, or type a path in the box at the top and press Enter. You can also start a
+   scan from the command line: `je-file-tree D:\Projects` (or `python start_file_tree.py D:\Projects`).
+2. **Watch it fill in**: the tree appears right away and the biggest folders move to the top while
+   FileTree works; the largest files and file types follow when the scan ends. *Stop* (or Esc) ends the
+   scan at any time and keeps what was read so far, marked as incomplete.
+3. **Find what takes the space**: the biggest folders are at the top of the tree. Open a folder with the
+   arrow next to it, or explore the chart on the right.
+
+### Reading the results
+
+| Where | What it tells you |
+|---|---|
+| Folder tree | Size, *On disk* (the space really taken: whole clusters, so usually a little more; less for compressed files, nothing for files kept only online), *% of parent* (the share of the folder above), number of files and folders inside, last change |
+| Chart | *Treemap*: one rectangle per file, sized by space used; each folder has a strip with its name and size, and tiles show their size. *Levels* sets how many levels are drawn (2 at first, up to all), *Colours* colours by file type (the legend is under it) or by top-level folder. *Bars*: one bar per entry of the folder shown, largest first, with its size and share of the folder. *Sunburst*: the folder in the centre and each deeper level as a ring, the angles by size, each top-level folder in its own colour; click the centre to go up. Double-click a folder to go into it and *Up* to go back; the three views always show the same folder, and FileTree remembers which one you chose |
+| Largest files | The 1,000 biggest files; type in the filter box to narrow the list, double-click to find a file in the tree |
+| Search | Files and folders whose name contains what you type; a pattern (`*.mp4`) must match the whole name, several are separated by `;` (`*.iso;*.zip`); the 1,000 largest matches are listed with the count and total size of all |
+| Duplicates | Press *Find duplicates*: files of the same size are compared, first by their first 64 KB, then by their whole content (hard links count once). Files under 1 MB are left out unless you choose a smaller size, because reading takes time. Each group lists its copies oldest first; *Select extra copies* selects all but the oldest, ready for Delete |
+| File types | Space per extension; choose a kind above the table to see only that kind, double-click a row to list the largest files of that type |
+| Age | Space by when files last changed (within a month … over two years ago); double-click a row to list its largest files |
+| Problems | Folders FileTree was not allowed to read; their contents are not counted |
+
+### Freeing space
+
+Right-click any entry to open it, show it in your file manager, copy its path, show it in the chart,
+rescan that folder after changes made outside FileTree (the rest of the results stay), scan that folder on
+its own, or move it to the Recycle Bin (the Trash on macOS and Linux). To move several entries at once,
+pick them with Ctrl+click or Shift+click in the folder tree, the Largest files list or the search results:
+FileTree asks once, listing them with their total size. It always asks before moving anything and never
+deletes permanently.
+
+### Seeing what grew
+
+Save a scan with **File → Export → Folder tree (JSON)**. Later, after a new scan, choose **File → Compare with a
+saved scan…** and open that file: a **Changes** tab lists every folder that changed, with its size then and
+now, the biggest growth first; new folders say *new* and removed ones *gone*. The comparison follows further
+rescans until you press *Stop comparing*. Folders are matched by their path below the scanned folder, so a
+scan can also be compared with a copy of the same tree elsewhere, such as a backup.
+
+### Keyboard shortcuts
+
+| Key | Action |
+|---|---|
+| Ctrl+O | Choose a folder |
+| F5 | Rescan |
+| Esc | Stop the scan |
+| Ctrl+F | Search by name |
+| Delete | Move the selected entries to the Recycle Bin |
+| F1 | How to use |
+| Ctrl+Q | Quit |
+
+On macOS use ⌘ instead of Ctrl (⌘R rescans).
+
+### Good to know
+
+- Sizes are real file sizes in binary units (1 KB = 1,024 bytes), the same as Windows Explorer. Pick a
+  fixed unit under *View → Size unit*.
+- On Windows, FileTree asks for administrator rights when it starts, like TreeSize, so it can read protected
+  folders too. Say no and it runs normally; folders it could not read are listed under *Problems*, with a
+  *Restart as administrator* button (also in the *File* menu). Turn the question off under
+  *View → Ask for administrator rights at start*.
+- Hidden files are counted. Turn off *View → Include hidden files* to leave them out of the next scan.
+- Your language, size unit, window layout and recently scanned folders are remembered (on Windows in the
+  registry under `HKEY_CURRENT_USER\Software\JE-Chen\FileTree`).
+
+## Development
+
+```bash
+pip install -r dev_requirements.txt
+python -m pytest
+python -m ruff check .
+python tools/make_screenshots.py
+```
+
+`tools/make_screenshots.py` redraws the README pictures from a made-up folder, in every language. The
+code layout, the main flows and the design rules are described in [architecture.md](architecture.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

je_file_tree-0.1.1/je_file_tree/__init__.py

@@ -0,0 +1,7 @@
+"""FileTree: see where your disk space goes.
+
+The package has two layers: ``je_file_tree.core`` scans a folder and computes the
+numbers (no Qt dependency), and ``je_file_tree.gui`` shows them in a PySide6 window.
+"""
+
+__version__ = "0.1.1"

je_file_tree-0.1.1/je_file_tree/__main__.py

@@ -0,0 +1,6 @@
+"""``python -m je_file_tree [folder]`` opens the window (and starts scanning ``folder`` if given)."""
+
+from je_file_tree.gui.app import run
+
+if __name__ == "__main__":
+    run()

je_file_tree-0.1.1/je_file_tree/core/__init__.py

@@ -0,0 +1 @@
+"""Scanning and analysis, independent of any GUI toolkit."""

je_file_tree-0.1.1/je_file_tree/core/allocation.py

@@ -0,0 +1,129 @@
+"""The space a file takes on disk ("size on disk"), which can differ from its size.
+
+A file takes whole clusters, so it usually takes a little more than its size; a compressed or
+sparse file can take much less, and a file whose data is elsewhere (offline, or a cloud file kept
+online only, such as a OneDrive placeholder) takes none.
+
+- POSIX: ``st_blocks`` (512-byte units) is exact and comes with the ``stat`` the scan makes anyway.
+- Windows: a directory listing has no allocation, and asking for it file by file
+  (``GetCompressedFileSizeW``) took 100-145 µs per file (measured 2026-09-26 on 60,000 files of D:\\Codes),
+  several times what the whole scan spends on a file. So an ordinary file is rounded up to whole
+  clusters, which came within 0.64 % of the exact total on 765,000 entries (tiny files stored inside
+  the MFT take no cluster of their own); only compressed and sparse files are asked for, and a file
+  whose data is elsewhere counts 0 without being opened, so nothing is downloaded.
+
+Cost, measured 2026-09-26 on 766,000 entries of D:\\Codes (median of five scans each): the scan takes
+about 3 % longer (6.93 s to 7.12 s) and each entry 17.5 bytes more. Small sizes are handed out from a
+table (``_SHARED``) so files of the same few clusters share one int object; without it each entry grew
+by 44 bytes and the scan by 5-9 %.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import functools
+import os
+import sys
+from collections.abc import Callable
+from typing import Any
+
+Allocation = Callable[["os.DirEntry[str]", os.stat_result], int]
+"""Tells the space a file takes on disk from its directory entry and its ``stat`` result."""
+
+DEFAULT_CLUSTER = 4096
+
+_SPARSE = 0x200
+_COMPRESSED = 0x800
+_OFFLINE = 0x1000
+_RECALL_ON_OPEN = 0x40000
+_RECALL_ON_DATA_ACCESS = 0x400000
+_PACKED = _SPARSE | _COMPRESSED
+_ELSEWHERE = _OFFLINE | _RECALL_ON_OPEN | _RECALL_ON_DATA_ACCESS
+_UNUSUAL = _PACKED | _ELSEWHERE
+_INVALID_FILE_SIZE = 0xFFFFFFFF
+_VOLUME_PATH_LENGTH = 1024
+_SHARED = 1024  # sizes of up to this many units (clusters or blocks) share their int object
+
+
+def allocation_for(root: str) -> Allocation:
+    """How to tell the space taken on disk by the files beneath ``root`` (a folder on one volume)."""
+    if sys.platform == "win32":
+        return windows_allocation(cluster_size(root))
+    if hasattr(os.stat_result, "st_blocks"):
+        return blocks_allocation()
+    return _plain_size
+
+
+def blocks_allocation() -> Allocation:
+    """The POSIX rule: ``st_blocks`` 512-byte units."""
+    shared = _multiples(512)
+
+    def allocated(_entry: os.DirEntry[str], info: os.stat_result) -> int:
+        blocks = info.st_blocks
+        return shared[blocks] if blocks < _SHARED else blocks * 512
+
+    return allocated
+
+
+def windows_allocation(cluster: int) -> Allocation:
+    """The Windows rule (see the module docstring) for a volume with ``cluster``-byte clusters."""
+
+    shared = _multiples(cluster)
+
+    def rounded(size: int) -> int:
+        clusters = -(-size // cluster)
+        return shared[clusters] if clusters < _SHARED else clusters * cluster
+
+    def allocated(entry: os.DirEntry[str], info: os.stat_result) -> int:
+        attributes = info.st_file_attributes
+        if not attributes & _UNUSUAL:  # nearly every file: no call to the system
+            return rounded(info.st_size)
+        if attributes & _ELSEWHERE:
+            return 0
+        exact = compressed_size(entry.path)
+        return rounded(info.st_size) if exact is None else exact
+
+    return allocated
+
+
+def cluster_size(path: str) -> int:
+    """Bytes per cluster of the volume holding ``path`` (Windows; ``DEFAULT_CLUSTER`` when it cannot be told)."""
+    kernel32 = _kernel32()
+    volume = ctypes.create_unicode_buffer(_VOLUME_PATH_LENGTH)
+    if not kernel32.GetVolumePathNameW(os.path.abspath(path), volume, _VOLUME_PATH_LENGTH):
+        return DEFAULT_CLUSTER
+    sectors, sector_bytes, free, total = (ctypes.c_ulong() for _ in range(4))
+    if not kernel32.GetDiskFreeSpaceW(volume.value, ctypes.byref(sectors), ctypes.byref(sector_bytes),
+                                      ctypes.byref(free), ctypes.byref(total)):
+        return DEFAULT_CLUSTER
+    return sectors.value * sector_bytes.value or DEFAULT_CLUSTER
+
+
+def compressed_size(path: str) -> int | None:
+    """The bytes a compressed or sparse file really takes (Windows); None when the system cannot say."""
+    high = ctypes.c_ulong()
+    low = _kernel32().GetCompressedFileSizeW(path, ctypes.byref(high))
+    if low == _INVALID_FILE_SIZE and ctypes.get_last_error():
+        return None
+    return (high.value << 32) | low
+
+
+@functools.cache
+def _kernel32() -> Any:
+    """kernel32 with the signatures used here (its own instance, so other modules' settings never clash)."""
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)  # type: ignore[attr-defined]
+    kernel32.GetVolumePathNameW.argtypes = [ctypes.c_wchar_p, ctypes.c_wchar_p, ctypes.c_ulong]
+    kernel32.GetVolumePathNameW.restype = ctypes.c_int
+    kernel32.GetDiskFreeSpaceW.argtypes = [ctypes.c_wchar_p] + [ctypes.POINTER(ctypes.c_ulong)] * 4
+    kernel32.GetDiskFreeSpaceW.restype = ctypes.c_int
+    kernel32.GetCompressedFileSizeW.argtypes = [ctypes.c_wchar_p, ctypes.POINTER(ctypes.c_ulong)]
+    kernel32.GetCompressedFileSizeW.restype = ctypes.c_ulong
+    return kernel32
+
+
+def _multiples(unit: int) -> tuple[int, ...]:
+    return tuple(range(0, _SHARED * unit, unit))
+
+
+def _plain_size(_entry: os.DirEntry[str], info: os.stat_result) -> int:
+    return info.st_size