Apply black code style

Author: ZipFile

getdents/__init__.py

@@ -47,23 +47,24 @@ def getdents(path: str, buff_size: int = 32768) -> Iterator[DirectoryEntry]:
         yield from (
             (inode, type, name)
             for inode, type, name in getdents_raw(fd, buff_size)
-            if not(type == DT_UNKNOWN or inode == 0 or name in ('.', '..'))
+            if not (type == DT_UNKNOWN or inode == 0 or name in (".", ".."))
         )
     finally:
         os.close(fd)
 
 
 __all__ = [
-    'DT_BLK',
-    'DT_CHR',
-    'DT_DIR',
-    'DT_FIFO',
-    'DT_LNK',
-    'DT_REG',
-    'DT_SOCK',
-    'DT_UNKNOWN',
-    'MIN_GETDENTS_BUFF_SIZE',
-    'O_GETDENTS',
-    'getdents',
-    'getdents_raw',
+    "DT_BLK",
+    "DT_CHR",
+    "DT_DIR",
+    "DT_FIFO",
+    "DT_LNK",
+    "DT_REG",
+    "DT_SOCK",
+    "DT_UNKNOWN",
+    "MIN_GETDENTS_BUFF_SIZE",
+    "O_GETDENTS",
+    "DirectoryEntry",
+    "getdents",
+    "getdents_raw",
 ]

getdents/__main__.py

@@ -3,6 +3,5 @@
 from . import __name__ as prog
 from .cli import main
 
-
-if __name__ == '__main__':  # pragma: no cover
+if __name__ == "__main__":  # pragma: no cover
     exit(main(prog=prog))

getdents/cli.py

@@ -12,32 +12,32 @@ def parse_args(
 ) -> Tuple[str, int, Formatter]:
     parser = ArgumentParser(
         prog=prog,
-        description='Print directory contents.',
+        description="Print directory contents.",
     )
 
-    parser.add_argument('path', metavar='PATH')
+    parser.add_argument("path", metavar="PATH")
     parser.add_argument(
-        '-b', '--buffer-size',
-        metavar='N',
+        "-b",
+        "--buffer-size",
+        metavar="N",
         type=int,
         default=32768,
-        help=(
-            'Buffer size (in bytes) to allocate when iterating over directory'
-        ),
+        help=("Buffer size (in bytes) to allocate when iterating over directory"),
     )
     parser.add_argument(
-        '-o', '--output-format',
-        metavar='NAME',
-        default='plain',
+        "-o",
+        "--output-format",
+        metavar="NAME",
+        default="plain",
         choices=list(FORMATTERS),
-        help='Output format: %s' % ', '.join(sorted(FORMATTERS)),
+        help="Output format: %s" % ", ".join(sorted(FORMATTERS)),
     )
 
     parsed_args = parser.parse_args(args)
     buff_size = parsed_args.buffer_size
 
     if buff_size < MIN_GETDENTS_BUFF_SIZE:
-        parser.error('Minimum buffer size is %s' % MIN_GETDENTS_BUFF_SIZE)
+        parser.error("Minimum buffer size is %s" % MIN_GETDENTS_BUFF_SIZE)
 
     return parsed_args.path, buff_size, FORMATTERS[parsed_args.output_format]
 
@@ -49,7 +49,9 @@ def main(args: Optional[List[str]] = None, prog: Optional[str] = None) -> int:
         fmt(getdents(path, buff_size=buff_size), stdout)
     except MemoryError:
         print(
-            'Not enough memory to allocate', buff_size, 'bytes of data',
+            "Not enough memory to allocate",
+            buff_size,
+            "bytes of data",
             file=stderr,
         )
         return 3

getdents/formatters.py

@@ -16,19 +16,19 @@
     DirectoryEntry,
 )
 
-
 Formatter = Callable[[Iterable[DirectoryEntry], TextIO], None]
-HEADER = ('inode', 'type', 'name')
-FORMATTERS: Dict[str, Formatter] = {}
+FormatterRegistry = Dict[str, Formatter]
+HEADER = ("inode", "type", "name")
+FORMATTERS: FormatterRegistry = {}
 TYPE_NAMES = {
-    DT_BLK: 'blk',
-    DT_CHR: 'chr',
-    DT_DIR: 'dir',
-    DT_FIFO: 'fifo',
-    DT_LNK: 'lnk',
-    DT_REG: 'reg',
-    DT_SOCK: 'sock',
-    DT_UNKNOWN: 'unknown',
+    DT_BLK: "blk",
+    DT_CHR: "chr",
+    DT_DIR: "dir",
+    DT_FIFO: "fifo",
+    DT_LNK: "lnk",
+    DT_REG: "reg",
+    DT_SOCK: "sock",
+    DT_UNKNOWN: "unknown",
 }
 
 
