megfile 4.2.5__py3-none-any.whl → 5.0.0__py3-none-any.whl

megfile/lib/base_memory_handler.py

@@ -0,0 +1,92 @@
+import os
+from abc import ABC, abstractmethod
+from io import BytesIO, UnsupportedOperation
+from typing import Iterable, List, Optional
+
+from megfile.interfaces import Readable, Seekable, Writable
+
+
+class BaseMemoryHandler(Readable[bytes], Seekable, Writable[bytes], ABC):
+    def __init__(
+        self,
+        mode: str,
+    ):
+        self._mode = mode
+
+        if mode not in ("rb", "wb", "ab", "rb+", "wb+", "ab+"):
+            raise ValueError("unacceptable mode: %r" % mode)
+
+        self._fileobj = BytesIO()
+        self._download_fileobj()
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @property
+    def mode(self) -> str:
+        return self._mode
+
+    def tell(self) -> int:
+        return self._fileobj.tell()
+
+    def seek(self, offset: int, whence: int = os.SEEK_SET) -> int:
+        return self._fileobj.seek(offset, whence)
+
+    def readable(self) -> bool:
+        return self._mode[0] == "r" or self._mode[-1] == "+"
+
+    def read(self, size: Optional[int] = None) -> bytes:
+        if not self.readable():
+            raise UnsupportedOperation("not readable")
+        return self._fileobj.read(size)
+
+    def readline(self, size: Optional[int] = None) -> bytes:
+        if not self.readable():
+            raise UnsupportedOperation("not readable")
+        if size is None:
+            size = -1
+        return self._fileobj.readline(size)
+
+    def readlines(self, hint: Optional[int] = None) -> List[bytes]:
+        if not self.readable():
+            raise UnsupportedOperation("not readable")
+        if hint is None:
+            hint = -1
+        return self._fileobj.readlines(hint)
+
+    def writable(self) -> bool:
+        return self._mode[0] == "w" or self._mode[0] == "a" or self._mode[-1] == "+"
+
+    def flush(self):
+        self._fileobj.flush()
+
+    def write(self, data: bytes) -> int:
+        if not self.writable():
+            raise UnsupportedOperation("not writable")
+        if self._mode[0] == "a":
+            self.seek(0, os.SEEK_END)
+        return self._fileobj.write(data)
+
+    def writelines(self, lines: Iterable[bytes]):
+        if not self.writable():
+            raise UnsupportedOperation("not writable")
+        if self._mode[0] == "a":
+            self.seek(0, os.SEEK_END)
+        self._fileobj.writelines(lines)
+
+    @abstractmethod
+    def _download_fileobj(self):
+        pass
+
+    @abstractmethod
+    def _upload_fileobj(self):
+        pass
+
+    def _close(self, need_upload: bool = True):
+        if hasattr(self, "_fileobj"):
+            need_upload = need_upload and self.writable()
+            if need_upload:
+                self._upload_fileobj()
+            self._fileobj.close()

megfile/lib/glob.py

@@ -289,9 +289,9 @@ def get_non_glob_dir(glob: str):
     root_dir = []
     if glob.startswith("/"):
         root_dir.append("/")
-    elif "://" in glob:
-        protocol, glob = glob.split("://", 1)
-        root_dir.append(f"{protocol}://")
+    elif "//" in glob:
+        protocol_or_domain, glob = glob.rsplit("//", 1)
+        root_dir.append(f"{protocol_or_domain}//")
     for name in glob.split("/"):
         if has_magic(name):
             break

megfile/lib/http_prefetch_reader.py

@@ -85,29 +85,29 @@ class HttpPrefetchReader(BasePrefetchReader):
                         "Cookies": response.cookies,
                         "StatusCode": response.status_code,
                     }
