megfile 3.1.0.post2__py3-none-any.whl → 3.1.2__py3-none-any.whl

megfile/utils/__init__.py

@@ -5,17 +5,26 @@ import os
 import uuid
 from copy import copy
 from functools import wraps
-from io import BufferedIOBase, BufferedRandom, BufferedReader, BufferedWriter, BytesIO, StringIO, TextIOBase, TextIOWrapper
+from io import (
+    BufferedIOBase,
+    BufferedRandom,
+    BufferedReader,
+    BufferedWriter,
+    BytesIO,
+    StringIO,
+    TextIOBase,
+    TextIOWrapper,
+)
 from typing import IO, Callable, Optional
 
 from megfile.utils.mutex import ProcessLocal, ThreadLocal
 
 
 def get_content_size(fileobj: IO, *, intrusive: bool = False) -> int:
-    ''' Get size of File-Like Object
+    """Get size of File-Like Object
 
     The File-Like Object must be seekable, otherwise raise IOError
-    '''
+    """
     if isinstance(fileobj, (BytesIO, StringIO)):
         return len(fileobj.getvalue())
 
@@ -25,8 +34,8 @@ def get_content_size(fileobj: IO, *, intrusive: bool = False) -> int:
             file = file.buffer
         if isinstance(file, BufferedIOBase):
             file = file.raw
-        if hasattr(file, '_content_size'):
-            return getattr(file, '_content_size')  # pyre-ignore[16]
+        if hasattr(file, "_content_size"):
+            return getattr(file, "_content_size")  # pyre-ignore[16]
 
     offset = fileobj.tell()
     if not is_seekable(fileobj) and is_writable(fileobj):
@@ -40,41 +49,41 @@ def get_content_size(fileobj: IO, *, intrusive: bool = False) -> int:
 
 
 def is_seekable(fileobj: IO) -> bool:
-    ''' Test if File-Like Object is seekable'''
-    if hasattr(fileobj, 'seekable'):
+    """Test if File-Like Object is seekable"""
+    if hasattr(fileobj, "seekable"):
         try:
             return fileobj.seekable()
         except Exception:
             return False
-    return hasattr(fileobj, 'seek')
+    return hasattr(fileobj, "seek")
 
 
 def is_readable(fileobj: IO) -> bool:
-    ''' Test if File-Like Object is readable'''
-    if hasattr(fileobj, 'readable'):
+    """Test if File-Like Object is readable"""
+    if hasattr(fileobj, "readable"):
         try:
             return fileobj.readable()
         except Exception:
             return False
-    return hasattr(fileobj, 'read')
+    return hasattr(fileobj, "read")
 
 
 def is_writable(fileobj: IO) -> bool:
-    ''' Test if File-Like Object is writable'''
-    if hasattr(fileobj, 'writable'):
+    """Test if File-Like Object is writable"""
+    if hasattr(fileobj, "writable"):
         try:
             return fileobj.writable()
         except Exception:
             return False
-    return hasattr(fileobj, 'write')
+    return hasattr(fileobj, "write")
 
 
 def _is_pickle(fileobj) -> bool:
-    ''' Test if File Object is pickle'''
-    if fileobj.name.endswith('.pkl') or fileobj.name.endswith('.pickle'):
+    """Test if File Object is pickle"""
+    if fileobj.name.endswith(".pkl") or fileobj.name.endswith(".pickle"):
         return True
 
-    if 'r' in fileobj.mode and 'b' in fileobj.mode:
+    if "r" in fileobj.mode and "b" in fileobj.mode:
         offset = fileobj.tell()
         fileobj.seek(0)
         data = fileobj.read(2)
@@ -90,29 +99,32 @@ def get_content_offset(start: Optional[int], stop: Optional[int], size: int):
     if stop is None or stop < 0 or start < 0:
         start, stop, _ = slice(start, stop).indices(size)
     if stop < start:
-        raise ValueError('read length must be positive')
+        raise ValueError("read length must be positive")
     return start, stop
 
 
 def get_name(fileobj, default=None):
-    return getattr(fileobj, 'name', default or repr(fileobj))
+    return getattr(fileobj, "name", default or repr(fileobj))
 
 
-def get_mode(fileobj, default='r'):
+def get_mode(fileobj, default="r"):
     if isinstance(fileobj, BytesIO):
-        return 'rb+'
+        return "rb+"
     elif isinstance(fileobj, StringIO):
-        return 'r+'
-    return getattr(fileobj, 'mode', default)
+        return "r+"
+    return getattr(fileobj, "mode", default)
 
 
 def shadow_copy(fileobj: IO, intrusive: bool = True, buffered: bool = False):
-    ''' Create a File-Like Object, maintaining file pointer, to avoid misunderstanding the position when read / write / seek
+    """Create a File-Like Object, maintaining file pointer,
+    to avoid misunderstanding the position when read / write / seek.
 
