megfile 3.1.6__py3-none-any.whl → 4.0.0__py3-none-any.whl

megfile/pathlike.py

@@ -216,6 +216,8 @@ class FileEntry(NamedTuple):
 
 
 class BasePath:
+    protocol = ""
+
     def __init__(self, path: "PathLike"):
         self.path = str(path)
 
@@ -229,7 +231,7 @@ class BasePath:
         return str(self).encode()
 
     def __fspath__(self) -> str:
-        return self.path
+        return self.as_uri()
 
     def __hash__(self) -> int:
         return hash(fspath(self))
@@ -237,207 +239,9 @@ class BasePath:
     def __eq__(self, other_path: "BasePath") -> bool:
         return fspath(self) == fspath(other_path)
 
-    def is_dir(self, followlinks: bool = False) -> bool:
-        """Return True if the path points to a directory."""
-        raise NotImplementedError('method "is_dir" not implemented: %r' % self)
-
-    def is_file(self, followlinks: bool = False) -> bool:
-        """Return True if the path points to a regular file."""
-        raise NotImplementedError('method "is_file" not implemented: %r' % self)
-
-    def is_symlink(self) -> bool:
-        return False
-
-    def access(self, mode: Access) -> bool:
-        """Return True if the path has access permission described by mode."""
-        raise NotImplementedError('method "access" not implemented: %r' % self)
-
-    def exists(self, followlinks: bool = False) -> bool:
-        """Whether the path points to an existing file or directory."""
-        raise NotImplementedError('method "exists" not implemented: %r' % self)
-
-    def listdir(self) -> List[str]:
-        """Return the names of the entries in the directory the path points to."""
-        raise NotImplementedError('method "listdir" not implemented: %r' % self)
-
-    def scandir(self) -> Iterator[FileEntry]:
-        """
-        Return an iterator of FileEntry objects corresponding to the entries
-        in the directory.
-        """
-        raise NotImplementedError('method "scandir" not implemented: %r' % self)
-
-    def getsize(self, follow_symlinks: bool = True) -> int:
-        """Return the size, in bytes."""
-        raise NotImplementedError('method "getsize" not implemented: %r' % self)
-
-    def getmtime(self, follow_symlinks: bool = True) -> float:
-        """Return the time of last modification."""
-        raise NotImplementedError('method "getmtime" not implemented: %r' % self)
-
-    def stat(self, follow_symlinks=True) -> StatResult:
-        """Get the status of the path."""
-        raise NotImplementedError('method "stat" not implemented: %r' % self)
-
-    def remove(self, missing_ok: bool = False) -> None:
-        """Remove (delete) the file."""
-        raise NotImplementedError('method "remove" not implemented: %r' % self)
-
-    def unlink(self, missing_ok: bool = False) -> None:
-        """Remove (delete) the file."""
-        raise NotImplementedError('method "unlink" not implemented: %r' % self)
-
-    def mkdir(self, mode=0o777, parents: bool = False, exist_ok: bool = False) -> None:
-        """Create a directory."""
-        raise NotImplementedError('method "mkdir" not implemented: %r' % self)
-
-    def rmdir(self) -> None:
-        """Remove (delete) the directory."""
-        raise NotImplementedError('method "rmdir" not implemented: %r' % self)
-
-    def open(self, mode: str = "r", **kwargs) -> IO:
-        """Open the file with mode."""
-        raise NotImplementedError('method "open" not implemented: %r' % self)
-
-    def walk(
-        self, followlinks: bool = False
-    ) -> Iterator[Tuple[str, List[str], List[str]]]:
-        """Generate the file names in a directory tree by walking the tree."""
-        raise NotImplementedError('method "walk" not implemented: %r' % self)
-
-    def scan(self, missing_ok: bool = True, followlinks: bool = False) -> Iterator[str]:
-        """Iterate through the files in the directory."""
-        raise NotImplementedError('method "scan" not implemented: %r' % self)
-
-    def scan_stat(
-        self, missing_ok: bool = True, followlinks: bool = False
-    ) -> Iterator[FileEntry]:
-        """Iterate through the files in the directory, with file stat."""
-        raise NotImplementedError('method "scan_stat" not implemented: %r' % self)
-
-    def glob(
-        self: Self, pattern: str, recursive: bool = True, missing_ok: bool = True
-    ) -> List[Self]:
-        """Return files whose paths match the glob pattern."""
-        raise NotImplementedError('method "glob" not implemented: %r' % self)
-
-    def iglob(
-        self: Self, pattern: str, recursive: bool = True, missing_ok: bool = True
-    ) -> Iterator[Self]:
-        """Return an iterator of files whose paths match the glob pattern."""
-        raise NotImplementedError('method "iglob" not implemented: %r' % self)
-
-    def glob_stat(
-        self, pattern: str, recursive: bool = True, missing_ok: bool = True
-    ) -> Iterator[FileEntry]:
-        """Return an iterator of files with stat whose paths match the glob pattern."""
-        raise NotImplementedError('method "glob_stat" not implemented: %r' % self)
-
-    def load(self) -> BinaryIO:
-        """Read all content in binary."""
-        raise NotImplementedError('method "load" not implemented: %r' % self)
-
-    def save(self, file_object: BinaryIO):
-        """Write the opened binary stream to the path."""
-        raise NotImplementedError('method "save" not implemented: %r' % self)
-
-    def joinpath(self: Self, *other_paths: "PathLike") -> Self:
-        """Join or or more path."""
-        raise NotImplementedError('method "joinpath" not implemented: %r' % self)
-
-    def abspath(self):
-        """Return a normalized absolute version of the path."""
-        raise NotImplementedError('method "abspath" not implemented: %r' % self)
-
-    def realpath(self):
-        """Return the canonical path of the path."""
-        raise NotImplementedError('method "realpath" not implemented: %r' % self)
-
-    def relpath(self, start=None):
-        """Return the relative path."""
-        raise NotImplementedError('method "relpath" not implemented: %r' % self)
-
-    def is_absolute(self) -> bool:
-        """Return True if the path is an absolute pathname."""
-        raise NotImplementedError('method "is_absolute" not implemented: %r' % self)
-
-    def is_mount(self) -> bool:
-        """Return True if the path is a mount point."""
-        raise NotImplementedError('method "is_mount" not implemented: %r' % self)
-
-    def resolve(self):
-        """Alias of realpath."""
-        raise NotImplementedError('method "resolve" not implemented: %r' % self)
-
-    def touch(self):
-        with self.open("w"):
-            pass
-
-    # TODO: will be deleted in next version
-    def is_link(self) -> bool:
-        return self.is_symlink()
-
-    def makedirs(self, exist_ok: bool = False) -> None:
-        """
-        Recursive directory creation function. Like mkdir(), but makes all
-        intermediate-level directories needed to contain the leaf directory.
-        """
-        self.mkdir(parents=True, exist_ok=exist_ok)
-
-
-PathLike = Union[str, BasePath, _PathLike]
-
-
-class BaseURIPath(BasePath):
-    # #####
-    # TODO: Backwards compatible API, will be removed in megfile 1.0
-    @classmethod
-    def get_protocol(self) -> Optional[str]:
-        pass  # pragma: no cover
-
-    @classproperty
-    def protocol(cls) -> str:
-        return cls.get_protocol() or ""
-
-    def make_uri(self) -> str:
-        return self.path_with_protocol
-
-    def as_uri(self) -> str:
-        return self.make_uri()
-
-    # #####
-
-    @cached_property
-    def path_with_protocol(self) -> str:
-        """Return path with protocol, like file:///root, s3://bucket/key"""
-        path = self.path
-        protocol_prefix = self.protocol + "://"  # pyre-ignore[58]
-        if path.startswith(protocol_prefix):
-            return path
-        return protocol_prefix + path.lstrip("/")
-
-    @cached_property
-    def path_without_protocol(self) -> str:
-        """
-        Return path without protocol, example: if path is s3://bucket/key,
-        return bucket/key
-        """
-        path = self.path
-        protocol_prefix = self.protocol + "://"  # pyre-ignore[58]
-        if path.startswith(protocol_prefix):
-            path = path[len(protocol_prefix) :]
-        return path
-
-    def as_posix(self) -> str:
-        """Return a string representation of the path with forward slashes (/)"""
-        return self.path_with_protocol
-
-    def __fspath__(self) -> str:
-        return self.as_uri()
-
-    def __lt__(self, other_path: "BaseURIPath") -> bool:
-        if not isinstance(other_path, BaseURIPath):
-            raise TypeError("%r is not 'URIPath'" % other_path)
+    def __lt__(self, other_path: "BasePath") -> bool:
+        if not isinstance(other_path, BasePath):
+            raise TypeError("%r is not 'BasePath'" % other_path)
         if self.protocol != other_path.protocol:
             raise TypeError(
                 "'<' not supported between instances of %r and %r"
@@ -445,9 +249,9 @@ class BaseURIPath(BasePath):
             )
         return fspath(self) < fspath(other_path)
 