-            else:
-                range_end = end
-                if self._content_size is not None:
-                    range_end = min(range_end, self._content_size - 1)
-                headers = {"Range": f"bytes={start}-{range_end}"}
-                with self._session.get(
-                    fspath(self._url), headers=headers, stream=True
-                ) as response:
-                    if len(response.content) != int(response.headers["Content-Length"]):
-                        raise HttpBodyIncompleteError(
-                            "The downloaded content is incomplete, "
-                            "expected size: %s, actual size: %d"
-                            % (
-                                response.headers["Content-Length"],
-                                len(response.content),
-                            )
+
+            range_end = end
+            if self._content_size is not None:
+                range_end = min(range_end, self._content_size - 1)
+            headers = {"Range": f"bytes={start}-{range_end}"}
+            with self._session.get(
+                fspath(self._url), headers=headers, stream=True
+            ) as response:
+                if len(response.content) != int(response.headers["Content-Length"]):
+                    raise HttpBodyIncompleteError(
+                        "The downloaded content is incomplete, "
+                        "expected size: %s, actual size: %d"
+                        % (
+                            response.headers["Content-Length"],
+                            len(response.content),
                         )
-                    return {
-                        "Body": BytesIO(response.content),
-                        "Headers": response.headers,
-                        "Cookies": response.cookies,
-                        "StatusCode": response.status_code,
-                    }
+                    )
+                return {
+                    "Body": BytesIO(response.content),
+                    "Headers": response.headers,
+                    "Cookies": response.cookies,
+                    "StatusCode": response.status_code,
+                }
 
         fetch_response = patch_method(
             fetch_response,

megfile/lib/s3_memory_handler.py

@@ -1,17 +1,16 @@
 import os
-from io import BytesIO, UnsupportedOperation
-from typing import Iterable, List, Optional
+from typing import Optional
 
 from megfile.errors import (
     S3ConfigError,
-    UnknownError,
-    raise_s3_error,
+    S3PermissionError,
+    S3UnknownError,
     translate_s3_error,
 )
-from megfile.interfaces import Readable, Seekable, Writable
+from megfile.lib.base_memory_handler import BaseMemoryHandler
 
 
-class S3MemoryHandler(Readable[bytes], Seekable, Writable[bytes]):
+class S3MemoryHandler(BaseMemoryHandler):
     def __init__(
         self,
         bucket: str,
@@ -23,75 +22,14 @@ class S3MemoryHandler(Readable[bytes], Seekable, Writable[bytes]):
     ):
         self._bucket = bucket
         self._key = key
-        self._mode = mode
         self._client = s3_client
         self._profile_name = profile_name
-
-        if mode not in ("rb", "wb", "ab", "rb+", "wb+", "ab+"):
-            raise ValueError("unacceptable mode: %r" % mode)
-
-        self._fileobj = BytesIO()
-        self._download_fileobj()
+        super().__init__(mode=mode)
 
     @property
     def name(self) -> str:
-        return "s3%s://%s/%s" % (
-            f"+{self._profile_name}" if self._profile_name else "",
-            self._bucket,
-            self._key,
-        )
-
-    @property
-    def mode(self) -> str:
-        return self._mode
-
-    def tell(self) -> int:
-        return self._fileobj.tell()
-
-    def seek(self, offset: int, whence: int = os.SEEK_SET) -> int:
-        return self._fileobj.seek(offset, whence)
-
-    def readable(self) -> bool:
-        return self._mode[0] == "r" or self._mode[-1] == "+"
-
-    def read(self, size: Optional[int] = None) -> bytes:
-        if not self.readable():
-            raise UnsupportedOperation("not readable")
-        return self._fileobj.read(size)
-
-    def readline(self, size: Optional[int] = None) -> bytes:
-        if not self.readable():
-            raise UnsupportedOperation("not readable")
-        if size is None:
-            size = -1
-        return self._fileobj.readline(size)
-
-    def readlines(self, hint: Optional[int] = None) -> List[bytes]:
-        if not self.readable():
-            raise UnsupportedOperation("not readable")
-        if hint is None:
-            hint = -1
-        return self._fileobj.readlines(hint)
-
-    def writable(self) -> bool:
-        return self._mode[0] == "w" or self._mode[0] == "a" or self._mode[-1] == "+"
-
-    def flush(self):
-        self._fileobj.flush()
-
-    def write(self, data: bytes) -> int:
-        if not self.writable():
-            raise UnsupportedOperation("not writable")
-        if self._mode[0] == "a":
-            self.seek(0, os.SEEK_END)
-        return self._fileobj.write(data)
-
-    def writelines(self, lines: Iterable[bytes]):
-        if not self.writable():
-            raise UnsupportedOperation("not writable")
-        if self._mode[0] == "a":
-            self.seek(0, os.SEEK_END)
-        self._fileobj.writelines(lines)
+        protocol = f"s3+{self._profile_name}" if self._profile_name else "s3"
+        return f"{protocol}://{self._bucket}/{self._key}"
 
     def _translate_error(self, error: Exception):
         return translate_s3_error(error, self.name)
@@ -101,15 +39,14 @@ class S3MemoryHandler(Readable[bytes], Seekable, Writable[bytes]):
             self._client.head_object(Bucket=self._bucket, Key=self._key)
         except Exception as error:
             error = self._translate_error(error)
-            if isinstance(error, (UnknownError, S3ConfigError)):
+            if isinstance(error, (S3UnknownError, S3ConfigError, S3PermissionError)):
                 raise error
             return False
         return True
 
     def _download_fileobj(self):
-        need_download = self._mode[0] == "r" or (
-            self._mode[0] == "a" and self._file_exists()
-        )
+        need_download = self._mode[0] == "r"
+        need_download = need_download or (self._mode[0] == "a" and self._file_exists())
         if not need_download:
             return
         # directly download to the file handle
@@ -126,11 +63,7 @@ class S3MemoryHandler(Readable[bytes], Seekable, Writable[bytes]):
             return
         # directly upload from file handle
         self.seek(0, os.SEEK_SET)
-        with raise_s3_error(self.name):
+        try:
             self._client.upload_fileobj(self._fileobj, self._bucket, self._key)
-
-    def _close(self, need_upload: bool = True):
-        if hasattr(self, "_fileobj"):
-            if need_upload:
-                self._upload_fileobj()
-            self._fileobj.close()
+        except Exception as error:
+            raise self._translate_error(error)

megfile/lib/webdav_memory_handler.py

@@ -0,0 +1,83 @@
+import os
+
+from webdav3.client import Client as WebdavClient
+from webdav3.client import Urn, WebDavXmlUtils, wrap_connection_error
+from webdav3.exceptions import (
+    OptionNotValid,
+    RemoteResourceNotFound,
+)
+
+from megfile.lib.base_memory_handler import BaseMemoryHandler
+
+
+def _webdav_stat(client: WebdavClient, remote_path: str):
+    urn = Urn(remote_path)
+    response = client.execute_request(
+        action="info", path=urn.quote(), headers_ext=["Depth: 0"]
+    )
+    path = client.get_full_path(urn)
+    info = WebDavXmlUtils.parse_info_response(
+        response.content, path, client.webdav.hostname
+    )
+    info["is_dir"] = WebDavXmlUtils.parse_is_dir_response(
+        response.content, path, client.webdav.hostname
+    )
+    return info
+
+
+@wrap_connection_error
+def _webdav_download_from(client: WebdavClient, buff, remote_path):
+    urn = Urn(remote_path)
+    if client.is_dir(urn.path()):
+        raise OptionNotValid(name="remote_path", value=remote_path)
+
+    if not client.check(urn.path()):
+        raise RemoteResourceNotFound(urn.path())
+
+    response = client.execute_request(action="download", path=urn.quote())
+
+    for chunk in response.iter_content(chunk_size=client.chunk_size):
+        buff.write(chunk)
+
+
+class WebdavMemoryHandler(BaseMemoryHandler):
+    def __init__(
+        self,
+        remote_path: str,
+        mode: str,
+        *,
+        webdav_client: WebdavClient,
+        name: str,
+    ):
+        self._remote_path = remote_path
+        self._client = webdav_client
+        self._name = name
+        super().__init__(mode=mode)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def _file_exists(self) -> bool:
+        try:
+            return not _webdav_stat(self._client, self._remote_path)["is_dir"]
+        except RemoteResourceNotFound:
+            return False
+
+    def _download_fileobj(self):
+        need_download = self._mode[0] == "r"
+        need_download = need_download or (self._mode[0] == "a" and self._file_exists())
+        if not need_download:
+            return
+        # directly download to the file handle
+        _webdav_download_from(self._client, self._fileobj, self._remote_path)
+        if self._mode[0] == "r":
+            self.seek(0, os.SEEK_SET)
+
+    def _upload_fileobj(self):
+        need_upload = self.writable()
+        if not need_upload:
+            return
+        # directly upload from file handle
+        self.seek(0, os.SEEK_SET)
+        self._client.upload_to(self._fileobj, self._remote_path)

megfile/lib/webdav_prefetch_reader.py

@@ -0,0 +1,115 @@
+from io import BytesIO
+from typing import Optional
+
+from webdav3.client import Client as WebdavClient
+from webdav3.client import Urn
+
+from megfile.config import (
+    READER_BLOCK_SIZE,
+    READER_MAX_BUFFER_SIZE,
+    WEBDAV_MAX_RETRY_TIMES,
+)
+from megfile.errors import (
+    HttpBodyIncompleteError,
+    http_should_retry,
+    patch_method,
+)
+from megfile.lib.base_prefetch_reader import BasePrefetchReader
+from megfile.lib.webdav_memory_handler import _webdav_stat
+
+DEFAULT_TIMEOUT = (60, 60 * 60 * 24)
+
+
+class WebdavPrefetchReader(BasePrefetchReader):
+    """
+    Reader to fast read the http content, service must support Accept-Ranges.
+
+    This will divide the file content into equal parts of block_size size, and will use
+    LRU to cache at most blocks in max_buffer_size memory.
+
+    open(), seek() and read() will trigger prefetch read.
+
+    The prefetch will cached block_forward blocks of data from offset position
+    (the position after reading if the called function is read).
+    """
+
+    def __init__(
+        self,
+        remote_path: str,
+        *,
+        client: Optional[WebdavClient] = None,
+        block_size: int = READER_BLOCK_SIZE,
+        max_buffer_size: int = READER_MAX_BUFFER_SIZE,
+        block_forward: Optional[int] = None,
+        max_retries: int = WEBDAV_MAX_RETRY_TIMES,
+        max_workers: Optional[int] = None,
+    ):
+        self._urn = Urn(remote_path)
+        self._remote_path = remote_path
+        self._client = client or WebdavClient({})
+
+        super().__init__(
+            block_size=block_size,
+            max_buffer_size=max_buffer_size,
+            block_forward=block_forward,
+            max_retries=max_retries,
+            max_workers=max_workers,
+        )
+
+    def _get_content_size(self) -> int:
+        info = _webdav_stat(self._client, self._remote_path)
+        return int(info.get("size") or 0)
+
+    @property
+    def name(self) -> str:
+        return self._remote_path
+
+    def _fetch_response(
+        self, start: Optional[int] = None, end: Optional[int] = None
+    ) -> dict:
+        def fetch_response() -> dict:
+            if start is None or end is None:
+                with self._client.execute_request(
+                    action="download", path=self._urn.quote()
+                ) as response:
+                    return {
+                        "Headers": response.headers,
+                        "Cookies": response.cookies,
+                        "StatusCode": response.status_code,
+                    }
+
+            range_end = end
+            if self._content_size is not None:
+                range_end = min(range_end, self._content_size - 1)
+            headers_ext = [f"Range: bytes={start}-{range_end}"]
+            with self._client.execute_request(
+                action="download", path=self._urn.quote(), headers_ext=headers_ext
+            ) as response:
+                headers = response.headers
+                if (
+                    "Content-Length" in headers
+                    and len(response.content) != int(headers["Content-Length"])
+                    and not headers.get("Content-Encoding")
+                ):
+                    raise HttpBodyIncompleteError(
+                        "The downloaded content is incomplete, "
+                        "expected size: %s, actual size: %d"
+                        % (
+                            headers["Content-Length"],
+                            len(response.content),
+                        )
+                    )
+                return {
+                    "Body": BytesIO(response.content),
+                    "Headers": response.headers,
+                    "Cookies": response.cookies,
+                    "StatusCode": response.status_code,
+                }
+
+        fetch_response = patch_method(
+            fetch_response,
+            max_retries=self._max_retries,
+            should_retry=http_should_retry,
+        )
+
+        return fetch_response()

megfile/pathlike.py

@@ -22,7 +22,6 @@ from megfile.lib.compat import PathLike as _PathLike
 from megfile.lib.compat import fspath
 from megfile.lib.fnmatch import _compile_pattern
 from megfile.lib.joinpath import uri_join
-from megfile.utils import classproperty
 
 Self = TypeVar("Self")
 
@@ -556,15 +555,15 @@ class BasePath:
         ) as f:
             return f.write(data)
 
-    @classproperty
+    @cached_property
     def drive(self) -> str:
         return ""
 
-    @classproperty
+    @cached_property
     def root(self) -> str:
         return self.protocol + "://"
 
-    @classproperty
+    @cached_property
     def anchor(self) -> str:
         return self.root  # pyre-ignore[7]