-    :param intrusive: If is intrusive. If True, move file pointer to the original position after every read / write / seek. If False, then not.
+    :param intrusive: If is intrusive. If True, move file pointer to the original
+        position after every read / write / seek. If False, then not.
     :param verbose: If True, print log when read / write / seek
-    '''
+    """
     from megfile.lib.shadow_handler import ShadowHandler
+
     result = ShadowHandler(fileobj, intrusive=intrusive)
     mode = get_mode(fileobj)
     if "b" in mode and (buffered or _is_pickle(result)):
@@ -125,22 +137,25 @@ def shadow_copy(fileobj: IO, intrusive: bool = True, buffered: bool = False):
     return result
 
 
-def lazy_open(
-        path: str, mode: str, open_func: Optional[Callable] = None, **options):
-    ''' Create a File-Like Object, maintaining file pointer, to open a file in lazy mode
+def lazy_open(path: str, mode: str, open_func: Optional[Callable] = None, **options):
+    """Create a File-Like Object, maintaining file pointer, to open a file in lazy mode
 
-    :param intrusive: If is intrusive. If True, move file pointer to the original position after every read / write / seek. If False, then not.
+    :param intrusive: If is intrusive. If True, move file pointer to the original
+        position after every read / write / seek. If False, then not.
     :param verbose: If True, print log when read / write / seek
-    '''
+    """
     from megfile.lib.lazy_handler import LazyHandler
+
     if open_func is None:
         from megfile.smart import smart_open
+
         open_func = smart_open
     return LazyHandler(path, mode, open_func=open_func, **options)
 
 
 def patch_rlimit():
     import resource
+
     soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
     resource.setrlimit(resource.RLIMIT_NOFILE, (hard, hard))
 
@@ -151,36 +166,38 @@ process_local = ProcessLocal()
 
 def combine(file_objects, name):
     from megfile.lib.combine_reader import CombineReader
+
     return CombineReader(file_objects, name)
 
 
 def get_binary_mode(mode: str) -> str:
-    '''Replace mode parameter in open() with corresponding binary mode'''
-    if 't' in mode:
+    """Replace mode parameter in open() with corresponding binary mode"""
+    if "t" in mode:
         # rt / wt / rt+ => rb / wb / rb+
-        mode = mode.replace('t', 'b')
-    elif 'b' not in mode:
+        mode = mode.replace("t", "b")
+    elif "b" not in mode:
         # r / w / r+ => rb / wb / rb+
-        mode = mode[:1] + 'b' + mode[1:]
+        mode = mode[:1] + "b" + mode[1:]
     # rb / wb / r+b => rb / wb / rb+
-    return "".join(sorted(mode, key=lambda k: {'b': 1, '+': 2}.get(k, 0)))
+    return "".join(sorted(mode, key=lambda k: {"b": 1, "+": 2}.get(k, 0)))
 
 
 def binary_open(open_func):