-    def __le__(self, other_path: "BaseURIPath") -> bool:
-        if not isinstance(other_path, BaseURIPath):
-            raise TypeError("%r is not 'URIPath'" % other_path)
+    def __le__(self, other_path: "BasePath") -> bool:
+        if not isinstance(other_path, BasePath):
+            raise TypeError("%r is not 'BasePath'" % other_path)
         if self.protocol != other_path.protocol:
             raise TypeError(
                 "'<=' not supported between instances of %r and %r"
@@ -455,9 +259,9 @@ class BaseURIPath(BasePath):
             )
         return str(self) <= str(other_path)
 
-    def __gt__(self, other_path: "BaseURIPath") -> bool:
-        if not isinstance(other_path, BaseURIPath):
-            raise TypeError("%r is not 'URIPath'" % other_path)
+    def __gt__(self, other_path: "BasePath") -> bool:
+        if not isinstance(other_path, BasePath):
+            raise TypeError("%r is not 'BasePath'" % other_path)
         if self.protocol != other_path.protocol:
             raise TypeError(
                 "'>' not supported between instances of %r and %r"
@@ -465,9 +269,9 @@ class BaseURIPath(BasePath):
             )
         return str(self) > str(other_path)
 
-    def __ge__(self, other_path: "BaseURIPath") -> bool:
-        if not isinstance(other_path, BaseURIPath):
-            raise TypeError("%r is not 'URIPath'" % other_path)
+    def __ge__(self, other_path: "BasePath") -> bool:
+        if not isinstance(other_path, BasePath):
+            raise TypeError("%r is not 'BasePath'" % other_path)
         if self.protocol != other_path.protocol:
             raise TypeError(
                 "'>=' not supported between instances of %r and %r"
@@ -475,27 +279,39 @@ class BaseURIPath(BasePath):
             )
         return str(self) >= str(other_path)
 
