megfile 5.0.2__py3-none-any.whl → 5.0.4__py3-none-any.whl

megfile/cli.py

@@ -92,6 +92,8 @@ def safe_cli():  # pragma: no cover
 
 
 def get_echo_path(file_stat, base_path: str = "", full: bool = False):
+    if base_path.startswith("file://"):
+        base_path = base_path[7:]
     if base_path == file_stat.path:
         path = file_stat.name
     elif full:
@@ -150,6 +152,8 @@ def _sftp_prompt_host_key(path):
 
 def _ls(path: str, long: bool, full: bool, recursive: bool, human_readable: bool):
     base_path = path
+    if path == "file://":
+        path = "./"
     if has_magic(path):
         scan_func = smart_glob_stat
         base_path = get_non_glob_dir(path)
@@ -186,7 +190,7 @@ class PathType(ParamType):
     name = "path"
 
     def shell_complete(self, ctx, param, incomplete):
-        if "://" not in incomplete and not incomplete.startswith("/"):
+        if not incomplete:
             completions = [
                 CompletionItem(f"{protocol}://")
                 for protocol in SmartPath._registered_protocols
@@ -196,6 +200,15 @@ class PathType(ParamType):
                     continue
                 completions.append(CompletionItem(f"s3+{name}://"))
             return completions
+        if incomplete.startswith("file://"):
+            return [
+                CompletionItem(
+                    f"file://{entry.path}/"
+                    if entry.is_dir()
+                    else f"file://{entry.path}"
+                )
+                for entry in islice(smart_glob_stat(incomplete[7:] + "*"), 128)
+            ]
         try:
             return [
                 CompletionItem(f"{entry.path}/" if entry.is_dir() else entry.path)

megfile/errors.py

@@ -182,7 +182,7 @@ def patch_method(
                         f"Cannot handle error {full_error_message(error)} "
                         f"after {retries} tries"
                     )
-                    raise
+                    raise MaxRetriesExceededError(error, retries=retries)
                 retry_interval = min(0.1 * 2**retries, 30)
                 _logger.info(
                     f"unknown error encountered: {full_error_message(error)}, "
@@ -209,14 +209,34 @@ def _create_missing_ok_generator(generator, missing_ok: bool, error: Exception):
     return create_generator()
 
 
-class UnknownError(Exception):
-    def __init__(self, error: Exception, path: PathLike, extra: Optional[str] = None):
-        message = "Unknown error encountered: %r, error: %s" % (
-            path,
+class MaxRetriesExceededError(Exception):
+    def __init__(self, error: Exception, retries: int = 1):
+        while isinstance(error, MaxRetriesExceededError):
+            retries *= error.retries
+            error = error.__cause__
+        message = "Max retires exceeded: %s, after %d tries" % (
             full_error_message(error),
+            retries,
         )
+        super().__init__(message)
+        self.retries = retries
+        self.__cause__ = error
+
+    def __reduce__(self):
+        return (self.__class__, (self.__cause__, self.retries))
+
+
+class UnknownError(Exception):
+    def __init__(self, error: Exception, path: PathLike, extra: Optional[str] = None):
+        parts = [f"Unknown error encountered: {path!r}"]
+        if isinstance(error, MaxRetriesExceededError):
+            parts.append(f"error: {full_error_message(error.__cause__)}")
+            parts.append(f"after {error.retries} tries")
+        else:
+            parts.append(f"error: {full_error_message(error)}")
         if extra is not None:
-            message += ", " + extra
+            parts.append(extra)
+        message = ", ".join(parts)
         super().__init__(message)
         self.path = path
         self.extra = extra
@@ -350,6 +370,8 @@ def translate_fs_error(fs_error: Exception, fs_path: PathLike) -> Exception:
         if fs_error.filename is None:
             fs_error.filename = fs_path
         return fs_error
+    if isinstance(fs_error, MaxRetriesExceededError):
+        return fs_error.__cause__
     return fs_error
 
 
@@ -359,7 +381,10 @@ def translate_s3_error(s3_error: Exception, s3_url: PathLike) -> Exception:
     """
     if isinstance(s3_error, S3Exception):
         return s3_error
-    elif isinstance(s3_error, ClientError):
+    ori_error = s3_error
+    if isinstance(s3_error, MaxRetriesExceededError):
+        s3_error = s3_error.__cause__
+    if isinstance(s3_error, ClientError):
         code = client_error_code(s3_error)
         if code in ("NoSuchBucket"):
             bucket_or_url = (
@@ -419,7 +444,7 @@ def translate_s3_error(s3_error: Exception, s3_url: PathLike) -> Exception:
             return S3InvalidRangeError("Invalid range: %r" % s3_url)
         elif "AccessDenied" in str(s3_error):
             return S3PermissionError("Access denied: %r" % s3_url)
-    return S3UnknownError(s3_error, s3_url)
+    return S3UnknownError(ori_error, s3_url)
 
 
 def translate_http_error(http_error: Exception, http_url: str) -> Exception:
@@ -434,13 +459,16 @@ def translate_http_error(http_error: Exception, http_url: str) -> Exception:
     """
     if isinstance(http_error, HttpException):
         return http_error
+    ori_error = http_error
+    if isinstance(http_error, MaxRetriesExceededError):
+        http_error = http_error.__cause__
     if isinstance(http_error, HTTPError):
         status_code = http_error.response.status_code
         if status_code == 401 or status_code == 403:
             return HttpPermissionError("Permission denied: %r" % http_url)
         elif status_code == 404:
             return HttpFileNotFoundError("No such file: %r" % http_url)
-    return HttpUnknownError(http_error, http_url)
+    return HttpUnknownError(ori_error, http_url)
 
 
 @contextmanager
@@ -476,6 +504,8 @@ def translate_hdfs_error(hdfs_error: Exception, hdfs_path: PathLike) -> Exceptio
         elif hdfs_error.status_code == 404:
             return FileNotFoundError(f"No match file: {hdfs_path}")
     # pytype: enable=attribute-error
+    if isinstance(hdfs_error, MaxRetriesExceededError):
+        return hdfs_error.__cause__
     return hdfs_error
 
 

megfile/fs_path.py

@@ -17,7 +17,6 @@ from megfile.interfaces import (
     Access,
     ContextIterator,
     FileEntry,
-    FileLike,
     PathLike,
     StatResult,
     URIPath,
@@ -29,6 +28,7 @@ from megfile.lib.joinpath import path_join
 from megfile.lib.url import get_url_scheme
 from megfile.smart_path import SmartPath
 from megfile.utils import calculate_md5, copyfd
+from megfile.utils.atomic import FSFuncForAtomic, WrapAtomic
 
 __all__ = [
     "FSPath",
@@ -115,36 +115,6 @@ def _fs_rename_file(
     shutil.move(src_path, dst_path)
 
 
-class WrapAtomic(FileLike):
-    __atomic__ = True
-
-    def __init__(self, fileobj):
-        self.fileobj = fileobj
-        self.temp_name = f"{self.name}.temp"
-        os.rename(self.name, self.temp_name)
-
-    @property
-    def name(self):
-        return self.fileobj.name
-
-    @property
-    def mode(self):
-        return self.fileobj.mode
-
-    def _close(self):
-        self.fileobj.close()
-        os.rename(self.temp_name, self.name)
-
-    def _abort(self):
-        try:
-            os.unlink(self.temp_name)
-        except FileNotFoundError:
-            pass
-
-    def __getattr__(self, name: str):
-        return getattr(self.fileobj, name)
-
-
 @SmartPath.register
 class FSPath(URIPath):
     """file protocol
@@ -995,7 +965,30 @@ class FSPath(URIPath):
                     self.path_without_protocol  # pyre-ignore[6]
                 )
             ).mkdir(parents=True, exist_ok=True)
-        fp = io.open(
+
+        if atomic and mode not in ("r", "rb"):
+            if isinstance(self.path_without_protocol, int):
+                raise TypeError("atomic is not supported for file descriptor path")
+
+            fs_func = FSFuncForAtomic(
+                exists=os.path.exists,
+                copy=shutil.copyfile,
+                replace=os.replace,
+                open=io.open,
+                unlink=os.unlink,
+            )
+            return WrapAtomic(
+                self.path_without_protocol,
+                mode,
+                fs_func,
+                buffering=buffering,
+                encoding=encoding,
+                errors=errors,
+                newline=newline,
+                closefd=closefd,
+            )
+
+        return io.open(
             self.path_without_protocol,
             mode,
             buffering=buffering,
@@ -1004,9 +997,6 @@ class FSPath(URIPath):
             newline=newline,
             closefd=closefd,
         )
-        if atomic and ("w" in mode or "x" in mode or "a" in mode):
-            return WrapAtomic(fp)
-        return fp
 
     @cached_property
     def parts(self) -> Tuple[str, ...]:

megfile/hdfs_path.py

@@ -4,6 +4,7 @@ import io
 import os
 import sys
 from functools import cached_property, lru_cache
+from logging import getLogger
 from typing import IO, BinaryIO, Iterator, List, Optional, Tuple
 
 from megfile.config import (
@@ -26,6 +27,8 @@ __all__ = [
     "is_hdfs",
 ]
 
+_logger = getLogger(__name__)
+
 HDFS_USER = "HDFS_USER"
 HDFS_URL = "HDFS_URL"
 HDFS_ROOT = "HDFS_ROOT"
@@ -590,6 +593,7 @@ class HdfsPath(URIPath):
         max_buffer_size: int = READER_MAX_BUFFER_SIZE,
         block_forward: Optional[int] = None,
         block_size: int = READER_BLOCK_SIZE,
+        atomic: bool = False,
         **kwargs,
     ) -> IO:
         """
@@ -619,6 +623,12 @@ class HdfsPath(URIPath):
         elif not encoding:
             encoding = sys.getdefaultencoding()
 
+        if atomic:
+            _logger.warning(
+                "`atomic` parameter in HdfsPath.open is not supported yet. "
+                "The parameter will be ignored."
+            )
+
         with raise_hdfs_error(self.path_with_protocol):
             if mode in ("r", "rb"):
                 file_obj = HdfsPrefetchReader(

megfile/lib/base_memory_handler.py

@@ -10,6 +10,8 @@ class BaseMemoryHandler(Readable[bytes], Seekable, Writable[bytes], ABC):
     def __init__(
         self,
         mode: str,
+        *,
+        atomic: bool = False,
     ):
         self._mode = mode
 
@@ -19,6 +21,9 @@ class BaseMemoryHandler(Readable[bytes], Seekable, Writable[bytes], ABC):
         self._fileobj = BytesIO()
         self._download_fileobj()
 
+        if atomic:
+            self.__atomic__ = True
+
     @property
     @abstractmethod
     def name(self) -> str:
@@ -90,3 +95,7 @@ class BaseMemoryHandler(Readable[bytes], Seekable, Writable[bytes], ABC):
             if need_upload:
                 self._upload_fileobj()
             self._fileobj.close()
+
+    def _abort(self):
+        if hasattr(self, "_fileobj"):
+            self._fileobj.close()

megfile/lib/s3_cached_handler.py

@@ -17,6 +17,7 @@ class S3CachedHandler(S3MemoryHandler):
         cache_path: Optional[str] = None,
         remove_cache_when_open: bool = True,
         profile_name: Optional[str] = None,
+        atomic: bool = False,
     ):
         self._bucket = bucket
         self._key = key
@@ -37,6 +38,9 @@ class S3CachedHandler(S3MemoryHandler):
         if remove_cache_when_open:
             os.unlink(self._cache_path)  # pyre-ignore[6]
 
+        if atomic:
+            self.__atomic__ = True
+
     def fileno(self) -> int:
         # allow numpy.array to create a memmaped ndarray
         return self._fileobj.fileno()

megfile/lib/s3_memory_handler.py

@@ -19,12 +19,13 @@ class S3MemoryHandler(BaseMemoryHandler):
         *,
         s3_client,
         profile_name: Optional[str] = None,
+        atomic: bool = False,
     ):
         self._bucket = bucket
         self._key = key
         self._client = s3_client
         self._profile_name = profile_name
-        super().__init__(mode=mode)
+        super().__init__(mode=mode, atomic=atomic)
 
     @property
     def name(self) -> str:

megfile/lib/webdav_memory_handler.py

@@ -48,11 +48,12 @@ class WebdavMemoryHandler(BaseMemoryHandler):
         *,
         webdav_client: WebdavClient,
         name: str,
+        atomic: bool = False,
     ):
         self._remote_path = remote_path
         self._client = webdav_client
         self._name = name
-        super().__init__(mode=mode)
+        super().__init__(mode=mode, atomic=atomic)
 
     @property
     def name(self) -> str:

megfile/pathlike.py

@@ -565,7 +565,7 @@ class BasePath:
 
     @cached_property
     def anchor(self) -> str:
-        return self.root  # pyre-ignore[7]
+        return self.root
 
     def joinpath(self: Self, *other_paths: "PathLike") -> Self:
         """
@@ -863,7 +863,7 @@ class URIPath(BasePath):
         path = path.lstrip("/")
         if path != "":
             parts.extend(path.split("/"))
-        return tuple(parts)  # pyre-ignore[7]
+        return tuple(parts)
 
     @cached_property
     def parents(self) -> "URIPathParents":
@@ -917,10 +917,18 @@ class URIPathParents(Sequence):
             self.parts = parts
 
     def __len__(self):
+        if (
+            (self.prefix == "" or "://" in self.prefix)
+            and len(self.parts) > 0
+            and self.parts[0] != "/"
+        ):
+            return len(self.parts)
         return max(len(self.parts) - 1, 0)
 
     def __getitem__(self, idx):
-        if idx < 0 or idx > len(self):
+        if idx < 0:
+            idx += len(self)
+        if idx < 0 or idx >= len(self):
             raise IndexError(idx)
 
         if len(self.parts[: -idx - 1]) > 1:

megfile/s3_path.py

@@ -76,9 +76,9 @@ from megfile.lib.url import get_url_scheme
 from megfile.smart_path import SmartPath
 from megfile.utils import (
     _is_pickle,
+    binary_open,
     calculate_md5,
     generate_cache_path,
-    get_binary_mode,
     get_content_offset,
     is_domain_or_subdomain,
     is_readable,
@@ -683,11 +683,15 @@ def _s3_binary_mode(s3_open_func):
                 raise S3FileExistsError("File exists: %r" % s3_url)
             mode = mode.replace("x", "w")
 
-        fileobj = s3_open_func(s3_url, get_binary_mode(mode), **kwargs)
-        if "b" not in mode:
-            fileobj = io.TextIOWrapper(fileobj, encoding=encoding, errors=errors)  # type: ignore
-            fileobj.mode = mode  # pyre-ignore[41]
-        return fileobj
+        return binary_open(
+            s3_open_func,
+        )(
+            s3_url,
+            mode,
+            encoding=encoding,
+            errors=errors,
+            **kwargs,
+        )
 
     return wrapper
 
@@ -991,7 +995,12 @@ def s3_buffered_open(
     if "a" in mode or "+" in mode:
         if cache_path is None:
             return S3MemoryHandler(
-                bucket, key, mode, s3_client=client, profile_name=s3_url._profile_name
+                bucket,
+                key,
+                mode,
+                s3_client=client,
+                profile_name=s3_url._profile_name,
+                atomic=atomic,
             )
         return S3CachedHandler(
             bucket,
@@ -1000,6 +1009,7 @@ def s3_buffered_open(
             s3_client=client,
             cache_path=cache_path,
             profile_name=s3_url._profile_name,
+            atomic=atomic,
         )
 
     if mode == "rb":

megfile/sftp_path.py

@@ -24,6 +24,7 @@ from megfile.lib.glob import FSFunc, iglob
 from megfile.pathlike import URIPath
 from megfile.smart_path import SmartPath
 from megfile.utils import calculate_md5, copyfileobj, thread_local
+from megfile.utils.atomic import FSFuncForAtomic, WrapAtomic
 
 _logger = get_logger(__name__)
 
@@ -1234,6 +1235,7 @@ class SftpPath(URIPath):
         buffering=-1,
         encoding: Optional[str] = None,
         errors: Optional[str] = None,
+        atomic: bool = False,
         **kwargs,
     ) -> IO:
         """Open a file on the path.
@@ -1253,6 +1255,26 @@ class SftpPath(URIPath):
             self.parent.mkdir(parents=True, exist_ok=True)
         elif not self.exists():
             raise FileNotFoundError("No such file: %r" % self.path_with_protocol)
+
+        if atomic and mode not in ("r", "rb"):
+            fs_func = FSFuncForAtomic(
+                exists=lambda path: self.from_path(path).exists(),
+                copy=lambda src, dst: self.from_path(src).copy(dst),
+                replace=lambda src, dst: self.from_path(src).replace(dst),
+                open=lambda path, *args, **kwargs: self.from_path(path).open(
+                    *args, **kwargs
+                ),
+                unlink=lambda path: self.from_path(path).unlink(),
+            )
+            return WrapAtomic(
+                self.path_with_protocol,
+                mode,
+                fs_func,
+                buffering=buffering,
+                encoding=encoding,
+                errors=errors,
+            )
+
         fileobj = self._client.open(self._real_path, mode, bufsize=buffering)
         fileobj.name = self.path
         if "r" in mode and "b" not in mode:

megfile/utils/__init__.py

@@ -13,7 +13,6 @@ from io import (
     BytesIO,
     StringIO,
     TextIOBase,
-    TextIOWrapper,
 )
 from threading import RLock
 from typing import IO, Callable, List, Optional
@@ -23,6 +22,7 @@ from megfile.config import (
     DEFAULT_HASH_BUFFER_SIZE,
     READER_LAZY_PREFETCH,
 )
+from megfile.utils.atomic import AtomicTextIOWrapper
 from megfile.utils.mutex import ProcessLocal, ThreadLocal
 
 
@@ -210,7 +210,7 @@ def binary_open(open_func):
     ):
         fileobj = open_func(path, get_binary_mode(mode), **kwargs)
         if "b" not in mode:
-            fileobj = TextIOWrapper(fileobj, encoding=encoding, errors=errors)
+            fileobj = AtomicTextIOWrapper(fileobj, encoding=encoding, errors=errors)
             fileobj.mode = mode  # pyre-ignore[41]
         return fileobj
 

megfile/utils/atomic.py

@@ -0,0 +1,143 @@
+import typing as T
+from io import TextIOWrapper
+from logging import getLogger
+
+from megfile.interfaces import FileLike
+
+_logger = getLogger(__name__)
+
+
+class FSFuncForAtomic(T.NamedTuple):
+    exists: T.Callable[[str], bool]
+    copy: T.Callable[[str, str], T.Any]
+    replace: T.Callable[[str, str], T.Any]
+    open: T.Callable[..., T.IO]
+    unlink: T.Callable[[str], T.Any]
+
+
+class WrapAtomic(FileLike):
+    """Wrap a file object to provide atomic close/abort semantics."""
+
+    __atomic__ = True
+
+    def __init__(
+        self,
+        path: str,
+        mode: str,
+        fs_func: FSFuncForAtomic,
+        *,
+        buffering: int = -1,
+        encoding: T.Optional[str] = None,
+        errors: T.Optional[str] = None,
+        newline: T.Optional[str] = None,
+        closefd: bool = True,
+    ):
+        self.fs_func = fs_func
+        if "x" in mode and self.fs_func.exists(path):
+            raise FileExistsError(f"File exists: {path}")
+
+        self._path = path
+        self._mode = mode
+        self._temp_path = self._path + ".temp"
+
+        if self._should_copy():
+            self.fs_func.copy(self._path, self._temp_path)
+
+        # Open temp file with the same mode/encoding parameters.
+        open_mode = mode.replace("x", "w", 1) if "x" in mode else mode
+
+        self.fileobj = self.fs_func.open(
+            self._temp_path,
+            open_mode,
+            buffering=buffering,
+            encoding=encoding,
+            errors=errors,
+            newline=newline,
+            closefd=closefd,
+        )
+
+        self.read = self.fileobj.read
+        self.readline = self.fileobj.readline
+        self.readlines = self.fileobj.readlines
+        self.write = self.fileobj.write
+        self.writelines = self.fileobj.writelines
+        self.truncate = self.fileobj.truncate
+        self.seek = self.fileobj.seek
+        self.tell = self.fileobj.tell
+        self.flush = self.fileobj.flush
+        self.readable = self.fileobj.readable
+        self.writable = self.fileobj.writable
+        self.seekable = self.fileobj.seekable
+
+    @property
+    def name(self):
+        return self._path
+
+    @property
+    def mode(self):
+        return self._mode
+
+    def _should_copy(self) -> bool:
+        if self.fs_func.exists(self._path):
+            return True
+        return False
+
+    def _close(self):
+        self.fileobj.close()
+        self.fs_func.replace(self._temp_path, self._path)
+
+    def _abort(self):
+        try:
+            self.fileobj.close()
+        except Exception:
+            pass
+        try:
+            self.fs_func.unlink(self._temp_path)
+        except FileNotFoundError:
+            pass
+
+
+class AtomicTextIOWrapper(TextIOWrapper):
+    """TextIOWrapper that keeps atomic semantics of the underlying raw object."""
+
+    def __init__(self, buffer, *args, **kwargs):
+        # Keep a reference to the raw object so we can call abort later.
+        self._raw = buffer
+        super().__init__(buffer, *args, **kwargs)
+
+    @property
+    def atomic(self) -> bool:
+        return getattr(self._raw, "atomic", False)
+
+    def abort(self) -> bool:
+        """Abort the atomic operation.
+
+        Returns:
+            bool: True if the abort was performed, False otherwise.
+        """
+        if hasattr(self._raw, "abort"):
+            return self._raw._abort()
+        return False
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.atomic and exc_val is not None:
+            if self.abort():
+                from megfile.errors import full_error_message
+
+                _logger.warning(
+                    f"skip closing atomic file-like object: {self}, "
+                    f"since error encountered: {full_error_message(exc_val)}"
+                )
+            return
+
+        super().__exit__(exc_type, exc_val, exc_tb)
+
+    def __del__(self):
+        if self.atomic:
+            if self.abort():
+                _logger.warning(
+                    f"skip closing atomic file-like object before deletion: {self}"
+                )
+            return
+        self.flush()
+        self.close()

megfile/version.py

@@ -1 +1 @@
-VERSION = "5.0.2"
+VERSION = "5.0.4"

megfile/webdav_path.py

@@ -800,6 +800,7 @@ class WebdavPath(URIPath):
         max_buffer_size: int = READER_MAX_BUFFER_SIZE,
         block_forward: Optional[int] = None,
         block_size: int = READER_BLOCK_SIZE,
+        atomic: bool = False,
         **kwargs,
     ) -> IO:
         """Open a file on the path.
@@ -840,6 +841,7 @@ class WebdavPath(URIPath):
             mode,
             webdav_client=self._client,
             name=self.path_with_protocol,
+            atomic=atomic,
         )
 
     def chmod(self, mode: int, *, follow_symlinks: bool = True):

{megfile-5.0.2.dist-info → megfile-5.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: megfile
-Version: 5.0.2
+Version: 5.0.4
 Summary: Megvii file operation library
 Author-email: megvii-reng <megvii-reng@googlegroups.com>
 Project-URL: Homepage, https://github.com/megvii-research/megfile
@@ -59,7 +59,7 @@ megfile - Megvii FILE library
 * Faster file read and write operations
 * Excellent error retry mechanism to help you handle network issues
 * Supports popular protocols, even making it easy to use the same protocol with different endpoints
-* Stable and secure, with CI coverage over 95%, used by multiple industry giants
+* Stable and secure, with high CI test coverage, used by multiple industry giants
 * Perfect type hints and built-in documentation. You can enjoy the IDE's auto-completion and static checking
 
 ## Support Protocols

{megfile-5.0.2.dist-info → megfile-5.0.4.dist-info}/RECORD

@@ -1,22 +1,22 @@
 megfile/__init__.py,sha256=4XbMsR-lM7MxbnPGBI16m2sq6ghuA2-zZj2XF4bbX2Y,3291
-megfile/cli.py,sha256=HdOIAMFXdZw79kayVIri5-_rbq_KwOGSdMYTx51ABp0,30204
+megfile/cli.py,sha256=TjUhfcOB_weEBa_e55nmiajq_XObAhQa7sx5oivrQCw,30620
 megfile/config.py,sha256=K3B_o2dnI7qGsGnK8Jg18-S5YYLYuzskfNJowlSMkQM,5065
-megfile/errors.py,sha256=eC7z-2-QqE12pYgTGAOIlEBsemqcMyeBFVUEDz3gBS0,15585
-megfile/fs_path.py,sha256=tt2__W6E4vep0lmVreTLIW63njl-EzyQEEkEGziyAb4,41015
-megfile/hdfs_path.py,sha256=OmUe3vA3Qoxnqtcq0Rs3ygBvzAtqUz3fGo8iP5sWneE,26058
+megfile/errors.py,sha256=zKwM5r5j89mlbWZNeax26Hq63NmQhl9iGMfTtgyvYNA,16830
+megfile/fs_path.py,sha256=RxdhMDoc1HRmQtyaCehEGk_UJtHGLrrwiUIHrS4LJiY,41027
+megfile/hdfs_path.py,sha256=PWqws54Ou136VxaYp9K_UFRr5BoiZWsO330n9ig5IG0,26338
 megfile/http_path.py,sha256=08OmzmRMyLSyq1Yr1K2HbzexesURJrIoA6AibwYzUiA,13844
 megfile/interfaces.py,sha256=XU46U5pl4k1Gse63i4z5SvxcjWeKLj0xyB0Y6fYiWWo,9887
-megfile/pathlike.py,sha256=kacTG55j3dq3b7YP7MT7jxeJGbDwvK3XuZIvF-UUE0o,31244
-megfile/s3_path.py,sha256=LINHnHnpesXnf9wxbV6n0xQVT0wPwyjLc7xAasakefU,94467
+megfile/pathlike.py,sha256=4RuYHqUc5_6rZDCcVo_18il0Hy7BlOYt-rtYwCtp9Gg,31446
+megfile/s3_path.py,sha256=C6z6pqZb0LMlNqUbZiaC8_deKX3feGxfPfSYjusqJq0,94507
 megfile/sftp2_path.py,sha256=K90bnMVAx0MQPGXP6LogGuDRzaD4MPR6lMOfdY9C9-0,37942
-megfile/sftp_path.py,sha256=_KU7_-Mq2m7lcLY1mpiGrju0SP-OsdEXlRjFhZH25UA,51223
+megfile/sftp_path.py,sha256=zxuT1hk7sgoOUwq6KBXS__caX8Hk_LgPjINQheTZWAU,52063
 megfile/smart.py,sha256=Lab2jxprj-zvPw5GqUWlWiEY8bcpRlviks_qp9r-km8,38224
 megfile/smart_path.py,sha256=kGidkM5S58ChE3LVZMcUACs3IQgsqh9m04sp6-wxuhk,12615
 megfile/stdio_path.py,sha256=cxaDr8rtisTPnN-rjtaEpqQnshwiqwXFUJBM9xWY7Cg,2711
-megfile/version.py,sha256=2z_YV6M_rFsVnaPW0uk4dTnt4IynxvGR09iBXCfO_Po,19
-megfile/webdav_path.py,sha256=xQmZMt-hDA7PfHzuSjRYaIoJA_Nbi1jsg952KZJhs-E,31364
+megfile/version.py,sha256=nxcOThQpxgVcGzsD8ROZ-d6RNNhY7dxyBkl0oU0Aahs,19
+megfile/webdav_path.py,sha256=QrRYKBGWXkUZXEeHxAfVJkxnCfnczocBSRkVgDC_qC4,31421
 megfile/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-megfile/lib/base_memory_handler.py,sha256=i5-YHpL0k2tuFBnP9VMzb3_OsaU6D6j6thkmWgptnFg,2680
+megfile/lib/base_memory_handler.py,sha256=K4mq28vXVQD-05I64AMH2_7_3y5n7splcMNQZ7jYdxw,2871
 megfile/lib/base_prefetch_reader.py,sha256=MYaWOkXc3geZMYNPHlPZmmpOR6uSz-AMuCZwYdoz7t0,13296
 megfile/lib/combine_reader.py,sha256=Kp2wEloOUpTlIU7dve87MBpSzmIM-F9OtpTawAjFkiU,4828
 megfile/lib/compare.py,sha256=CPSbyqsQ396oSfxa7h0NdUUqBw5A3WOn6fHrNKkuinw,2188
@@ -29,23 +29,24 @@ megfile/lib/http_prefetch_reader.py,sha256=x0m5tKN8QLl5QkZyNEDW662UJaZoMf61GDHVv
 megfile/lib/joinpath.py,sha256=R3sz3pvcgbv1e793vZUnwGH-NmDlEghEPNwq5IEMm4I,1251
 megfile/lib/lazy_handler.py,sha256=bE7RGt1x_xYWMgGAvHr7dwEt52qy-D3z90X3oyCvE6g,1875
 megfile/lib/s3_buffered_writer.py,sha256=a42tr48QXToTQtZD1XfK1Veju6qLCLF0RJC0V_P3pW8,8252
-megfile/lib/s3_cached_handler.py,sha256=MkNt6AAapd5x8BH2gnW5_S0cLofN-mshEdb0qSoLho8,1426
+megfile/lib/s3_cached_handler.py,sha256=_57t5wO3N1B2HhxGy2sRKStUm-XFrpGZJO9DkgLMHKk,1511
 megfile/lib/s3_limited_seekable_writer.py,sha256=rBlGCsrIJdVRKdsJ1uIAE_R6EN96Kl2JMskk-5czYmE,6289
-megfile/lib/s3_memory_handler.py,sha256=YHakyN21hvBoSlGXSV1UfFMFBh3WJNYWmiwyEzmIytw,2125
+megfile/lib/s3_memory_handler.py,sha256=6gWFlVgwJSHssofP5HJ5AuGHwkL6r1Fh8UR-H7g-GJ0,2170
 megfile/lib/s3_pipe_handler.py,sha256=g3iAN1P9pCdvSNsGeJBGcBa10S62oqIg_9W3b3wc7os,3809
 megfile/lib/s3_prefetch_reader.py,sha256=AqfADmbbZYA6nw4vxBOiFWX5q5CSYOd0hq1LWcf1PY0,4524
 megfile/lib/s3_share_cache_reader.py,sha256=8uip5IdVjPXCquXrskjocsZx2-TiXqWZPY0gX8JC144,4020
 megfile/lib/shadow_handler.py,sha256=TntewlvIW9ZxCfmqASDQREHoiZ8v42faOe9sovQYQz0,2779
 megfile/lib/stdio_handler.py,sha256=IDdgENLQlhigEwkLL4zStueVSzdWg7xVcTF_koof_Ek,1987
 megfile/lib/url.py,sha256=ER32pWy9Q2MAk3TraAaNEBWIqUeBmLuM57ol2cs7-Ks,103
-megfile/lib/webdav_memory_handler.py,sha256=_UccPYPpvfTd4gSEhBFL1BHeyFtsBJdhVINkjNNtyaw,2506
+megfile/lib/webdav_memory_handler.py,sha256=7nq4o69ck_7dFh6xlYTBG8-rj49Q7gxwa3V2bHXEQz4,2551
 megfile/lib/webdav_prefetch_reader.py,sha256=M0X6E6t-DS5q9KiLvjVZx_AZuiW9SaIkBnIPLc774GQ,3941
-megfile/utils/__init__.py,sha256=4hBVSXbNTbDj7Je0y9SbwgcPm_s41H9v3eHUMr9JNGo,12700
+megfile/utils/__init__.py,sha256=lfJze58nO18ug8EUfSJgTTxOwj1p7FQdsnO1keBeMSo,12740
+megfile/utils/atomic.py,sha256=W3NInmDxytBBecktxY_D3S4rA0SX2v2M13ab8jXa4Yk,4061
 megfile/utils/mutex.py,sha256=asb8opGLgK22RiuBJUnfsvB8LnMmodP8KzCVHKmQBWA,2561
-megfile-5.0.2.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-megfile-5.0.2.dist-info/licenses/LICENSE.pyre,sha256=9lf5nT-5ZH25JijpYAequ0bl8E8z5JmZB1qrjiUMp84,1080
-megfile-5.0.2.dist-info/METADATA,sha256=TvjBMScDXQdbke5lhUufQg2B-KY7XywLn-VpQkfQsfw,9225
-megfile-5.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-megfile-5.0.2.dist-info/entry_points.txt,sha256=M6ZWSSv5_5_QtIpZafy3vq7WuOJ_5dSGQQnEZbByt2Q,49
-megfile-5.0.2.dist-info/top_level.txt,sha256=i3rMgdU1ZAJekAceojhA-bkm3749PzshtRmLTbeLUPQ,8
-megfile-5.0.2.dist-info/RECORD,,
+megfile-5.0.4.dist-info/licenses/LICENSE,sha256=xuY_rHyygMLmf0LgkKj_-wb-BxveHp9rTN0VDE73PrE,11365
+megfile-5.0.4.dist-info/licenses/LICENSE.pyre,sha256=9lf5nT-5ZH25JijpYAequ0bl8E8z5JmZB1qrjiUMp84,1080
+megfile-5.0.4.dist-info/METADATA,sha256=1SCUBMhm0XIjq06T-utC_zgtakXc3qjJF29a4-Yljvo,9226
+megfile-5.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+megfile-5.0.4.dist-info/entry_points.txt,sha256=M6ZWSSv5_5_QtIpZafy3vq7WuOJ_5dSGQQnEZbByt2Q,49
+megfile-5.0.4.dist-info/top_level.txt,sha256=i3rMgdU1ZAJekAceojhA-bkm3749PzshtRmLTbeLUPQ,8
+megfile-5.0.4.dist-info/RECORD,,

{megfile-5.0.2.dist-info → megfile-5.0.4.dist-info}/licenses/LICENSE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright [megvii-reng] [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.
@@ -199,4 +199,4 @@
    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.
+   limitations under the License.