-    '''
+    """
     Decorator:
     Output according to user-setting mode while calling Open
-    '''
+    """
 
     @wraps(open_func)
     def wrapper(
-            path,
-            mode: str = 'rb',
-            encoding: Optional[str] = None,
-            errors: Optional[str] = None,
-            **kwargs):
+        path,
+        mode: str = "rb",
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        **kwargs,
+    ):
         fileobj = open_func(path, get_binary_mode(mode), **kwargs)
-        if 'b' not in mode:
+        if "b" not in mode:
             fileobj = TextIOWrapper(fileobj, encoding=encoding, errors=errors)
             fileobj.mode = mode  # pyre-ignore[41]
         return fileobj
@@ -189,18 +206,20 @@ def binary_open(open_func):
 
 
 def get_human_size(size_bytes: float) -> str:
-    '''Get human-readable size, e.g. `100MB`'''
-    assert size_bytes >= 0, 'negative size: %r' % size_bytes
+    """Get human-readable size, e.g. `100MB`"""
+    if size_bytes < 0:
+        # TODO: replace AssertionError with ValueError in 4.0.0
+        raise AssertionError("negative size: %r" % size_bytes)
     if size_bytes == 0:
-        return '0 B'
-    size_name = ('B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB')
+        return "0 B"
+    size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
     index = int(math.floor(math.log(size_bytes, 1024)))
     base = math.pow(1024, index)
     if base == 1:
         size = size_bytes
     else:
         size = round(size_bytes / base, 2)
-    return '%s %s' % (size, size_name[index])
+    return "%s %s" % (size, size_name[index])
 
 
 def necessary_params(func: Callable, **kwargs):
@@ -220,7 +239,7 @@ def necessary_params(func: Callable, **kwargs):
     return res_kwargs
 
 
-def generate_cache_path(filename: str, cache_dir: str = '/tmp') -> str:
+def generate_cache_path(filename: str, cache_dir: str = "/tmp") -> str:
     suffix = os.path.splitext(filename)[1]
     return os.path.join(cache_dir, str(uuid.uuid4()) + suffix)
 
@@ -238,7 +257,7 @@ def _get_class(cls_or_obj) -> type:
 
 def calculate_md5(file_object):
     hash_md5 = hashlib.md5()  # nosec
-    for chunk in iter(lambda: file_object.read(4096), b''):
+    for chunk in iter(lambda: file_object.read(4096), b""):
         hash_md5.update(chunk)
     return hash_md5.hexdigest()
 
@@ -264,7 +283,8 @@ class classproperty(property):
     def __set__(self, cls_or_obj, value: object) -> None:
         """
         This method gets called when a property value should be set.
-        @param cls_or_obj: The class or instance of which the property should be changed.
+        @param cls_or_obj: The class or instance of which the property should be
+            changed.
         @param value: The new value.
         """
         # call this method only on the class, not the instance
@@ -273,7 +293,8 @@ class classproperty(property):
     def __delete__(self, cls_or_obj) -> None:
         """
         This method gets called when a property should be deleted.
-        @param cls_or_obj: The class or instance of which the property should be deleted.
+        @param cls_or_obj: The class or instance of which the property should be
+            deleted.
         """
         # call this method only on the class, not the instance
         super(classproperty, self).__delete__(_get_class(cls_or_obj))

megfile/utils/mutex.py

@@ -5,14 +5,10 @@ from threading import RLock
 from threading import local as _ThreadLocal
 from typing import Any, Callable, Iterator
 
-__all__ = [
-    'ThreadLocal',
-    'ProcessLocal',
-]
+__all__ = ["ThreadLocal", "ProcessLocal"]
 
 
 class ForkAware(ABC):
-
     def __init__(self):
         self._process_id = os.getpid()
         self._reset()
@@ -26,7 +22,6 @@ class ForkAware(ABC):
 
 
 def fork_aware(func):
-
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         current_pid = os.getpid()
@@ -39,7 +34,6 @@ def fork_aware(func):
 
 
 class BaseLocal(ABC):  # pragma: no cover
-
     @property
     @abstractmethod
     def _data(self) -> dict:
@@ -68,7 +62,6 @@ class BaseLocal(ABC):  # pragma: no cover
 
 
 class ThreadLocal(ForkAware, BaseLocal):
-
     def _reset(self):
         self._local = _ThreadLocal()
 
@@ -86,9 +79,12 @@ class ThreadLocal(ForkAware, BaseLocal):
 
 class ProcessLocal(ForkAware, BaseLocal):
     """