-    @classproperty
-    def drive(self) -> str:
-        return ""
+    def __truediv__(self: Self, other_path: "PathLike") -> Self:
+        raise NotImplementedError('method "__truediv__" not implemented: %r' % self)
 
-    @classproperty
-    def root(self) -> str:
-        return self.protocol + "://"  # pyre-ignore[58]
+    @cached_property
+    def path_with_protocol(self) -> str:
+        """Return path with protocol, like file:///root, s3://bucket/key"""
+        path = self.path
+        protocol_prefix = self.protocol + "://"
+        if path.startswith(protocol_prefix):
+            return path
+        return protocol_prefix + path.lstrip("/")
 
-    @classproperty
-    def anchor(self) -> str:
-        return self.root  # pyre-ignore[7]
+    @cached_property
+    def path_without_protocol(self) -> str:
+        """
+        Return path without protocol, example: if path is s3://bucket/key,
+        return bucket/key
+        """
+        path = self.path
+        protocol_prefix = self.protocol + "://"
+        if path.startswith(protocol_prefix):
+            path = path[len(protocol_prefix) :]
+        return path
 
+    def as_uri(self) -> str:
+        return self.path_with_protocol
 
-class URIPath(BaseURIPath):
-    def __init__(self, path: "PathLike", *other_paths: "PathLike"):
-        if len(other_paths) > 0:
-            path = self.from_path(path).joinpath(*other_paths)
-        self.path = str(path)
+    def as_posix(self) -> str:
+        """Return a string representation of the path with forward slashes (/)"""
+        return self.path_with_protocol
 
     @classmethod
