megfile 3.0.5__py3-none-any.whl → 3.0.6.post1__py3-none-any.whl

megfile/cli.py

@@ -174,12 +174,14 @@ def ll(path: str, recursive: bool):
     is_flag=True,
     help='treat dst_path as a normal file.')
 @click.option('-g', '--progress-bar', is_flag=True, help='Show progress bar.')
+@click.option('--skip', is_flag=True, help='Skip existed files.')
 def cp(
         src_path: str,
         dst_path: str,
         recursive: bool,
         no_target_directory: bool,
         progress_bar: bool,
+        skip: bool,
 ):
     if not no_target_directory and (dst_path.endswith('/') or
                                     smart_isdir(dst_path)):
@@ -193,14 +195,16 @@ def cp(
                     dst_path,
                     followlinks=True,
                     map_func=executor.map,
-                    force=True)
+                    force=True,
+                    overwrite=not skip)
             else:
                 smart_sync(
                     src_path,
                     dst_path,
                     followlinks=True,
                     map_func=executor.map,
-                    force=True)
+                    force=True,
+                    overwrite=not skip)
     else:
         if progress_bar:
             file_size = smart_stat(src_path).size
@@ -214,10 +218,11 @@ def cp(
             def callback(length: int):
                 sbar.update(length)
 
-            smart_copy(src_path, dst_path, callback=callback)
+            smart_copy(
+                src_path, dst_path, callback=callback, overwrite=not skip)
             sbar.close()
         else:
-            smart_copy(src_path, dst_path)
+            smart_copy(src_path, dst_path, overwrite=not skip)
 
 
 @cli.command(short_help='Move files from source to dest.')
@@ -236,12 +241,14 @@ def cp(
     is_flag=True,
     help='treat dst_path as a normal file.')
 @click.option('-g', '--progress-bar', is_flag=True, help='Show progress bar.')
+@click.option('--skip', is_flag=True, help='Skip existed files.')
 def mv(
         src_path: str,
         dst_path: str,
         recursive: bool,
         no_target_directory: bool,
         progress_bar: bool,
+        skip: bool,
 ):
     if not no_target_directory and (dst_path.endswith('/') or
                                     smart_isdir(dst_path)):
@@ -253,15 +260,16 @@ def mv(
         if recursive:
             if src_protocol == dst_protocol:
                 with tqdm(total=1) as t:
-                    SmartPath(src_path).rename(dst_path)
+                    SmartPath(src_path).rename(dst_path, overwrite=not skip)
                     t.update(1)
             else:
-                smart_sync_with_progress(src_path, dst_path, followlinks=True)
+                smart_sync_with_progress(
+                    src_path, dst_path, followlinks=True, overwrite=not skip)
                 smart_remove(src_path)
         else:
             if src_protocol == dst_protocol:
                 with tqdm(total=1) as t:
-                    SmartPath(src_path).rename(dst_path)
+                    SmartPath(src_path).rename(dst_path, overwrite=not skip)
                     t.update(1)
             else:
                 file_size = smart_stat(src_path).size
@@ -275,12 +283,13 @@ def mv(
                 def callback(length: int):
                     sbar.update(length)
 
-                smart_copy(src_path, dst_path, callback=callback)
+                smart_copy(
+                    src_path, dst_path, callback=callback, overwrite=not skip)
                 smart_unlink(src_path)
                 sbar.close()
     else:
         move_func = smart_move if recursive else smart_rename
-        move_func(src_path, dst_path)
+        move_func(src_path, dst_path, overwrite=not skip)
 
 
 @cli.command(short_help='Remove files from path.')
@@ -314,9 +323,10 @@ def rm(path: str, recursive: bool):
     is_flag=True,
     help='Copy files forcely, ignore same files.')
 @click.option('-q', '--quiet', is_flag=True, help='Not show any progress log.')
+@click.option('--skip', is_flag=True, help='Skip existed files.')
 def sync(
         src_path: str, dst_path: str, progress_bar: bool, worker: int,
-        force: bool, quiet: bool):
+        force: bool, quiet: bool, skip: bool):
     with ThreadPoolExecutor(max_workers=worker) as executor:
         if has_magic(src_path):
             src_root_path = get_non_glob_dir(src_path)
@@ -384,6 +394,7 @@ def sync(
                 followlinks=True,
                 callback_after_copy_file=callback_after_copy_file,
                 force=force,
+                overwrite=not skip,
             ) for file_entry in file_entries)
         list(executor.map(_smart_sync_single_file, params_iter))
     if not quiet:

megfile/errors.py

@@ -25,6 +25,9 @@ __all__ = [
     'UnsupportedError',
     'HttpPermissionError',
     'HttpFileNotFoundError',
+    'HttpBodyIncompleteError',
+    'HttpUnknownError',
+    'HttpException',
     'ProtocolExistsError',
     'ProtocolNotFoundError',
     'S3UnknownError',
@@ -124,24 +127,6 @@ def s3_should_retry(error: Exception) -> bool:
     return False
 
 
-http_retry_exceptions = (
-    requests.exceptions.ReadTimeout,
-    requests.exceptions.ConnectTimeout,
-    requests.exceptions.ChunkedEncodingError,
-    requests.exceptions.HTTPError,
-    requests.exceptions.ProxyError,
-    urllib3.exceptions.IncompleteRead,
-    urllib3.exceptions.ProtocolError,
-    urllib3.exceptions.ReadTimeoutError,
-)
-
-
-def http_should_retry(error: Exception) -> bool:
-    if isinstance(error, http_retry_exceptions):
-        return True
-    return False
-
-
 def patch_method(
         func: Callable,
         max_retries: int,
@@ -301,6 +286,29 @@ class HttpUnknownError(HttpException, UnknownError):
     pass
 
 
+class HttpBodyIncompleteError(HttpException):
+    pass
+
+
+http_retry_exceptions = (
+    requests.exceptions.ReadTimeout,
+    requests.exceptions.ConnectTimeout,
+    requests.exceptions.ChunkedEncodingError,
+    requests.exceptions.HTTPError,
+    requests.exceptions.ProxyError,
+    urllib3.exceptions.IncompleteRead,
+    urllib3.exceptions.ProtocolError,
+    urllib3.exceptions.ReadTimeoutError,
+    HttpBodyIncompleteError,
+)
+
+
+def http_should_retry(error: Exception) -> bool:
+    if isinstance(error, http_retry_exceptions):
+        return True
+    return False
+
+
 class ProtocolExistsError(Exception):
     pass
 

megfile/fs.py

@@ -311,7 +311,8 @@ def fs_copy(
         src_path: PathLike,
         dst_path: PathLike,
         callback: Optional[Callable[[int], None]] = None,
-        followlinks: bool = False):
+        followlinks: bool = False,
+        overwrite: bool = True):
     ''' File copy on file system
     Copy content (excluding meta date) of file on `src_path` to `dst_path`. `dst_path` must be a complete file name
 
@@ -331,23 +332,26 @@ def fs_copy(
     :param dst_path: Target file path
     :param callback: Called periodically during copy, and the input parameter is the data size (in bytes) of copy since the last call
     :param followlinks: False if regard symlink as file, else True
+    :param overwrite: whether or not overwrite file when exists, default is True
     '''
-    return FSPath(src_path).copy(dst_path, callback, followlinks)
+    return FSPath(src_path).copy(dst_path, callback, followlinks, overwrite)
 
 
 def fs_sync(
         src_path: PathLike,
         dst_path: PathLike,
         followlinks: bool = False,
-        force: bool = False) -> None:
+        force: bool = False,
+        overwrite: bool = True) -> None:
     '''Force write of everything to disk.
 
     :param src_path: Given path
     :param dst_path: Target file path
     :param followlinks: False if regard symlink as file, else True
-    :param force: Sync file forcely, do not ignore same files
+    :param force: Sync file forcely, do not ignore same files, priority is higher than 'overwrite', default is False
+    :param overwrite: whether or not overwrite file when exists, default is True
     '''
-    return FSPath(src_path).sync(dst_path, followlinks, force)
+    return FSPath(src_path).sync(dst_path, followlinks, force, overwrite)
 
 
 def fs_symlink(src_path: PathLike, dst_path: PathLike) -> None:

megfile/fs_path.py

@@ -3,7 +3,6 @@ import io
 import os
 import pathlib
 import shutil
-from shutil import copytree
 from stat import S_ISDIR as stat_isdir
 from stat import S_ISLNK as stat_islnk
 from typing import IO, AnyStr, BinaryIO, Callable, Iterator, List, Optional, Tuple, Union
