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

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/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.3"
+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.3.dist-info → megfile-5.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: megfile
-Version: 5.0.3
+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.3.dist-info → megfile-5.0.4.dist-info}/RECORD

@@ -2,21 +2,21 @@ megfile/__init__.py,sha256=4XbMsR-lM7MxbnPGBI16m2sq6ghuA2-zZj2XF4bbX2Y,3291
 megfile/cli.py,sha256=TjUhfcOB_weEBa_e55nmiajq_XObAhQa7sx5oivrQCw,30620
 megfile/config.py,sha256=K3B_o2dnI7qGsGnK8Jg18-S5YYLYuzskfNJowlSMkQM,5065
 megfile/errors.py,sha256=zKwM5r5j89mlbWZNeax26Hq63NmQhl9iGMfTtgyvYNA,16830
-megfile/fs_path.py,sha256=tt2__W6E4vep0lmVreTLIW63njl-EzyQEEkEGziyAb4,41015
-megfile/hdfs_path.py,sha256=OmUe3vA3Qoxnqtcq0Rs3ygBvzAtqUz3fGo8iP5sWneE,26058
+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=4RuYHqUc5_6rZDCcVo_18il0Hy7BlOYt-rtYwCtp9Gg,31446
-megfile/s3_path.py,sha256=LINHnHnpesXnf9wxbV6n0xQVT0wPwyjLc7xAasakefU,94467
+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=ayvDTXMtNAcyGKXxogED3ZAvUOOsfQYG6VqgcDYL7o8,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.3.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-megfile-5.0.3.dist-info/licenses/LICENSE.pyre,sha256=9lf5nT-5ZH25JijpYAequ0bl8E8z5JmZB1qrjiUMp84,1080
-megfile-5.0.3.dist-info/METADATA,sha256=qc9JcTR52y09F_lY2fiCuwCkeRzfekculMSNeXBEP_g,9225
-megfile-5.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-megfile-5.0.3.dist-info/entry_points.txt,sha256=M6ZWSSv5_5_QtIpZafy3vq7WuOJ_5dSGQQnEZbByt2Q,49
-megfile-5.0.3.dist-info/top_level.txt,sha256=i3rMgdU1ZAJekAceojhA-bkm3749PzshtRmLTbeLUPQ,8
-megfile-5.0.3.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.3.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.