-    def from_path(cls: Type[Self], path: PathLike) -> Self:
+    def from_path(cls: Type[Self], path: "PathLike") -> Self:
         """Return new instance of this class
 
         :param path: new path
@@ -506,7 +322,7 @@ class URIPath(BaseURIPath):
         return cls(path)  # pyre-ignore[19]
 
     @classmethod
-    def from_uri(cls: Type[Self], path: PathLike) -> Self:
+    def from_uri(cls: Type[Self], path: "PathLike") -> Self:
         path = fspath(path)
         protocol_prefix = cls.protocol + "://"
         if path[: len(protocol_prefix)] != protocol_prefix:
@@ -515,59 +331,12 @@ class URIPath(BaseURIPath):
             )
         return cls.from_path(path[len(protocol_prefix) :])
 
-    def __truediv__(self: Self, other_path: PathLike) -> Self:
-        if isinstance(other_path, BaseURIPath):
-            if self.protocol != other_path.protocol:
-                raise TypeError(
-                    "'/' not supported between instances of %r and %r"
-                    % (type(self), type(other_path))
-                )
-        elif not isinstance(other_path, str):
-            raise TypeError("%r is not 'str' nor 'URIPath'" % other_path)
-        return self.joinpath(other_path)
-
-    def joinpath(self: Self, *other_paths: PathLike) -> Self:
-        """
-        Calling this method is equivalent to combining the path
-        with each of the other arguments in turn
-        """
-        return self.from_path(uri_join(str(self), *map(str, other_paths)))
-
-    @cached_property
-    def parts(self) -> Tuple[str, ...]:
-        """A tuple giving access to the path’s various components"""
-        parts = [self.root]
-        path = self.path_without_protocol
-        path = path.lstrip("/")
-        if path != "":
-            parts.extend(path.split("/"))
-        return tuple(parts)  # pyre-ignore[7]
-
-    @cached_property
-    def parents(self) -> "URIPathParents":
-        """
-        An immutable sequence providing access to the logical ancestors of the path
-        """
-        return URIPathParents(self)
-
-    @cached_property
-    def parent(self: Self) -> Self:
-        """The logical parent of the path"""
-        if self.path_without_protocol == "/":
-            return self
-        elif len(self.parents) > 0:
-            return self.parents[0]
-        return self.from_path("")
-
     @cached_property
     def name(self) -> str:
         """
         A string representing the final path component, excluding the drive and root
         """
-        parts = self.parts
-        if len(parts) == 1 and parts[0] == self.protocol + "://":  # pyre-ignore[58]
-            return ""
-        return parts[-1]
+        return self.path_without_protocol
 
     @cached_property
     def suffix(self) -> str:
@@ -599,18 +368,6 @@ class URIPath(BaseURIPath):
     def is_reserved(self) -> bool:
         return False
 
-    def match(self, pattern) -> bool:
-        """
-        Match this path against the provided glob-style pattern.
-        Return True if matching is successful, False otherwise
-        """
-        match = _compile_pattern(pattern)
-        for index in range(len(self.parts), 0, -1):
-            path = "/".join(self.parts[index:])
-            if match(path) is not None:
-                return True
-        return match(self.path_with_protocol) is not None
-
     def is_relative_to(self, *other) -> bool:
         try:
             self.relative_to(*other)
@@ -663,74 +420,295 @@ class URIPath(BaseURIPath):
         other_path = self.from_path(start).path_with_protocol
         path = self.path_with_protocol
 
-        if path.startswith(other_path):
-            relative = path[len(other_path) :]
-            relative = relative.lstrip("/")
-            return relative
+        if path.startswith(other_path):
+            relative = path[len(other_path) :]
+            relative = relative.lstrip("/")
+            return relative
+
+        raise ValueError("%r does not start with %r" % (path, other_path))
+
+    def is_absolute(self) -> bool:
+        return True
+
+    def is_mount(self) -> bool:
+        """Test whether a path is a mount point
+
+        :returns: True if a path is a mount point, else False
+        """
+        return False
+
+    def is_socket(self) -> bool:
+        """
+        Return True if the path points to a Unix socket (or a symbolic link pointing
+        to a Unix socket), False if it points to another kind of file.
+
+        False is also returned if the path doesn’t exist or is a broken symlink;
+        other errors (such as permission errors) are propagated.
+        """
+        return False
+
+    def is_fifo(self) -> bool:
+        """
+        Return True if the path points to a FIFO (or a symbolic link pointing to a
+        FIFO), False if it points to another kind of file.
+
+        False is also returned if the path doesn’t exist or is a broken symlink;
+        other errors (such as permission errors) are propagated.
+        """
+        return False
+
+    def is_block_device(self) -> bool:
+        """
+        Return True if the path points to a block device (or a symbolic link pointing
+        to a block device), False if it points to another kind of file.
+
+        False is also returned if the path doesn’t exist or is a broken symlink;
+        other errors (such as permission errors) are propagated.
+        """
+        return False
+
+    def is_char_device(self) -> bool:
+        """
+        Return True if the path points to a character device (or a symbolic link
+        pointing to a character device), False if it points to another kind of file.
+
+        False is also returned if the path doesn’t exist or is a broken symlink;
+        other errors (such as permission errors) are propagated.
+        """
+        return False
+
+    def abspath(self) -> str:
+        """Return a normalized absolute version of the path."""
+        return self.path_with_protocol
+
+    def realpath(self) -> str:
+        """Return the canonical path of the path."""
+        return self.path_with_protocol
+
+    def resolve(self):
+        """Alias of realpath."""
+        return self.path_with_protocol
+
+    def read_bytes(self) -> bytes:
+        """Return the binary contents of the pointed-to file as a bytes object"""
+        with self.open(mode="rb") as f:
+            return f.read()  # pytype: disable=bad-return-type
+
+    def read_text(self) -> str:
+        """Return the decoded contents of the pointed-to file as a string"""
+        with self.open(mode="r") as f:
+            return f.read()  # pytype: disable=bad-return-type
+
+    def rglob(self: Self, pattern) -> List[Self]:
+        """
+        This is like calling Path.glob() with “**/” added in front of
+        the given relative pattern
+        """
+        if not pattern:
+            pattern = ""
+        pattern = "**/" + pattern.lstrip("/")
+        return self.glob(pattern=pattern)
+
+    def samefile(self, other_path) -> bool:
+        """
+        Return whether this path points to the same file
+        """
+        if hasattr(other_path, "protocol"):
+            if other_path.protocol != self.protocol:
+                return False
+
+        stat = self.stat()
+        if hasattr(other_path, "stat"):
+            other_path_stat = other_path.stat()
+        else:
+            other_path_stat = self.from_path(other_path).stat()
+
+        return (
+            stat.st_ino == other_path_stat.st_ino
+            and stat.st_dev == other_path_stat.st_dev
+        )
+
+    def touch(self):
+        with self.open("w"):
+            pass
+
+    def makedirs(self, exist_ok: bool = False) -> None:
+        """
+        Recursive directory creation function. Like mkdir(), but makes all
+        intermediate-level directories needed to contain the leaf directory.
+        """
+        self.mkdir(parents=True, exist_ok=exist_ok)
+
+    def write_bytes(self, data: bytes):
+        """
+        Open the file pointed to in bytes mode, write data to it, and close the file
+        """
+        with self.open(mode="wb") as f:
+            return f.write(data)
+
+    def write_text(self, data: str, encoding=None, errors=None, newline=None):
+        """
+        Open the file pointed to in text mode, write data to it, and close the file.
+        The optional parameters have the same meaning as in open().
+        """
+        with self.open(
+            mode="w", encoding=encoding, errors=errors, newline=newline
+        ) as f:
+            return f.write(data)
+
+    @classproperty
+    def drive(self) -> str:
+        return ""
+
+    @classproperty
+    def root(self) -> str:
+        return self.protocol + "://"
+
+    @classproperty
+    def anchor(self) -> str:
+        return self.root  # pyre-ignore[7]
+
+    def joinpath(self: Self, *other_paths: "PathLike") -> Self:
+        """
+        Calling this method is equivalent to combining the path
+        with each of the other arguments in turn
+        """
+        raise NotImplementedError('method "joinpath" not implemented: %r' % self)
+
+    @cached_property
+    def parts(self) -> Tuple[str, ...]:
+        """A tuple giving access to the path’s various components"""
+        raise NotImplementedError('property "parts" not implemented: %r' % self)
+
+    @cached_property
+    def parents(self) -> "URIPathParents":
+        """
+        An immutable sequence providing access to the logical ancestors of the path
+        """
+        raise NotImplementedError('property "parents" not implemented: %r' % self)
+
+    @cached_property
+    def parent(self: Self) -> Self:
+        """The logical parent of the path"""
+        raise NotImplementedError('property "parent" not implemented: %r' % self)
+
+    def is_dir(self, followlinks: bool = False) -> bool:
+        """Return True if the path points to a directory."""
+        raise NotImplementedError('method "is_dir" not implemented: %r' % self)
+
+    def is_file(self, followlinks: bool = False) -> bool:
+        """Return True if the path points to a regular file."""
+        raise NotImplementedError('method "is_file" not implemented: %r' % self)
+
+    def is_symlink(self) -> bool:
+        return False
+
+    def access(self, mode: Access) -> bool:
+        """Return True if the path has access permission described by mode."""
+        raise NotImplementedError('method "access" not implemented: %r' % self)
+
+    def exists(self, followlinks: bool = False) -> bool:
+        """Whether the path points to an existing file or directory."""
+        raise NotImplementedError('method "exists" not implemented: %r' % self)
+
+    def listdir(self) -> List[str]:
+        """Return the names of the entries in the directory the path points to."""
+        raise NotImplementedError('method "listdir" not implemented: %r' % self)
+
+    def scandir(self) -> Iterator[FileEntry]:
+        """
+        Return an iterator of FileEntry objects corresponding to the entries
+        in the directory.
+        """
+        raise NotImplementedError('method "scandir" not implemented: %r' % self)
 
-        raise ValueError("%r does not start with %r" % (path, other_path))
+    def getsize(self, follow_symlinks: bool = True) -> int:
+        """Return the size, in bytes."""
+        raise NotImplementedError('method "getsize" not implemented: %r' % self)
 
-    def is_absolute(self) -> bool:
-        return True
+    def getmtime(self, follow_symlinks: bool = True) -> float:
+        """Return the time of last modification."""
+        raise NotImplementedError('method "getmtime" not implemented: %r' % self)
 
-    def is_mount(self) -> bool:
-        """Test whether a path is a mount point
+    def stat(self, follow_symlinks=True) -> StatResult:
+        """Get the status of the path."""
+        raise NotImplementedError('method "stat" not implemented: %r' % self)
 