@@ -158,24 +157,69 @@ def fs_glob_stat(
             os.path.basename(path), path, _make_stat(os.lstat(path)))
 
 
-def fs_rename(src_path: PathLike, dst_path: PathLike) -> None:
+def _fs_rename_file(
+        src_path: PathLike, dst_path: PathLike, overwrite: bool = True) -> None:
     '''
     rename file on fs
 
     :param src_path: Given path
     :param dst_path: Given destination path
+    :param overwrite: whether or not overwrite file when exists
     '''
+    src_path, dst_path = fspath(src_path), fspath(dst_path)
+
+    if not overwrite and os.path.exists(dst_path):
+        return
+
+    dst_dir = os.path.dirname(dst_path)
+    if dst_dir and dst_dir != ".":
+        os.makedirs(dst_dir, exist_ok=True)
     shutil.move(src_path, dst_path)
 
 
-def fs_move(src_path: PathLike, dst_path: PathLike) -> None:
+def fs_rename(
+        src_path: PathLike, dst_path: PathLike, overwrite: bool = True) -> None:
+    '''
+    rename file on fs
+
+    :param src_path: Given path
+    :param dst_path: Given destination path
+    :param overwrite: whether or not overwrite file when exists
+    '''
+    src_path, dst_path = fspath(src_path), fspath(dst_path)
+    if os.path.isfile(src_path):
+        return _fs_rename_file(src_path, dst_path, overwrite)
+    else:
+        os.makedirs(dst_path, exist_ok=True)
+
+    with os.scandir(src_path) as entries:
+        for file_entry in entries:
+            src_file_path = file_entry.path
+            dst_file_path = dst_path
+            relative_path = os.path.relpath(src_file_path, start=src_path)
+            if relative_path and relative_path != '.':
+                dst_file_path = os.path.join(dst_file_path, relative_path)
+            if os.path.exists(dst_file_path) and file_entry.is_dir():
+                fs_rename(src_file_path, dst_file_path, overwrite)
+            else:
+                _fs_rename_file(src_file_path, dst_file_path, overwrite)
+
+        if os.path.isdir(src_path):
+            shutil.rmtree(src_path)
+        else:
+            os.remove(src_path)
+
+
+def fs_move(
+        src_path: PathLike, dst_path: PathLike, overwrite: bool = True) -> None:
     '''
     rename file on fs
 
     :param src_path: Given path
     :param dst_path: Given destination path
+    :param overwrite: whether or not overwrite file when exists
     '''
-    fs_rename(src_path, dst_path)
+    return fs_rename(src_path, dst_path, overwrite)
 
 
 def fs_resolve(path: PathLike) -> str:
@@ -491,22 +535,24 @@ class FSPath(URIPath):
         '''
         return fspath(os.path.relpath(self.path_without_protocol, start=start))
 
-    def rename(self, dst_path: PathLike) -> 'FSPath':
+    def rename(self, dst_path: PathLike, overwrite: bool = True) -> 'FSPath':
         '''
         rename file on fs
 
         :param dst_path: Given destination path
+        :param overwrite: whether or not overwrite file when exists
         '''
-        fs_rename(self.path_without_protocol, dst_path)
+        fs_rename(self.path_without_protocol, dst_path, overwrite)
         return self.from_path(dst_path)
 
-    def replace(self, dst_path: PathLike) -> 'FSPath':
+    def replace(self, dst_path: PathLike, overwrite: bool = True) -> 'FSPath':
         '''
         move file on fs
 
         :param dst_path: Given destination path
+        :param overwrite: whether or not overwrite file when exists
         '''
-        return self.rename(dst_path=dst_path)
+        return self.rename(dst_path=dst_path, overwrite=overwrite)
 
     def remove(self, missing_ok: bool = False) -> None:
         '''
@@ -678,7 +724,7 @@ class FSPath(URIPath):
         :rtype: FSPath
         '''
         return self.from_path(
-            str(
+            fspath(
                 pathlib.Path(
                     self.path_without_protocol).resolve(strict=strict)))
 
@@ -718,7 +764,8 @@ class FSPath(URIPath):
             self,
             dst_path: PathLike,
             callback: Optional[Callable[[int], None]] = None,
-            followlinks: bool = False):
+            followlinks: bool = False,
+            overwrite: bool = True):
         ''' File copy on file system
         Copy content (excluding meta date) of file on `src_path` to `dst_path`. `dst_path` must be a complete file name
 
