check-empty 0.2.0__tar.gz → 0.6.0__tar.gz

{check_empty-0.2.0 → check_empty-0.6.0}/AUTHORS.md

@@ -10,4 +10,4 @@
 
 ## All other contributors and their affiliations
 
-None at the moment.
+None at the moment.

{check_empty-0.2.0 → check_empty-0.6.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: check-empty
-Version: 0.2.0
-Summary: Command-line utility, as well as a hook usable by the Python pre-commit framework, to ensure that selected files are empty.
-Keywords: check,command-line,empty,github-action,hook,lightweight,pre-commit,prek,tool,utility
+Version: 0.6.0
+Summary: Command-line utility, as well as a hook usable by the Python pre-commit framework and a GitHub Action, to ensure that selected files are empty.
+Keywords: check,command-line,empty,files,github-action,helper,hook,lightweight,pre-commit,prek,tool,utility
 Author: Jonathan Dung
 Author-email: Jonathan Dung <jonathandung@yahoo.com>
 License-Expression: MIT
@@ -29,33 +29,44 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Maintainer: Jonathan Dung
 Maintainer-email: Jonathan Dung <jonathandung@yahoo.com>
-Requires-Python: >=3.7
+Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 
 # check-empty
 
-A simple [pre-commit](https://pre-commit.com)/[prek](https://prek.j178.dev) hook that
+A simple, dependency-free and intuitive [pre-commit](https://pre-commit.com) /
+[prek](https://prek.j178.dev) hook, CLI, library and GitHub Action conglomerate that
 makes sure selected files are empty according to a filesystem stat call and clears them
-effectively on demand with a write-mode open and immediate close. Also acts as a CLI,
-library and GitHub Action conglomerate.
+effectively with minimal I/O if required, written in Python. Also available as a tool on
+uv. Supports CPython 3.6+, PyPy 7.0+, GraalPy 19.0+ and most likely every Python 3.6
+runtime you can think of.
 
 ## Quickstart
 
+Without installation (testing out the capabilities):
+
+```bash
+uvx check-empty -Q src/mylib/py.typed docs/.nojekyll static/.gitkeep some_directory
+```
+
 ```bash
-uv tool install check-empty # uv
+# uv
+uv tool install check-empty # bare executable on PATH
+uv pip install check-empty # if you want the library as well
+
 pip install check-empty # pip
 ```
 
 Check the version with:
 
 ```bash
-check-empty -v
+check-empty --version # or check-empty -v
 ```
 
 Run the CLI:
 
 ```bash
-check-empty -q src/mylib/py.typed docs/.nojekyll static/.gitkeep
+check-empty -Q src/mylib/py.typed docs/.nojekyll static/.gitkeep some_directory
 ```
 
 As a pre-commit hook:
@@ -64,16 +75,17 @@ As a pre-commit hook:
 # .pre-commit-config.yaml
 repos:
 - repo: https://github.com/jonathandung/check-empty
-  rev: v0.2.0 # repository version
+  rev: v0.6.0 # repository version
   hooks:
     - id: check-empty # the hook
       args: # example list of arguments
-        - --quiet # flag to silence output (equivalent to -q)
-        # below: paths to files to clear or keep empty, either relative to the project
-        # root or absolute (not shown)
+        - -Q # flag to silence output (shorthand for --quiet)
+        # below: paths to files/directories to clear or keep empty, relative to project
+        # root (absolute paths are possible but not recommended)
         - src/mylib/py.typed
         - docs/.nojekyll
         - static/.gitkeep
+        - some_directory
 ```
 
 equivalent in `prek.toml` format:
@@ -81,14 +93,29 @@ equivalent in `prek.toml` format:
 ```toml
 [[repos]]
 repo = "https://github.com/jonathandung/check-empty"
-rev = "v0.2.0"
+rev = "v0.6.0"
+
+[[repos.hooks]]
+id = "check-empty"
+args = [
+  "-Q",
+  "src/mylib/py.typed",
+  "docs/.nojekyll",
+  "static/.gitkeep",
+  "some_directory"
+]
+```
+
+or a more terse format (TOML 1.1+):
+
+```toml
+[[repos]]
+repo = "https://github.com/jonathandung/check-empty"
+rev = "v0.6.0"
 hooks = [{
   id = "check-empty",
   args = [
-    "--quiet",
-    "src/mylib/py.typed",
-    "docs/.nojekyll",
-    "static/.gitkeep",
+    "-Q", "src/mylib/py.typed", "docs/.nojekyll", "static/.gitkeep", "some_directory"
   ]
 }]
 ```
@@ -97,7 +124,7 @@ As a GitHub action step:
 
 ```yaml
 steps:
-- uses: jonathandung/check-empty@v0.2.0 # the latest version on the GitHub Actions
+- uses: jonathandung/check-empty@v0.6.0 # the latest version on the GitHub Actions
   # marketplace; this step will fail and subsequent jobs will not run if any file is
   # not empty
   with:
@@ -108,4 +135,10 @@ steps:
       src/mylib/py.typed
       docs/.nojekyll
       static/.gitkeep
+      some_directory
 ```
+
+## Development
+
+If you wish to contribute to this project, you are more than welcome, but please
+remember to read the [contributing guide](CONTRIBUTING.md).

check_empty-0.6.0/README.md

@@ -0,0 +1,110 @@
+# check-empty
+
+A simple, dependency-free and intuitive [pre-commit](https://pre-commit.com) /
+[prek](https://prek.j178.dev) hook, CLI, library and GitHub Action conglomerate that
+makes sure selected files are empty according to a filesystem stat call and clears them
+effectively with minimal I/O if required, written in Python. Also available as a tool on
+uv. Supports CPython 3.6+, PyPy 7.0+, GraalPy 19.0+ and most likely every Python 3.6
+runtime you can think of.
+
+## Quickstart
+
+Without installation (testing out the capabilities):
+
+```bash
+uvx check-empty -Q src/mylib/py.typed docs/.nojekyll static/.gitkeep some_directory
+```
+
+```bash
+# uv
+uv tool install check-empty # bare executable on PATH
+uv pip install check-empty # if you want the library as well
+
+pip install check-empty # pip
+```
+
+Check the version with:
+
+```bash
+check-empty --version # or check-empty -v
+```
+
+Run the CLI:
+
+```bash
+check-empty -Q src/mylib/py.typed docs/.nojekyll static/.gitkeep some_directory
+```
+
+As a pre-commit hook:
+
+```yaml
+# .pre-commit-config.yaml
+repos:
+- repo: https://github.com/jonathandung/check-empty
+  rev: v0.6.0 # repository version
+  hooks:
+    - id: check-empty # the hook
+      args: # example list of arguments
+        - -Q # flag to silence output (shorthand for --quiet)
+        # below: paths to files/directories to clear or keep empty, relative to project
+        # root (absolute paths are possible but not recommended)
+        - src/mylib/py.typed
+        - docs/.nojekyll
+        - static/.gitkeep
+        - some_directory
+```
+
+equivalent in `prek.toml` format:
+
+```toml
+[[repos]]
+repo = "https://github.com/jonathandung/check-empty"
+rev = "v0.6.0"
+
+[[repos.hooks]]
+id = "check-empty"
+args = [
+  "-Q",
+  "src/mylib/py.typed",
+  "docs/.nojekyll",
+  "static/.gitkeep",
+  "some_directory"
+]
+```
+
+or a more terse format (TOML 1.1+):
+
+```toml
+[[repos]]
+repo = "https://github.com/jonathandung/check-empty"
+rev = "v0.6.0"
+hooks = [{
+  id = "check-empty",
+  args = [
+    "-Q", "src/mylib/py.typed", "docs/.nojekyll", "static/.gitkeep", "some_directory"
+  ]
+}]
+```
+
+As a GitHub action step:
+
+```yaml
+steps:
+- uses: jonathandung/check-empty@v0.6.0 # the latest version on the GitHub Actions
+  # marketplace; this step will fail and subsequent jobs will not run if any file is
+  # not empty
+  with:
+    python-version: '3.14' # run the script on the latest stable Python version
+    # Python down to 3.6 is supported but not recommended due to end-of-life
+    quiet: true
+    filenames: |
+      src/mylib/py.typed
+      docs/.nojekyll
+      static/.gitkeep
+      some_directory
+```
+
+## Development
+
+If you wish to contribute to this project, you are more than welcome, but please
+remember to read the [contributing guide](CONTRIBUTING.md).

check_empty-0.6.0/check_empty/__init__.py

@@ -0,0 +1,184 @@
+# Copyright © 2026 Jonathan Dung. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Utility to check the emptiness of files and directories.
+
+Pre-commit hook, command-line tool and GitHub Action all-in-one.
+"""
+
+from __future__ import annotations
+
+import os
+
+__all__ = ('check',)
+__version__ = '0.6.0'
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from _typeshed import FileDescriptorOrPath
+    from typing_extensions import Literal, SupportsIndex
+
+DIRECTORY_DESCRIPTOR_UNSUPPORTED: BaseException = (
+    SystemError('got directory descriptor on Windows??')
+    if os.name == 'nt'
+    else NotImplementedError('directory descriptors are not supported')
+)
+
+
+class _Handler:
+    __slots__ = 'a', 'c', 'f', 'j', 'v'
+
+    def __init__(self, *a):
+        self.j, self.f, self.a = a
+        self.v = None
+
+    def __enter__(self):
+        self.c = False
+        return self
+
+    @property
+    def e(self, s='invalid fd (negative): %d', t='fd: %d'):  # ruff: ignore[property-with-parameters]
+        r = self.v
+        if r is not None:
+            return r
+        a = self.a
+        self.v = r = (s if a < 0 else t) % a if isinstance(a, int) else os.fsdecode(a)
+        return r
+
+    def _x(self, v):
+        self.j(self.e) if v.errno == 2 else self.f(str(v))
+
+    def __exit__(self, t, v, _):
+        if t is None or not issubclass(t, OSError):
+            return False
+        self._x(v)
+        self.c = True
+        return True
+
+
+def check(  # ruff: ignore[too-many-branches, too-many-locals, too-many-statements]
+    files: Iterable[FileDescriptorOrPath],
+    *,
+    clear: bool = False,
+    may_not_exist: bool = False,
+    verbosity: SupportsIndex = 2,
+) -> Literal[0, 1, 4, 5, 8, 9, 12, 13]:
+    """Check the emptiness of files and directories.
+
+    Args:
+        files: an iterable of file descriptors or paths representing the files and
+        directories to check; directory descriptors (Unix) are not supported.
+        clear: if True, clear the contents of non-empty files; directories, notably,
+        are not purged, but all files within should become empty.
+        may_not_exist: if True, do not treat absent files or directories as errors.
+        verbosity: how much detail the program should print to stdout; if 0, print
+        nothing; verbosity > 5 is equivalent to verbosity = 5.
+
+    Returns:
+        The integer exit code. A bitwise or of 1 (some files were not empty), 4 (some
+        files or directories were absent and `-m`/`--may-not-exist` was not specified)
+        and 8 (caught OSError while processing some files), such that 0 is the only
+        return value that represents success as expected. The 2 bit is skipped since it
+        conflicts with the exit code of `argparse.ArgumentParser` when it encounters
+        invalid arguments.
+
+    """
+    files = list(files)
+    if not files:
+        return 0
+    k, j, t, n, o = [0] * 4, [], 0, len(files), files.pop
+    u, e = j.extend, j.pop
+
+    def _(v, k=k):
+        def f(_):
+            k[v] += 1
+
+        return f
+
+    verbosity = type(verbosity).__index__(verbosity)
+    if verbosity > 4:
+        b = ['']
+        f = b.append
+    else:
+        b, f = None, _(0)
+    if verbosity > 2:
+        z, w = [''], ['']
+        i = z.append, w.append
+    else:
+        z = w = None
+        i = _(1), _(2)
+    if verbosity > 1:
+        r = ['']
+        g = r.append
+    else:
+        r, g = None, _(3)
+    while files:
+        a = o()
+        with _Handler(*i, a) as h:
+            q = os.stat(a)
+        if h.c:
+            continue
+        c = h.e
+        if (q.st_mode >> 12) & 15 == 4:
+            if isinstance(a, int):
+                raise DIRECTORY_DESCRIPTOR_UNSUPPORTED
+            if verbosity > 3:
+                print('Recursing into directory:', c)
+            u(os.scandir(c))
+            continue
+        s = q.st_size
+        if not s:
+            f(c)
+            continue
+        g(f'{c} ({s} bytes)')
+        t += s
+        if clear:
+            with h, open(a, 'wb'):
+                ...
+    del o, files
+    while j:
+        m = e()
+        a = m.path
+        if m.is_dir():
+            if verbosity > 3:
+                print('Recursing into directory:', a)
+            u(os.scandir(a))
+            continue
+        n += 1
+        s = m.stat().st_size
+        if not s:
+            f(a)
+            continue
+        g(f'{a} ({s} bytes)')
+        t += s
+        if clear:
+            with _Handler(*i, a), open(a, 'wb'):
+                ...
+    x = k[1] if z is None else len(z) - 1
+    y = k[3] if r is None else len(r) - 1
+    d = k[2] if w is None else len(w) - 1
+    v = bool(y) | (bool(x) and not may_not_exist) << 2 | bool(d) << 3
+    if verbosity <= 0:
+        return v  # ty: ignore[invalid-return-type]
+    if verbosity > 2:
+        print(*z, sep='\nNot found: ')
+    print(f'{x} file{"" if x == 1 else "s"} not found' if x else 'All files were found')
+    if verbosity > 2:
+        print(*w, sep='\nError: ')
+    if d:
+        print(f'{d} I/O error{"s" if d > 1 else ""} encountered')
+    if verbosity > 4:
+        print(*b, sep='\nEmpty: ')
+    if verbosity > 2:
+        p = k[0] if b is None else len(b) - 1
+        print(f'{p} empty file{"" if p == 1 else "s"}' if p else 'No empty files')
+    if y:
+        if verbosity > 1:
+            print(*r, sep='\nCleared: ' if clear else '\nNot empty: ', end='')
+            print(end='\n\n')
+        print(y, 'offending files' if y > 1 else 'offending file')
+        print(f'Total size: {t} bytes')
+    elif n > x:
+        print('All found files were empty')
+    return v  # ty: ignore[invalid-return-type]

check_empty-0.6.0/check_empty/__main__.py

@@ -0,0 +1,58 @@
+"""Implementation of the main routine. Also exports the argument parser."""
+
+from __future__ import annotations
+
+import check_empty as c
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from typing import Literal
+
+parser = __import__('argparse').ArgumentParser(
+    'check-empty',
+    description='Assert or enforce that some files, or even directories, are empty. '
+    'Makes some reasonable assumptions, such as the absence of another process '
+    'modifying a file or directory involved, while running.',
+    epilog='It is preferred that you use this as a pre-commit/prek hook or GitHub '
+    'Action for most cases which are not one-off.',
+)
+f = parser.add_argument
+f('filenames', nargs='+', help='the files that should be empty')
+f('-v', '--version', action='version', version='check-empty v' + c.__version__)
+f('-c', '--clear', action='store_true', help='clear files that are not empty')
+f(
+    '-m',
+    '--may-not-exist',
+    action='store_true',
+    help='do not fail solely because some files are not present',
+)
+f('-Q', '--quiet', action='count', default=0, help='decrease output verbosity')
+f('-V', '--verbose', action='count', default=0, help='increase output verbosity')
+
+
+def main(argv: Iterable[str] | None = None) -> Literal[0, 1, 2, 4, 5, 8, 9, 12, 13]:
+    """Run the hook on the files in the command-line arguments passed.
+
+    Args:
+        argv: a list of arguments; default `sys.argv[1:]`.
+
+    Returns:
+        The exit code. See `check` for details.
+
+    """
+    try:
+        n = parser.parse_args(argv)
+    except SystemExit as e:
+        return e.code  # ty: ignore[invalid-return-type]
+    return c.check(
+        n.filenames,
+        clear=n.clear,
+        may_not_exist=n.may_not_exist,
+        verbosity=2 + n.verbose - n.quiet,
+    )
+
+
+if __name__ == '__main__':
+    parser.exit(main())
+del f, TYPE_CHECKING

{check_empty-0.2.0 → check_empty-0.6.0}/pyproject.toml

@@ -1,19 +1,19 @@
 [build-system]
-requires = ["uv_build>=0.11.29,<0.12"]
+requires = ["uv_build>=0.11.31,<0.12"]
 build-backend = "uv_build"
 
 [project]
 authors = [{name = "Jonathan Dung", email = "jonathandung@yahoo.com"}]
 classifiers = ["Development Status :: 3 - Alpha", "Environment :: Console", "Intended Audience :: Developers", "Natural Language :: English", "Operating System :: OS Independent", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "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", "Programming Language :: Python :: 3.15", "Programming Language :: Python :: Free Threading :: 3 - Stable", "Topic :: Utilities", "Typing :: Typed"]
-description = "Command-line utility, as well as a hook usable by the Python pre-commit framework, to ensure that selected files are empty."
-keywords = ["check", "command-line", "empty", "github-action", "hook", "lightweight", "pre-commit", "prek", "tool", "utility"]
+description = "Command-line utility, as well as a hook usable by the Python pre-commit framework and a GitHub Action, to ensure that selected files are empty."
+keywords = ["check", "command-line", "empty", "files", "github-action", "helper", "hook", "lightweight", "pre-commit", "prek", "tool", "utility"]
 license = "MIT"
 license-files = ["LICENSE", "AUTHORS.md"]
 maintainers = [{name = "Jonathan Dung", email = "jonathandung@yahoo.com"}]
 name = "check-empty"
 readme = "README.md"
-requires-python = ">=3.7"
-version = "0.2.0"
+requires-python = ">=3.6"
+version = "0.6.0"
 
 [project.scripts]
 check-empty = "check_empty.__main__:main"
@@ -28,7 +28,7 @@ type-checking-imports = false
 quote-style = "single"
 
 [tool.ruff.lint]
-ignore = ["ANN", "COM", "PT", "PTH", "avoidable-escaped-quote", "bad-quotes-inline-string", "complex-structure", "docstring-extraneous-exception", "incorrect-blank-line-before-class", "multi-line-summary-second-line", "print", "unnecessary-dunder-call"]
+ignore = ["ANN", "COM", "FBT", "PT", "PTH", "avoidable-escaped-quote", "bad-quotes-inline-string", "complex-structure", "docstring-extraneous-exception", "import-outside-top-level", "incorrect-blank-line-before-class", "magic-value-comparison", "multi-line-summary-second-line", "non-empty-init-module", "print", "unnecessary-dunder-call"]
 preview = true
 select = ["ALL"]
 
@@ -53,8 +53,12 @@ python-platform = "all"
 all = "error"
 missing-override-decorator = "ignore"
 
+[[tool.ty.overrides]]
+include = ["check_empty/__init__.py"]
+rules = {not-iterable = "ignore"}
+
 [tool.uv]
-required-version = ">=0.11.29,<0.12"
+required-version = ">=0.11.31,<0.12"
 
 [tool.uv.build-backend]
 module-name = "check_empty"

check_empty-0.2.0/README.md

@@ -1,77 +0,0 @@
-# check-empty
-
-A simple [pre-commit](https://pre-commit.com)/[prek](https://prek.j178.dev) hook that
-makes sure selected files are empty according to a filesystem stat call and clears them
-effectively on demand with a write-mode open and immediate close. Also acts as a CLI,
-library and GitHub Action conglomerate.
-
-## Quickstart
-
-```bash
-uv tool install check-empty # uv
-pip install check-empty # pip
-```
-
-Check the version with:
-
-```bash
-check-empty -v
-```
-
-Run the CLI:
-
-```bash
-check-empty -q src/mylib/py.typed docs/.nojekyll static/.gitkeep
-```
-
-As a pre-commit hook:
-
-```yaml
-# .pre-commit-config.yaml
-repos:
-- repo: https://github.com/jonathandung/check-empty
-  rev: v0.2.0 # repository version
-  hooks:
-    - id: check-empty # the hook
-      args: # example list of arguments
-        - --quiet # flag to silence output (equivalent to -q)
-        # below: paths to files to clear or keep empty, either relative to the project
-        # root or absolute (not shown)
-        - src/mylib/py.typed
-        - docs/.nojekyll
-        - static/.gitkeep
-```
-
-equivalent in `prek.toml` format:
-
-```toml
-[[repos]]
-repo = "https://github.com/jonathandung/check-empty"
-rev = "v0.2.0"
-hooks = [{
-  id = "check-empty",
-  args = [
-    "--quiet",
-    "src/mylib/py.typed",
-    "docs/.nojekyll",
-    "static/.gitkeep",
-  ]
-}]
-```
-
-As a GitHub action step:
-
-```yaml
-steps:
-- uses: jonathandung/check-empty@v0.2.0 # the latest version on the GitHub Actions
-  # marketplace; this step will fail and subsequent jobs will not run if any file is
-  # not empty
-  with:
-    python-version: '3.14' # run the script on the latest stable Python version
-    # Python down to 3.6 is supported but not recommended due to end-of-life
-    quiet: true
-    filenames: |
-      src/mylib/py.typed
-      docs/.nojekyll
-      static/.gitkeep
-```

check_empty-0.2.0/check_empty/__init__.py

@@ -1,9 +0,0 @@
-# Copyright © 2026 Jonathan Dung. All rights reserved.
-# SPDX-License-Identifier: MIT
-"""Utility to check the emptiness of files.
-
-Pre-commit hook, command-line tool and GitHub Action all-in-one.
-"""
-
-__all__ = ('main',)
-from check_empty.__main__ import __version__ as __version__, main

check_empty-0.2.0/check_empty/__main__.py

@@ -1,83 +0,0 @@
-#!usr/bin/env python3
-"""Implementation of the main routine."""
-
-from __future__ import annotations
-
-from os.path import getsize
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Literal, Sequence
-
-__version__ = '0.1'
-parser = __import__('argparse').ArgumentParser(
-    'check-empty',
-    description='Assert or enforce that some files are empty.',
-    epilog='It is preferred that you use this as a pre-commit/prek hook or GitHub '
-    'Action for most cases which are not one-off.',
-)
-f = parser.add_argument
-f('filenames', nargs='+', help='the files that should be empty')
-f('-v', '--version', action='version', version='check-empty v' + __version__)
-f('-c', '--clear', action='store_true', help='clear files that are not empty')
-f('-m', '--must-exist', action='store_true', help='fail if any file is absent')
-f('-q', '--quiet', action='store_true', help='suppress output')
-
-
-def main(argv: Sequence[str] | None = None) -> Literal[0, 1, 2, 3]:
-    """Run the hook on the files in the (command-line) arguments passed.
-
-    Args:
-        argv: A list of arguments excluding the executable name, default sys.argv[1:].
-
-    Returns:
-        The exit code. A bitwise or of 1 (some files were not empty) and 2 (some files
-        were absent and --must-exist was specified), such that 0 is the only return
-        value that represents success as expected.
-
-    """
-    r, z, n = [''], [''], parser.parse_args(argv)
-    g, j, c, t, i = r.append, z.append, n.clear, 0, n.filenames
-    if c:
-        for a in i:
-            try:
-                s = getsize(a)
-            except FileNotFoundError:
-                j(a)
-                continue
-            if not s:
-                continue
-            g(f'{a} ({s} bytes)')
-            t += s
-            with open(a, 'wb'):
-                ...
-    else:
-        for a in i:
-            try:
-                s = getsize(a)
-            except FileNotFoundError:
-                j(a)
-                continue
-            if not s:
-                continue
-            g(f'{a} ({s} bytes)')
-            t += s
-    p, x, y = not n.quiet, len(z) - 1, len(r) - 1
-    v = n.must_exist << 1 if x else 0
-    if p:
-        print(*z, sep='\nNot found: ')
-        print(f'{x} files not found' if x else 'All files were found')
-    if y:
-        if p:
-            print(*r, sep='\nCleared: ' if c else '\nNot empty: ', end='\n\n')
-            print(y, 'offending files' if y > 1 else 'offending file')
-            print(f'Total size: {t} bytes')
-        return v | 1
-    if p:
-        print('All found files were empty')
-    return v
-
-
-if __name__ == '__main__':
-    raise SystemExit(main())
-del f, TYPE_CHECKING