-        :returns: True if a path is a mount point, else False
+    def lstat(self) -> StatResult:
         """
-        return False
-
-    def is_socket(self) -> bool:
+        Like stat() but, if the path points to a symbolic link,
+        return the symbolic link’s information rather than its target’s.
         """
-        Return True if the path points to a Unix socket (or a symbolic link pointing
-        to a Unix socket), False if it points to another kind of file.
+        return self.stat(follow_symlinks=False)
 
-        False is also returned if the path doesn’t exist or is a broken symlink;
-        other errors (such as permission errors) are propagated.
+    def match(self, pattern) -> bool:
         """
-        return False
-
-    def is_fifo(self) -> bool:
+        Match this path against the provided glob-style pattern.
+        Return True if matching is successful, False otherwise
         """
-        Return True if the path points to a FIFO (or a symbolic link pointing to a
-        FIFO), False if it points to another kind of file.
+        raise NotImplementedError('method "match" not implemented: %r' % self)
 
-        False is also returned if the path doesn’t exist or is a broken symlink;
-        other errors (such as permission errors) are propagated.
-        """
-        return False
+    def remove(self, missing_ok: bool = False) -> None:
+        """Remove (delete) the file."""
+        raise NotImplementedError('method "remove" not implemented: %r' % self)
 
-    def is_block_device(self) -> bool:
-        """
-        Return True if the path points to a block device (or a symbolic link pointing
-        to a block device), False if it points to another kind of file.
+    def unlink(self, missing_ok: bool = False) -> None:
+        """Remove (delete) the file."""
+        raise NotImplementedError('method "unlink" not implemented: %r' % self)
 