@@ -737,7 +784,11 @@ class FSPath(URIPath):
         :param dst_path: Target file path
         :param callback: Called periodically during copy, and the input parameter is the data size (in bytes) of copy since the last call
         :param followlinks: False if regard symlink as file, else True
+        :param overwrite: whether or not overwrite file when exists, default is True
         '''
+        if not overwrite and os.path.exists((dst_path)):
+            return
+
         try:
             self._copyfile(dst_path, callback=callback, followlinks=followlinks)
         except FileNotFoundError as error:
@@ -754,12 +805,14 @@ class FSPath(URIPath):
             self,
             dst_path: PathLike,
             followlinks: bool = False,
-            force: bool = False) -> None:
+            force: bool = False,
+            overwrite: bool = True) -> None:
         '''Force write of everything to disk.
 
         :param dst_path: Target file path
         :param followlinks: False if regard symlink as file, else True
-        :param force: Sync file forcely, do not ignore same files
+        :param force: Sync file forcely, do not ignore same files, priority is higher than 'overwrite', default is False
+        :param overwrite: whether or not overwrite file when exists, default is True
         '''
         if self.is_dir(followlinks=followlinks):
 
@@ -767,18 +820,22 @@ class FSPath(URIPath):
                 ignore_files = []
                 for name in names:
                     dst_obj = self.from_path(dst_path).joinpath(name)
-                    if not force and dst_obj.exists() and is_same_file(
+                    if force:
+                        pass
+                    elif not overwrite and dst_obj.exists():
+                        ignore_files.append(name)
+                    elif dst_obj.exists() and is_same_file(
                             self.joinpath(name).stat(), dst_obj.stat(), 'copy'):
                         ignore_files.append(name)
                 return ignore_files
 
-            copytree(
+            shutil.copytree(
                 self.path_without_protocol,
                 dst_path,
                 ignore=ignore_same_file,
                 dirs_exist_ok=True)
         else:
-            self.copy(dst_path, followlinks=followlinks)
+            self.copy(dst_path, followlinks=followlinks, overwrite=overwrite)
 
     def symlink(self, dst_path: PathLike) -> None:
         '''

megfile/hdfs.py

@@ -131,14 +131,15 @@ def hdfs_load_from(path: PathLike, followlinks: bool = False) -> BinaryIO:
     return HdfsPath(path).load(followlinks)
 
 
-def hdfs_move(src_path: PathLike, dst_path: PathLike) -> None:
+def hdfs_move(
+        src_path: PathLike, dst_path: PathLike, overwrite: bool = True) -> None:
     '''
     Move file/directory path from src_path to dst_path
 
     :param src_path: Given path
     :param dst_path: Given destination path
     '''
-    return HdfsPath(src_path).move(dst_path)
+    return HdfsPath(src_path).move(dst_path, overwrite)
 
 
 def hdfs_remove(path: PathLike, missing_ok: bool = False) -> None:

megfile/hdfs_path.py

@@ -405,25 +405,35 @@ class HdfsPath(URIPath):
         with raise_hdfs_error(self.path_with_protocol):
             self._client.makedirs(self.path_without_protocol, permission=mode)
 
-    def rename(self, dst_path: PathLike) -> 'HdfsPath':
+    def rename(self, dst_path: PathLike, overwrite: bool = True) -> 'HdfsPath':
         '''
         Move hdfs file path from src_path to dst_path
 
         :param dst_path: Given destination path
+        :param overwrite: whether or not overwrite file when exists
         '''
         dst_path = self.from_path(dst_path)
-        with raise_hdfs_error(self.path_with_protocol):
-            self._client.rename(
-                self.path_without_protocol, dst_path.path_without_protocol)
+        if self.is_dir():
+            for filename in self.iterdir():
+                self.joinpath(filename).rename(dst_path.joinpath(filename))  # pytype: disable=attribute-error
+        else:
+            if overwrite:
+                dst_path.remove(missing_ok=True)
+            if overwrite or not dst_path.exists():
+                with raise_hdfs_error(self.path_with_protocol):
+                    self._client.rename(
+                        self.path_without_protocol,
+                        dst_path.path_without_protocol)
+        self.remove(missing_ok=True)
         return dst_path
 
-    def move(self, dst_path: PathLike) -> None:
+    def move(self, dst_path: PathLike, overwrite: bool = True) -> None:
         '''
         Move file/directory path from src_path to dst_path
 
         :param dst_path: Given destination path
         '''