-    Provides a basic per-process mapping container that wipes itself if the current PID changed since the last get/set.
+    Provides a basic per-process mapping container that wipes itself if the current PID
+    changed since the last get/set.
+
     Aka `threading.local()`, but for processes instead of threads.
     """
+
     _lock = None
 
     def _reset(self):
@@ -101,8 +97,9 @@ class ProcessLocal(ForkAware, BaseLocal):
         return self._local
 
     def __call__(self, key: str, func: Callable, *args, **kwargs) -> Any:
-        with self._lock:
-            data = self._data
-            if key not in data:
-                data[key] = func(*args, **kwargs)
-            return data[key]
+        data = self._data
+        if key not in data:
+            with self._lock:
+                if key not in data:
+                    data[key] = func(*args, **kwargs)
+        return data[key]

megfile/version.py

@@ -1 +1 @@
-VERSION = "3.1.0.post2"
+VERSION = "3.1.2"

{megfile-3.1.0.post2.dist-info → megfile-3.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: megfile
-Version: 3.1.0.post2
+Version: 3.1.2
 Summary: Megvii file operation library
 Author-email: megvii <megfile@megvii.com>
 Project-URL: Homepage, https://github.com/megvii-research/megfile
@@ -22,15 +22,15 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: LICENSE.pyre
 Requires-Dist: boto3
-Requires-Dist: botocore >=1.13.0
+Requires-Dist: botocore>=1.13.0
 Requires-Dist: requests
 Requires-Dist: paramiko
 Requires-Dist: tqdm
 Requires-Dist: pyyaml
 Provides-Extra: cli
-Requires-Dist: click ; extra == 'cli'
+Requires-Dist: click; extra == "cli"
 Provides-Extra: hdfs
-Requires-Dist: hdfs ; extra == 'hdfs'
+Requires-Dist: hdfs; extra == "hdfs"
 
 megfile - Megvii FILE library
 ---
@@ -198,12 +198,9 @@ s3 =
 
     *You can submit code even if the code doesn't meet conditions. The project members will evaluate and assist you in making code changes*
 
-    * **Code format**: Your code needs to pass **code format check**. `megfile` uses `yapf` as lint tool and the version is locked at 0.27.0. The version lock may be removed in the future
+    * **Code format**: Your code needs to pass **code format check**. `megfile` uses `ruff` as lint tool
     * **Static check**: Your code needs complete **type hint**. `megfile` uses `pytype` as static check tool. If `pytype` failed in static check, use `# pytype: disable=XXX` to disable the error and please tell us why you disable it.
 
-        *Note* : Because `pytype` doesn't support variable type annation, the variable type hint format introduced by py36 cannot be used.
-        > i.e. `variable: int` is invalid, replace it with `variable  # type: int`
-
     * **Test**: Your code needs complete **unit test** coverage. `megfile` uses `pyfakefs` and `moto` as local file system and s3 virtual environment in unit tests. The newly added code should have a complete unit test to ensure the correctness
 
 * You can help to improve `megfile` in many ways:

megfile-3.1.2.dist-info/RECORD

@@ -0,0 +1,55 @@
+docs/conf.py,sha256=sfDSly5jO8W_RmuAptOIp4hd8dNcO-9a5XrHTbxFnNo,2448
+megfile/__init__.py,sha256=i2Lbq_VxIgppaqwkxG0_H35dRfcjJ4mCYWjprOf4hHo,7318
+megfile/cli.py,sha256=Z54c98bIBOmljPtSPKPnXmuzsJJ8eLE0pd2l-ImhL1U,22234
+megfile/config.py,sha256=_SkJRaVWUdfW1Q9uX0vao-6YVQKJtfej22Z8DykuRps,2331
+megfile/errors.py,sha256=h6CgdgFG7A39ZgSvso9o5fz2uBZwMkZtBhRgtCXBvPI,13929
+megfile/fs.py,sha256=dgj5fW-EEzQNdjMF2tkB5DjXu3iHQbtLi5PSIMxR8fc,11966
+megfile/fs_path.py,sha256=Ffvukc176beH5aQMZXXtwH6ApwLYXPViCIUP0pijgT0,41590
+megfile/hdfs.py,sha256=latguOuuzAmg-yWOy3Sm723CJ0ybN_eSHRubVNqhcMU,9202
+megfile/hdfs_path.py,sha256=0XLtABufwqL-y8igOxzOJz6zOGppuBp2f2SwXIMvvYg,27299
+megfile/http.py,sha256=2Z2yqyhU-zcJCJwSNyBsxsZ7f2FT9X6fcednsbHDsFM,2025
+megfile/http_path.py,sha256=BhMNjQVB85IaCGGIKzgEfY73mAVdCzJP08W1RuGeMRA,16119
+megfile/interfaces.py,sha256=HPkYvpIEYzzVrZrUAvmBIO9SmmQXEWD9Ihaq551cnlM,8575
+megfile/pathlike.py,sha256=vKuCMlSAPYNSojp03wEj2i3Cq3E3ROp_-UkkdgBElws,30802
+megfile/s3.py,sha256=7SdfLjAePVh-bpRyuj566VB4Qa7KP86rCJGzYANR7wQ,13008
+megfile/s3_path.py,sha256=fHXDwndXz3X9zicdyxRhCgXzCSnPyEPs56MAxAaN6BY,93440
+megfile/sftp.py,sha256=vyDnYXX3i1j2fhXMC8YCeX-66MDb9wrBQQjQVhZx0uo,13004
+megfile/sftp_path.py,sha256=4tByWvUJK1KBJoa3t5aoWYnZpaRWN9nQIE6ZyiGHrbk,53519
+megfile/smart.py,sha256=Vr4R7HpjXjt587KOc2-1QGbQ5EsZ48YRzCaK0rz3IS0,36108
+megfile/smart_path.py,sha256=RO84tnqXsKtd_T19mz5wjD9LSnsE9_Vv3CuHId1qDiU,6686
+megfile/stdio.py,sha256=UYe-h440Wc4f5COOzOTG1svnp5nFzrfpixehJ0_0_NY,653
+megfile/stdio_path.py,sha256=7jzVdreamO18yBWZM7Pp71cO7GmrYb0M0qyQde2Ypq4,2706
+megfile/version.py,sha256=qUtPF5wMCWTQvs67Rysqijd4tyLvFcKVJ9nmvYVQDQo,19
+megfile/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+megfile/lib/base_prefetch_reader.py,sha256=CaYWuiKmlk4Utr0IFDPwPC58wV2jBAhqpxhwhRHc734,13652
+megfile/lib/combine_reader.py,sha256=uSzo3PmhD5ck6_Vv6dFU5vVx4boeA97VS-puPyhF_BE,4657
+megfile/lib/compare.py,sha256=n_dtLxgoskYnsIZMKdKmVhQoVn8qYUrUhkS1JH2_X3o,2170
+megfile/lib/compat.py,sha256=SynEeHluys3tCK-lb_1oV3o_ft83yZvunqM_AjibLgE,207
+megfile/lib/fnmatch.py,sha256=HzXwMCskXGdA0tHCkgTGrIZmyyFvQpOQxoGqjZExXR8,4040
+megfile/lib/glob.py,sha256=iJ0NvFh7b07MDru36YY1j3ZWPCNBLAECzUkoqYfJWgY,10052
+megfile/lib/hdfs_prefetch_reader.py,sha256=UrcUmTM1IZwD95oZMJXuY2dYEpE7uUjs_6dHyTMYDbg,2129
+megfile/lib/hdfs_tools.py,sha256=4K-OdMYFFSLBGmDzjatioHvuZuUbKVy7ACeJl-l0HLQ,435
+megfile/lib/http_prefetch_reader.py,sha256=PibR9Mx4JSdhkB4p8WzD3i2f__Txv55VBtPOmhml3vM,4556
+megfile/lib/joinpath.py,sha256=gaPNtBi8fzd5LZNyZp5zrHzaybcqKJ1xlntGmVNyFEM,929
+megfile/lib/lazy_handler.py,sha256=bE7RGt1x_xYWMgGAvHr7dwEt52qy-D3z90X3oyCvE6g,1875
+megfile/lib/s3_buffered_writer.py,sha256=V2nMdA3sB8XV6q5OqWFBZhPrzkw1ZUMM81k2uDPNn24,7087
+megfile/lib/s3_cached_handler.py,sha256=QrQKck06ye16o7GD71T-fVCseKlOhsxp82LtBTtAKJU,1498
+megfile/lib/s3_limited_seekable_writer.py,sha256=v-e7rfFBfWCSQVtJIaFHM_i0Hb1FkfVLHlhawo5MOIk,6358
+megfile/lib/s3_memory_handler.py,sha256=NGKWbI4LG2cmV06CP7KOVPqS_BNpm3ApqKi5ibgIBvQ,4208
+megfile/lib/s3_pipe_handler.py,sha256=DY1UTNCq8oD3QWXNb4orOiz3EoEAo6dhwmZZdk6h1bU,3694
+megfile/lib/s3_prefetch_reader.py,sha256=YZA6JOQXcioREh_z1E-kZ2WRPTm02v0dCEVqyaOMHns,4287
+megfile/lib/s3_share_cache_reader.py,sha256=jhGL1B6NPv68cQnW1Jf7ey-zTQ8XfiJg5ILDNgRWHy0,3671
+megfile/lib/shadow_handler.py,sha256=UHsbDHISGBPBlzFyu1V_UgUSoYNoVvVDsyhxtt0yEU0,2735
+megfile/lib/stdio_handler.py,sha256=IDdgENLQlhigEwkLL4zStueVSzdWg7xVcTF_koof_Ek,1987
+megfile/lib/url.py,sha256=ER32pWy9Q2MAk3TraAaNEBWIqUeBmLuM57ol2cs7-Ks,103
+megfile/utils/__init__.py,sha256=NfO5vNxfeceGvMB3dgZNudyPFTmPY096JbC4iYroX6o,9003
+megfile/utils/mutex.py,sha256=asb8opGLgK22RiuBJUnfsvB8LnMmodP8KzCVHKmQBWA,2561
+scripts/convert_results_to_sarif.py,sha256=nDiOfsedb22Ps7ZodmYdlXZlxv54fRxCQgOZsB2OkNk,2833
+scripts/generate_file.py,sha256=-mTcBiqiQ1juvqojVfVZ-uZWgpANHJNdhrF7s68zNfc,10903
+megfile-3.1.2.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+megfile-3.1.2.dist-info/LICENSE.pyre,sha256=9lf5nT-5ZH25JijpYAequ0bl8E8z5JmZB1qrjiUMp84,1080
+megfile-3.1.2.dist-info/METADATA,sha256=PdRilJUjmvzVJmWUcW_Jx9ieLmcJlAao4NEdWFP8NB8,8797
+megfile-3.1.2.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+megfile-3.1.2.dist-info/entry_points.txt,sha256=M6ZWSSv5_5_QtIpZafy3vq7WuOJ_5dSGQQnEZbByt2Q,49
+megfile-3.1.2.dist-info/top_level.txt,sha256=oTnYXo1Z3V61qSWAKtnY9RkDgRSHvfRN38FQae6E0W0,50
+megfile-3.1.2.dist-info/RECORD,,

{megfile-3.1.0.post2.dist-info → megfile-3.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.1.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

scripts/convert_results_to_sarif.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # Copyright (c) Facebook, Inc. and its affiliates.
-#
+
 # This source code is licensed under the MIT license found in the
 # LICENSE.pyre file in the root directory of this source tree.
 
@@ -18,44 +18,33 @@ Location = Dict[str, Any]
 
 def _locations(errors: List[Error]) -> Dict[str, Location]:
     locations = {
-        error["path"]: {
-            "uri": f"file://{Path.cwd() / error['path']}",
-            "index": 0,
-        } for error in errors
+        error["path"]: {"uri": f"file://{Path.cwd() / error['path']}", "index": 0}
+        for error in errors
     }
     for index, location in enumerate(locations.values()):
         location["index"] = index
     return locations
 
 
-def _to_sarif_result(error: Error, locations: Dict[str,
-                                                   Location]) -> Dict[str, Any]:
+def _to_sarif_result(error: Error, locations: Dict[str, Location]) -> Dict[str, Any]:
     LOG.info(f"Transforming:\n{error}")
 
     return {
-        "ruleId":
-            "type-error",
-        "ruleIndex":
-            0,
-        "level":
-            "error",
-        "message": {
-            "text": error["description"],
-        },
-        "locations":
-            [
-                {
-                    "physicalLocation":
-                        {
-                            "artifactLocation": locations[error["path"]],
-                            "region":
-                                {
-                                    "startLine": error["line"],
-                                    "startColumn": error["column"] + 1,
-                                },
-                        }
+        "ruleId": "type-error",
+        "ruleIndex": 0,
+        "level": "error",
+        "message": {"text": error["description"]},
+        "locations": [
+            {
+                "physicalLocation": {
+                    "artifactLocation": locations[error["path"]],
+                    "region": {
+                        "startLine": error["line"],
+                        "startColumn": error["column"] + 1,
+                    },
                 }
-            ],
+            }
+        ],
     }
 
 
@@ -63,62 +52,40 @@ def _to_sarif(errors: List[Dict[str, Any]]) -> Dict[str, Any]:
     LOG.info(f"Transforming:\n{errors}")
     locations = _locations(errors)
     return {
-        "version":
-            "2.1.0",
-        "$schema":
-            "http://json.schemastore.org/sarif-2.1.0-rtm.4",
-        "runs":
-            [
-                {
-                    "tool":
-                        {
-                            "driver":
-                                {
-                                    "name":
-                                        "Pyre",
-                                    "informationUri":
-                                        "https://www.pyre-check.org",
-                                    "rules":
-                                        [
-                                            {
-                                                "id":
-                                                    "type-error",
-                                                "shortDescription":
-                                                    {
-                                                        "text": "Type Error"
-                                                    },
-                                                "helpUri":
-                                                    "https://www.pyre-check.org",
-                                                "help":
-                                                    {
-                                                        "text":
-                                                            "Pyre is a type checker for Python"
-                                                    },
-                                            },
-                                        ],
-                                }
-                        },
-                    "artifacts":
-                        [
+        "version": "2.1.0",
+        "$schema": "http://json.schemastore.org/sarif-2.1.0-rtm.4",
+        "runs": [
+            {
+                "tool": {
+                    "driver": {
+                        "name": "Pyre",
+                        "informationUri": "https://www.pyre-check.org",
+                        "rules": [
                             {
-                                "location": location
-                            } for location in sorted(
-                                locations.values(),
-                                key=lambda location: location["index"])
-                        ],
-                    "results":
-                        [
-                            _to_sarif_result(error, locations)
-                            for error in errors
+                                "id": "type-error",
+                                "shortDescription": {"text": "Type Error"},
+                                "helpUri": "https://www.pyre-check.org",
+                                "help": {"text": "Pyre is a type checker for Python"},
+                            }
                         ],
-                }
-            ],
+                    }
+                },
+                "artifacts": [
+                    {"location": location}
+                    for location in sorted(
+                        locations.values(), key=lambda location: location["index"]
+                    )
+                ],
+                "results": [_to_sarif_result(error, locations) for error in errors],
+            }
+        ],
     }
 
 
 if __name__ == "__main__":
     logging.basicConfig(
-        format="%(asctime)s [%(levelname)s] %(message)s", level=logging.DEBUG)
+        format="%(asctime)s [%(levelname)s] %(message)s", level=logging.DEBUG
+    )
 
     sarif = _to_sarif(json.load(sys.stdin))
     json.dump(sarif, sys.stdout, indent=4)