-        False is also returned if the path doesn’t exist or is a broken symlink;
-        other errors (such as permission errors) are propagated.
-        """
-        return False
+    def mkdir(self, mode=0o777, parents: bool = False, exist_ok: bool = False) -> None:
+        """Create a directory."""
+        raise NotImplementedError('method "mkdir" not implemented: %r' % self)
 
-    def is_char_device(self) -> bool:
-        """
-        Return True if the path points to a character device (or a symbolic link
-        pointing to a character device), False if it points to another kind of file.
+    def rmdir(self) -> None:
+        """Remove (delete) the directory."""
+        raise NotImplementedError('method "rmdir" not implemented: %r' % self)
 
-        False is also returned if the path doesn’t exist or is a broken symlink;
-        other errors (such as permission errors) are propagated.
-        """
-        return False
+    def open(self, mode: str = "r", **kwargs) -> IO:
+        """Open the file with mode."""
+        raise NotImplementedError('method "open" not implemented: %r' % self)
 
-    def abspath(self) -> str:
-        """Return a normalized absolute version of the path."""
-        return self.path_with_protocol
+    def walk(
+        self, followlinks: bool = False
+    ) -> Iterator[Tuple[str, List[str], List[str]]]:
+        """Generate the file names in a directory tree by walking the tree."""
+        raise NotImplementedError('method "walk" not implemented: %r' % self)
 
-    def realpath(self) -> str:
-        """Return the canonical path of the path."""
-        return self.path_with_protocol
+    def scan(self, missing_ok: bool = True, followlinks: bool = False) -> Iterator[str]:
+        """Iterate through the files in the directory."""
+        raise NotImplementedError('method "scan" not implemented: %r' % self)
 
-    def resolve(self):
-        """Alias of realpath."""
-        return self.path_with_protocol
+    def scan_stat(
+        self, missing_ok: bool = True, followlinks: bool = False
+    ) -> Iterator[FileEntry]:
+        """Iterate through the files in the directory, with file stat."""
+        raise NotImplementedError('method "scan_stat" not implemented: %r' % self)
+
+    def glob(
+        self: Self, pattern: str, recursive: bool = True, missing_ok: bool = True
+    ) -> List[Self]:
+        """Return files whose paths match the glob pattern."""
+        raise NotImplementedError('method "glob" not implemented: %r' % self)
+
+    def iglob(
+        self: Self, pattern: str, recursive: bool = True, missing_ok: bool = True
+    ) -> Iterator[Self]:
+        """Return an iterator of files whose paths match the glob pattern."""
+        raise NotImplementedError('method "iglob" not implemented: %r' % self)
+
+    def glob_stat(
+        self, pattern: str, recursive: bool = True, missing_ok: bool = True
+    ) -> Iterator[FileEntry]:
+        """Return an iterator of files with stat whose paths match the glob pattern."""
+        raise NotImplementedError('method "glob_stat" not implemented: %r' % self)
+
+    def load(self) -> BinaryIO:
+        """Read all content in binary."""
+        raise NotImplementedError('method "load" not implemented: %r' % self)
+
+    def save(self, file_object: BinaryIO):
+        """Write the opened binary stream to the path."""
+        raise NotImplementedError('method "save" not implemented: %r' % self)
 
     def chmod(self, mode: int, *, follow_symlinks: bool = True):
         raise NotImplementedError(f"'chmod' is unsupported on '{type(self)}'")
@@ -742,17 +720,7 @@ class URIPath(BaseURIPath):
         """
         return self.chmod(mode=mode, follow_symlinks=False)
 