@@ -39,10 +39,11 @@ def formatter(
     def deco(fn: Formatter) -> Formatter:
         registry[name] = fn
         return fn
+
     return deco
 
 
-@formatter('plain')
+@formatter("plain")
 def format_plain(
     directory_entries: Iterable[DirectoryEntry],
     file: TextIO = stdout,
@@ -65,24 +66,25 @@ def _format_csv(
 
     for first in directory_entries:
         if headers:
-            print(writer.writerow(HEADER), end='', file=file)
+            print(writer.writerow(HEADER), end="", file=file)
 
         for inode, type, name in chain((first,), directory_entries):
             print(
                 writer.writerow((inode, TYPE_NAMES[type], name)),
-                end='', file=file,
+                end="",
+                file=file,
             )
 
 
-@formatter('csv')
+@formatter("csv")
 def format_csv(
     directory_entries: Iterable[DirectoryEntry],
     file: TextIO = stdout,
 ) -> None:
     return _format_csv(directory_entries, file, False)
 
 
-@formatter('csv-headers')
+@formatter("csv-headers")
 def format_csv_headers(
     directory_entries: Iterable[DirectoryEntry],
     file: TextIO = stdout,
@@ -91,34 +93,42 @@ def format_csv_headers(
 
 
 def json_encode(inode: int, type: int, name: str) -> str:
-    return json_dumps({
-        'inode': inode,
-        'type': TYPE_NAMES[type],
-        'name': name,
-    })
+    return json_dumps(
+        {
+            "inode": inode,
+            "type": TYPE_NAMES[type],
+            "name": name,
+        }
+    )
 
 
-@formatter('json')
+@formatter("json")
 def format_json(
     directory_entries: Iterable[DirectoryEntry],
     file: TextIO = stdout,
 ) -> None:
     for inode, type, name in directory_entries:
         print(
-            '[\n', json_encode(inode, type, name),
-            sep='', end='', file=file,
+            "[\n",
+            json_encode(inode, type, name),
+            sep="",
+            end="",
+            file=file,
         )
 
         for inode, type, name in directory_entries:
             print(
-                ',\n', json_encode(inode, type, name),
-                sep='', end='', file=file,
+                ",\n",
+                json_encode(inode, type, name),
+                sep="",
+                end="",
+                file=file,
             )
 
-        print('\n]', file=file)
+        print("\n]", file=file)
 
 
-@formatter('json-stream')
+@formatter("json-stream")
 def format_json_stream(
     directory_entries: Iterable[DirectoryEntry],
     file: TextIO = stdout,

tests/test___init__.py

@@ -1,46 +1,51 @@
-from unittest.mock import patch, sentinel
+from unittest.mock import Mock, patch, sentinel
 
 from pytest import raises
 
 from getdents import DT_DIR, DT_REG, DT_UNKNOWN, O_GETDENTS, getdents
 
 
-@patch('getdents.os')
-@patch('getdents.getdents_raw')
-def test_path(mock_getdents_raw, mock_os):
+@patch("getdents.os")
+@patch("getdents.getdents_raw")
+def test_path(mock_getdents_raw: Mock, mock_os: Mock) -> None:
     mock_os.open.return_value = sentinel.fd
 
-    list(getdents('/tmp', sentinel.size))
+    list(getdents("/tmp", sentinel.size))
 
-    mock_os.open.assert_called_once_with('/tmp', O_GETDENTS)
+    mock_os.open.assert_called_once_with("/tmp", O_GETDENTS)
     mock_getdents_raw.assert_called_once_with(sentinel.fd, sentinel.size)
     mock_os.close.assert_called_once_with(sentinel.fd)
 
 
-@patch('getdents.os')
-@patch('getdents.getdents_raw', side_effect=[Exception])
-def test_path_err(mock_getdents_raw, mock_os):
+@patch("getdents.os")
+@patch("getdents.getdents_raw", side_effect=[Exception])
+def test_path_err(mock_getdents_raw: Mock, mock_os: Mock) -> None:
     mock_os.open.return_value = sentinel.fd
 
     with raises(Exception):
-        list(getdents('/tmp', sentinel.size))
+        list(getdents("/tmp", sentinel.size))
 
-    mock_os.open.assert_called_once_with('/tmp', O_GETDENTS)
+    mock_os.open.assert_called_once_with("/tmp", O_GETDENTS)
     mock_getdents_raw.assert_called_once_with(sentinel.fd, sentinel.size)
     mock_os.close.assert_called_once_with(sentinel.fd)
 
 
-@patch('getdents.os')
-@patch('getdents.getdents_raw', return_value=iter([
-    (1, DT_DIR, '.'),
-    (2, DT_DIR, '..'),
-    (3, DT_DIR, 'dir'),
-    (4, DT_REG, 'file'),
-    (5, DT_UNKNOWN, '???'),
-    (0, DT_REG, 'deleted'),
-]))
-def test_filtering(mock_getdents_raw, mock_os):
-    assert list(getdents(0)) == [
-        (3, DT_DIR, 'dir'),
-        (4, DT_REG, 'file'),
+@patch("getdents.os")
+@patch(
+    "getdents.getdents_raw",
+    return_value=iter(
+        [
+            (1, DT_DIR, "."),
+            (2, DT_DIR, ".."),
+            (3, DT_DIR, "dir"),
+            (4, DT_REG, "file"),
+            (5, DT_UNKNOWN, "???"),
+            (0, DT_REG, "deleted"),
+        ]
+    ),
+)
+def test_filtering(mock_getdents_raw: Mock, mock_os: Mock) -> None:
+    assert list(getdents(".")) == [
+        (3, DT_DIR, "dir"),
+        (4, DT_REG, "file"),
     ]

tests/test__getdents.py

@@ -1,66 +1,66 @@
 import os
 import sys
+from pathlib import Path
+from typing import Iterable
 from unittest.mock import ANY
 
 from pytest import fixture, raises
 
-from getdents._getdents import (
-    DT_DIR,
-    MIN_GETDENTS_BUFF_SIZE,
-    getdents_raw,
-)
+from getdents._getdents import DT_DIR, MIN_GETDENTS_BUFF_SIZE, getdents_raw
 
 
 @fixture
-def fixt_regular_file(tmpdir):
-    f = tmpdir.join('test.txt')
-    f.write('content')
+def fixt_regular_file(tmp_path: Path) -> Iterable[int]:
+    f = tmp_path / "test.txt"
+    f.write_text("content")
 
-    fd = os.open(str(f), os.O_RDONLY)
+    fd = os.open(f, os.O_RDONLY)
 
     yield fd
 
     os.close(fd)
 
 
 @fixture
-def fixt_dir(tmpdir):
+def fixt_dir(tmp_path: Path) -> Iterable[int]:
     for i in range(10):
-        tmpdir.mkdir('subdir%d' % i)
+        (tmp_path / f"subdir{i}").mkdir()
 
-    fd = os.open(str(tmpdir), os.O_DIRECTORY | os.O_RDONLY)
+    fd = os.open(tmp_path, os.O_DIRECTORY | os.O_RDONLY)
 
     yield fd
 
     os.close(fd)
 
 
-def test_not_a_directory(fixt_regular_file):
+def test_not_a_directory(fixt_regular_file: int) -> None:
     with raises(NotADirectoryError):
         getdents_raw(fixt_regular_file, MIN_GETDENTS_BUFF_SIZE)
 
 
-def test_small_buffer(fixt_dir):
+def test_small_buffer(fixt_dir: int) -> None:
     with raises(ValueError):
         getdents_raw(fixt_dir, MIN_GETDENTS_BUFF_SIZE - 1)
 
 
-def test_malloc_fail(fixt_dir):
+def test_malloc_fail(fixt_dir: int) -> None:
     with raises(MemoryError):
         getdents_raw(fixt_dir, sys.maxsize)
 
 
-def test_getdents_raw(fixt_dir):
-    iterator = iter(sorted(
-        getdents_raw(
-            fixt_dir,
-            MIN_GETDENTS_BUFF_SIZE,
-        ),
-        key=lambda d: d[2],
-    ))
+def test_getdents_raw(fixt_dir: int) -> None:
+    iterator = iter(
+        sorted(
+            getdents_raw(
+                fixt_dir,
+                MIN_GETDENTS_BUFF_SIZE,
+            ),
+            key=lambda d: d[2],
+        )
+    )
 
-    assert next(iterator) == (ANY, DT_DIR, '.')
-    assert next(iterator) == (ANY, DT_DIR, '..')
+    assert next(iterator) == (ANY, DT_DIR, ".")
+    assert next(iterator) == (ANY, DT_DIR, "..")
 
     for i, entry in enumerate(iterator):
-        assert entry == (ANY, DT_DIR, 'subdir%d' % i)
+        assert entry == (ANY, DT_DIR, "subdir%d" % i)