-        self.rename(dst_path=dst_path)
+        self.rename(dst_path=dst_path, overwrite=overwrite)
 
     def remove(self, missing_ok: bool = False) -> None:
         '''

megfile/http_path.py

@@ -1,4 +1,5 @@
 import time
+from copy import deepcopy
 from functools import partial
 from io import BufferedReader, BytesIO
 from logging import getLogger as get_logger
@@ -12,7 +13,7 @@ from megfile.config import DEFAULT_BLOCK_SIZE, HTTP_MAX_RETRY_TIMES
 from megfile.errors import http_should_retry, patch_method, translate_http_error
 from megfile.interfaces import PathLike, Readable, StatResult, URIPath
 from megfile.lib.compat import fspath
-from megfile.lib.http_prefetch_reader import HttpPrefetchReader
+from megfile.lib.http_prefetch_reader import DEFAULT_TIMEOUT, HttpPrefetchReader
 from megfile.lib.s3_buffered_writer import DEFAULT_MAX_BUFFER_SIZE
 from megfile.lib.url import get_url_scheme
 from megfile.pathlike import PathLike
@@ -32,7 +33,7 @@ max_retries = HTTP_MAX_RETRY_TIMES
 
 
 def get_http_session(
-        timeout: Union[int, Tuple[int, int]] = (9, 60),
+        timeout: Optional[Union[int, Tuple[int, int]]] = DEFAULT_TIMEOUT,
         status_forcelist: Iterable[int] = (500, 502, 503, 504)
 ) -> requests.Session:
     session = requests.Session()
@@ -172,10 +173,12 @@ class HttpPath(URIPath):
     protocol = "http"
 
     def __init__(self, path: PathLike, *other_paths: PathLike):
-        if str(path).startswith('https://'):
-            self.protocol = 'https'
         super().__init__(path, *other_paths)
 
+        if fspath(path).startswith('https://'):
+            self.protocol = 'https'
+        self.request_kwargs = {}
+
     @binary_open
     def open(
             self,
@@ -204,9 +207,15 @@ class HttpPath(URIPath):
             raise ValueError('unacceptable mode: %r' % mode)
 
         response = None
+        request_kwargs = deepcopy(self.request_kwargs)
+        timeout = request_kwargs.pop('timeout', DEFAULT_TIMEOUT)
+        stream = request_kwargs.pop('stream', True)
         try:
-            response = get_http_session(status_forcelist=()).get(
-                self.path_with_protocol, stream=True)
+            response = get_http_session(
+                timeout=timeout,
+                status_forcelist=(),
+            ).get(
+                self.path_with_protocol, stream=stream, **request_kwargs)
             response.raise_for_status()
         except Exception as error:
             if response:
@@ -226,7 +235,7 @@ class HttpPath(URIPath):
                 block_forward = max(int(block_capacity * forward_ratio), 1)
 
             reader = HttpPrefetchReader(
-                self.path_with_protocol,
+                self,
                 content_size=content_size,
                 max_retries=max_retries,
                 max_workers=max_concurrency,
@@ -254,9 +263,14 @@ class HttpPath(URIPath):
         :raises: HttpPermissionError, HttpFileNotFoundError
         '''
 
+        request_kwargs = deepcopy(self.request_kwargs)
+        timeout = request_kwargs.pop('timeout', DEFAULT_TIMEOUT)
+        stream = request_kwargs.pop('stream', True)
+
         try:
-            with get_http_session(status_forcelist=()).get(
-                    self.path_with_protocol, stream=True) as response:
+            with get_http_session(timeout=timeout, status_forcelist=()).get(
+                    self.path_with_protocol, stream=stream,
+                    **request_kwargs) as response:
                 response.raise_for_status()
                 headers = response.headers
         except Exception as error:
@@ -307,9 +321,14 @@ class HttpPath(URIPath):
         :return: return True if exists
         :rtype: bool
         """
+        request_kwargs = deepcopy(self.request_kwargs)
+        timeout = request_kwargs.pop('timeout', DEFAULT_TIMEOUT)
+        stream = request_kwargs.pop('stream', True)
+
         try:
-            with get_http_session(status_forcelist=()).get(
-                    self.path_with_protocol, stream=True) as response:
+            with get_http_session(timeout=timeout, status_forcelist=()).get(
+                    self.path_with_protocol, stream=stream,
+                    **request_kwargs) as response:
                 if response.status_code == 404:
                     return False
                 return True

megfile/lib/http_prefetch_reader.py

@@ -1,12 +1,15 @@
-import os
 from io import BytesIO
 from typing import Optional
 
 import requests
 
 from megfile.config import DEFAULT_BLOCK_CAPACITY, DEFAULT_BLOCK_SIZE, HTTP_MAX_RETRY_TIMES
-from megfile.errors import UnsupportedError, http_should_retry, patch_method
+from megfile.errors import HttpBodyIncompleteError, UnsupportedError, http_should_retry, patch_method
 from megfile.lib.base_prefetch_reader import BasePrefetchReader
+from megfile.lib.compat import fspath
+from megfile.pathlike import PathLike
+
+DEFAULT_TIMEOUT = (60, 60 * 60 * 24)
 
 
 class HttpPrefetchReader(BasePrefetchReader):
@@ -19,7 +22,7 @@ class HttpPrefetchReader(BasePrefetchReader):
 
     def __init__(
             self,
-            url: str,
+            url: PathLike,
             *,
             content_size: Optional[int] = None,
             block_size: int = DEFAULT_BLOCK_SIZE,
@@ -46,22 +49,28 @@ class HttpPrefetchReader(BasePrefetchReader):
         if first_index_response['Headers'].get('Accept-Ranges') != 'bytes':
             raise UnsupportedError(
                 f'Unsupported server, server must support Accept-Ranges: {self._url}',
-                path=self._url,
+                path=fspath(self._url),
             )
         return first_index_response['Headers']['Content-Length']
 
     @property
     def name(self) -> str:
-        return self._url
+        return fspath(self._url)
 
     def _fetch_response(
             self, start: Optional[int] = None,
             end: Optional[int] = None) -> dict:
 
         def fetch_response() -> dict:
+            request_kwargs = {}
+            if hasattr(self._url, 'request_kwargs'):
+                request_kwargs = self._url.request_kwargs
+            timeout = request_kwargs.pop('timeout', DEFAULT_TIMEOUT)
+            stream = request_kwargs.pop('stream', True)
+
             if start is None or end is None:
-                with requests.get(self._url, timeout=10,
-                                  stream=True) as response:
+                with requests.get(fspath(self._url), timeout=timeout,
+                                  stream=stream, **request_kwargs) as response:
                     return {
                         'Headers': response.headers,
                         'Cookies': response.cookies,
@@ -71,9 +80,16 @@ class HttpPrefetchReader(BasePrefetchReader):
                 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 requests.get(self._url, timeout=10, headers=headers,
-                                  stream=True) as response:
+                headers = request_kwargs.pop('headers', {})
+                headers["Range"] = f"bytes={start}-{range_end}"
+                with requests.get(fspath(self._url), timeout=timeout,
+                                  headers=headers, stream=stream,
+                                  **request_kwargs) as response:
+                    if len(response.content) != int(
+                            response.headers['Content-Length']):
+                        raise HttpBodyIncompleteError(
+                            f"The downloaded content is incomplete, expected size: {response.headers['Content-Length']}, actual size: {len(response.content)}",
+                        )
                     return {
                         'Body': BytesIO(response.content),
                         'Headers': response.headers,

megfile/pathlike.py

@@ -730,16 +730,23 @@ class URIPath(BaseURIPath):
         with self.open(mode='r') as f:
             return f.read()
 
-    def rename(self, dst_path: PathLike) -> 'URIPath':
+    def rename(self, dst_path: PathLike, overwrite: bool = True) -> 'URIPath':
+        '''
+        rename file
+
+        :param dst_path: Given destination path
+        :param overwrite: whether or not overwrite file when exists
+        '''
         raise NotImplementedError(f"'rename' is unsupported on '{type(self)}'")
 
-    def replace(self, dst_path: PathLike) -> 'URIPath':
+    def replace(self, dst_path: PathLike, overwrite: bool = True) -> 'URIPath':
         '''
         move file
 
         :param dst_path: Given destination path
+        :param overwrite: whether or not overwrite file when exists
         '''
-        return self.rename(dst_path=dst_path)
+        return self.rename(dst_path=dst_path, overwrite=overwrite)
 
     def rglob(self, pattern) -> List['URIPath']:
         '''