-    def read_bytes(self) -> bytes:
-        """Return the binary contents of the pointed-to file as a bytes object"""
-        with self.open(mode="rb") as f:
-            return f.read()  # pytype: disable=bad-return-type
-
-    def read_text(self) -> str:
-        """Return the decoded contents of the pointed-to file as a string"""
-        with self.open(mode="r") as f:
-            return f.read()  # pytype: disable=bad-return-type
-
-    def rename(self: Self, dst_path: PathLike, overwrite: bool = True) -> Self:
+    def rename(self: Self, dst_path: "PathLike", overwrite: bool = True) -> Self:
         """
         rename file
 
@@ -761,7 +729,7 @@ class URIPath(BaseURIPath):
         """
         raise NotImplementedError(f"'rename' is unsupported on '{type(self)}'")
 
-    def replace(self: Self, dst_path: PathLike, overwrite: bool = True) -> Self:
+    def replace(self: Self, dst_path: "PathLike", overwrite: bool = True) -> Self:
         """
         move file
 
@@ -770,39 +738,10 @@ class URIPath(BaseURIPath):
         """
         return self.rename(dst_path=dst_path, overwrite=overwrite)
 
-    def rglob(self: Self, pattern) -> List[Self]:
-        """
-        This is like calling Path.glob() with “**/” added in front of
-        the given relative pattern
-        """
-        if not pattern:
-            pattern = ""
-        pattern = "**/" + pattern.lstrip("/")
-        return self.glob(pattern=pattern)
-
     def md5(self, recalculate: bool = False, followlinks: bool = False) -> str:
         raise NotImplementedError(f"'md5' is unsupported on '{type(self)}'")
 
-    def samefile(self, other_path) -> bool:
-        """
-        Return whether this path points to the same file
-        """
-        if hasattr(other_path, "protocol"):
-            if other_path.protocol != self.protocol:
-                return False
-
-        stat = self.stat()
-        if hasattr(other_path, "stat"):
-            other_path_stat = other_path.stat()
-        else:
-            other_path_stat = self.from_path(other_path).stat()
-
-        return (
-            stat.st_ino == other_path_stat.st_ino
-            and stat.st_dev == other_path_stat.st_dev
-        )
-
-    def symlink(self, dst_path: PathLike) -> None:
+    def symlink(self, dst_path: "PathLike") -> None:
         raise NotImplementedError(f"'symlink' is unsupported on '{type(self)}'")
 
     def symlink_to(self, target, target_is_directory=False):
@@ -819,23 +758,6 @@ class URIPath(BaseURIPath):
         """
         raise NotImplementedError(f"'hardlink_to' is unsupported on '{type(self)}'")
 
-    def write_bytes(self, data: bytes):
-        """
-        Open the file pointed to in bytes mode, write data to it, and close the file
-        """
-        with self.open(mode="wb") as f:
-            return f.write(data)
-
-    def write_text(self, data: str, encoding=None, errors=None, newline=None):
-        """
-        Open the file pointed to in text mode, write data to it, and close the file.
-        The optional parameters have the same meaning as in open().
-        """
-        with self.open(
-            mode="w", encoding=encoding, errors=errors, newline=newline
-        ) as f:
-            return f.write(data)
-
     def home(self):
         """Return the home directory
 
@@ -901,12 +823,86 @@ class URIPath(BaseURIPath):
         """
         raise NotImplementedError(f"'utime' is unsupported on '{type(self)}'")
 
-    def lstat(self) -> StatResult:
+
+PathLike = Union[str, BasePath, _PathLike]
+
+
+class URIPath(BasePath):
+    def __init__(self, path: PathLike, *other_paths: PathLike):
+        # if not isinstance(path, PathLike):
+        #     raise TypeError(f"expected PathLike object, not {type(path)}")
+
+        if len(other_paths) > 0:
+            path = self.from_path(path).joinpath(*other_paths)
+        super().__init__(path)
+
+    def __truediv__(self: Self, other_path: PathLike) -> Self:
+        if isinstance(other_path, BasePath):
+            if self.protocol != other_path.protocol:
+                raise TypeError(
+                    "'/' not supported between instances of %r and %r"
+                    % (type(self), type(other_path))
+                )
+        elif isinstance(other_path, _PathLike):
+            other_path = fspath(other_path)
+        elif not isinstance(other_path, str):
+            raise TypeError("%r is not 'PathLike' object" % other_path)
+        return self.joinpath(other_path)
+
+    def joinpath(self: Self, *other_paths: PathLike) -> Self:
         """
-        Like stat() but, if the path points to a symbolic link,
-        return the symbolic link’s information rather than its target’s.
+        Calling this method is equivalent to combining the path
+        with each of the other arguments in turn
         """
-        return self.stat(follow_symlinks=False)
+        return self.from_path(uri_join(str(self), *map(str, other_paths)))
+
+    @cached_property
+    def parts(self) -> Tuple[str, ...]:
+        """A tuple giving access to the path’s various components"""
+        parts = [self.root]
+        path = self.path_without_protocol
+        path = path.lstrip("/")
+        if path != "":
+            parts.extend(path.split("/"))
+        return tuple(parts)  # pyre-ignore[7]
+
+    @cached_property
+    def parents(self) -> "URIPathParents":
+        """
+        An immutable sequence providing access to the logical ancestors of the path
+        """
+        return URIPathParents(self)
+
+    @cached_property
+    def parent(self: Self) -> Self:
+        """The logical parent of the path"""
+        if self.path_without_protocol == "/":
+            return self
+        elif len(self.parents) > 0:
+            return self.parents[0]
+        return self.from_path("")
+
+    @cached_property
+    def name(self) -> str:
+        """
+        A string representing the final path component, excluding the drive and root
+        """
+        parts = self.parts
+        if len(parts) == 1 and parts[0] == self.protocol + "://":
+            return ""
+        return parts[-1]
+
+    def match(self, pattern) -> bool:
+        """
+        Match this path against the provided glob-style pattern.
+        Return True if matching is successful, False otherwise
+        """
+        match = _compile_pattern(pattern)
+        for index in range(len(self.parts), 0, -1):
+            path = "/".join(self.parts[index:])
+            if match(path) is not None:
+                return True
+        return match(self.path_with_protocol) is not None
 
 
 class URIPathParents(Sequence):