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

megfile/fs_path.py

@@ -4,8 +4,12 @@ import os
 import pathlib
 import shutil
 from functools import cached_property
+from stat import S_ISBLK as stat_isblk
+from stat import S_ISCHR as stat_ischr
 from stat import S_ISDIR as stat_isdir
+from stat import S_ISFIFO as stat_isfifo
 from stat import S_ISLNK as stat_islnk
+from stat import S_ISSOCK as stat_issock
 from typing import IO, BinaryIO, Callable, Iterator, List, Optional, Tuple, Union
 
 from megfile.errors import _create_missing_ok_generator
@@ -30,24 +34,13 @@ __all__ = [
     "is_fs",
     "fs_path_join",
     "_make_stat",
-    "fs_readlink",
-    "fs_cwd",
-    "fs_home",
-    "fs_iglob",
-    "fs_glob",
-    "fs_glob_stat",
-    "fs_rename",
-    "fs_resolve",
-    "fs_move",
-    "fs_makedirs",
-    "fs_lstat",
 ]
 
 
 def _make_stat(stat: os.stat_result) -> StatResult:
     return StatResult(
         size=stat.st_size,
-        ctime=stat.st_ctime,
+        ctime=stat.st_ctime,  # pyre-ignore[16]
         mtime=stat.st_mtime,
         isdir=stat_isdir(stat.st_mode),
         islnk=stat_islnk(stat.st_mode),
@@ -72,121 +65,6 @@ def fs_path_join(path: PathLike, *other_paths: PathLike) -> str:
     return path_join(fspath(path), *map(fspath, other_paths))
 
 
-def fs_readlink(path) -> str:
-    """
-    Return a string representing the path to which the symbolic link points.
-    :returns: Return a string representing the path to which the symbolic link points.
-    """
-    return os.readlink(path)
-
-
-def fs_cwd() -> str:
-    """Return current working directory
-
-    returns: Current working directory
-    """
-    return os.getcwd()
-
-
-def fs_home():
-    """Return the home directory
-
-    returns: Home directory path
-    """
-    return os.path.expanduser("~")
-
-
-def fs_iglob(
-    path: PathLike, recursive: bool = True, missing_ok: bool = True
-) -> Iterator[str]:
-    """Return path iterator in ascending alphabetical order,
-    in which path matches glob pattern
-
-    1. If doesn't match any path, return empty list
-        Notice:  ``glob.glob`` in standard library returns ['a/'] instead of empty list
-        when pathname is like `a/**`, recursive is True and directory 'a' doesn't exist.
-        fs_glob behaves like ``glob.glob`` in standard library under such circumstance.
-    2. No guarantee that each path in result is different, which means:
-        Assume there exists a path `/a/b/c/b/d.txt`
-        use path pattern like `/**/b/**/*.txt` to glob,
-        the path above will be returned twice
-    3. `**` will match any matched file, directory, symlink and '' by default,
-        when recursive is `True`
-    4. fs_glob returns same as glob.glob(pathname, recursive=True)
-        in ascending alphabetical order.
-    5. Hidden files (filename stars with '.') will not be found in the result
-
-    :param recursive: If False, `**` will not search directory recursively
-    :param missing_ok: If False and target path doesn't match any file,
-        raise FileNotFoundError
-    :returns: An iterator contains paths match `pathname`
-    """
-    for path in _create_missing_ok_generator(
-        iglob(fspath(path), recursive=recursive),
-        missing_ok,
-        FileNotFoundError("No match any file: %r" % path),
-    ):
-        yield path
-
-
-def fs_glob(
-    path: PathLike, recursive: bool = True, missing_ok: bool = True
-) -> List[str]:
-    """Return path list in ascending alphabetical order,
-    in which path matches glob pattern
-
-    1. If doesn't match any path, return empty list
-        Notice:  ``glob.glob`` in standard library returns ['a/'] instead of empty list
-        when pathname is like `a/**`, recursive is True and directory 'a' doesn't exist.
-        fs_glob behaves like ``glob.glob`` in standard library under such circumstance.
-    2. No guarantee that each path in result is different, which means:
-        Assume there exists a path `/a/b/c/b/d.txt`
-        use path pattern like `/**/b/**/*.txt` to glob,
-        the path above will be returned twice
-    3. `**` will match any matched file, directory, symlink and '' by default,
-        when recursive is `True`
-    4. fs_glob returns same as glob.glob(pathname, recursive=True)
-        in ascending alphabetical order.
-    5. Hidden files (filename stars with '.') will not be found in the result
-
-    :param recursive: If False, `**` will not search directory recursively
-    :param missing_ok: If False and target path doesn't match any file,
-        raise FileNotFoundError
-    :returns: A list contains paths match `pathname`
-    """
-    return list(fs_iglob(path=path, recursive=recursive, missing_ok=missing_ok))
-
-
-def fs_glob_stat(
-    path: PathLike, recursive: bool = True, missing_ok: bool = True
-) -> Iterator[FileEntry]:
-    """Return a list contains tuples of path and file stat,
-    in ascending alphabetical order, in which path matches glob pattern
-
-    1. If doesn't match any path, return empty list
-        Notice:  ``glob.glob`` in standard library returns ['a/'] instead of empty list
-        when pathname is like `a/**`, recursive is True and directory 'a' doesn't exist.
-        fs_glob behaves like ``glob.glob`` in standard library under such circumstance.
-    2. No guarantee that each path in result is different, which means:
-        Assume there exists a path `/a/b/c/b/d.txt`
-        use path pattern like `/**/b/**/*.txt` to glob,
-        the path above will be returned twice.
-    3. `**` will match any matched file, directory, symlink and '' by default,
-        when recursive is `True`
-    4. fs_glob returns same as glob.glob(pathname, recursive=True)
-        in ascending alphabetical order.
-    5. Hidden files (filename stars with '.') will not be found in the result
-
-    :param recursive: If False, `**` will not search directory recursively
-    :param missing_ok: If False and target path doesn't match any file,
-        raise FileNotFoundError
-    :returns: A list contains tuples of path and file stat,
-        in which paths match `pathname`
-    """
-    for path in fs_iglob(path=path, recursive=recursive, missing_ok=missing_ok):
-        yield FileEntry(os.path.basename(path), path, _make_stat(os.lstat(path)))
-
-
 def _fs_rename_file(
     src_path: PathLike, dst_path: PathLike, overwrite: bool = True
 ) -> None:
@@ -208,82 +86,6 @@ def _fs_rename_file(
     shutil.move(src_path, dst_path)
 
 
-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
-    """
-    return fs_rename(src_path, dst_path, overwrite)
-
-
-def fs_resolve(path: PathLike) -> str:
-    """Equal to fs_realpath, return the real path of given path
-
-    :param path: Given path
-    :returns: Real path of given path
-    """
-    return FSPath(path).realpath()
-
-
-def fs_makedirs(path: PathLike, exist_ok: bool = False):
-    """
-    make a directory on fs, including parent directory
-
-    If there exists a file on the path, raise FileExistsError
-
-    :param path: Given path
-    :param exist_ok: If False and target directory exists, raise FileExistsError
-    :raises: FileExistsError
-    """
-    return FSPath(path).mkdir(parents=True, exist_ok=exist_ok)
-
-
-def fs_lstat(path: PathLike) -> StatResult:
-    """
-    Like Path.stat() but, if the path points to a symbolic link,
-    return the symbolic link’s information rather than its target’s.
-
-    :param path: Given path
-    :returns: StatResult
-    """
-    return FSPath(path).lstat()
-
-
 @SmartPath.register
 class FSPath(URIPath):
     """file protocol
@@ -299,27 +101,39 @@ class FSPath(URIPath):
             path = str(path)
         self.path = path
 
+    def _check_int_path(self) -> None:
+        if isinstance(self.path_without_protocol, int):
+            raise TypeError("not support the path of int type")
+
     def __fspath__(self) -> str:
-        return os.path.normpath(self.path_without_protocol)
+        self._check_int_path()
+        return os.path.normpath(self.path_without_protocol)  # pyre-ignore[6]
 
     @cached_property
     def root(self) -> str:
-        return pathlib.Path(self.path_without_protocol).root
+        if isinstance(self.path_without_protocol, int):
+            return "/"
+        return pathlib.Path(self.path_without_protocol).root  # pyre-ignore[6]
 
     @cached_property
     def anchor(self) -> str:
-        return pathlib.Path(self.path_without_protocol).anchor
+        if isinstance(self.path_without_protocol, int):
+            return "/"
+        return pathlib.Path(self.path_without_protocol).anchor  # pyre-ignore[6]
 
     @cached_property
     def drive(self) -> str:
-        return pathlib.Path(self.path_without_protocol).drive
+        if isinstance(self.path_without_protocol, int):
+            return ""
+        return pathlib.Path(self.path_without_protocol).drive  # pyre-ignore[6]
 
     @classmethod
     def from_uri(cls, path: PathLike) -> "FSPath":
         return cls.from_path(path)
 
-    @property
+    @cached_property
     def path_with_protocol(self) -> Union[str, int]:
+        """Return path with protocol, like file:///root"""
         if isinstance(self.path, int):
             return self.path
         protocol_prefix = self.protocol + "://"
@@ -327,19 +141,32 @@ class FSPath(URIPath):
             return self.path  # pyre-ignore[7]
         return protocol_prefix + self.path  # pyre-ignore[58]
 
+    @cached_property
+    def path_without_protocol(self) -> Union[str, int]:
+        """
+        Return path without protocol, example: if path is file:///root,
+        return /root
+        """
+        if isinstance(self.path, int):
+            return self.path
+        return super().path_without_protocol
+
     def is_absolute(self) -> bool:
         """Test whether a path is absolute
 
         :returns: True if a path is absolute, else False
         """
-        return os.path.isabs(self.path_without_protocol)
+        if isinstance(self.path_without_protocol, int):
+            return False
+        return os.path.isabs(self.path_without_protocol)  # pyre-ignore[6]
 
     def abspath(self) -> str:
         """Return the absolute path of given path
 
         :returns: Absolute path of given path
         """
-        return fspath(os.path.abspath(self.path_without_protocol))
+        self._check_int_path()
+        return fspath(os.path.abspath(self.path_without_protocol))  # pyre-ignore[6]
 
     def access(self, mode: Access = Access.READ) -> bool:
         """
@@ -512,7 +339,12 @@ class FSPath(URIPath):
         glob_path = self.path_without_protocol
         if pattern:
             glob_path = self.joinpath(pattern).path_without_protocol
-        for path in fs_iglob(glob_path, recursive=recursive, missing_ok=missing_ok):
+
+        for path in _create_missing_ok_generator(
+            iglob(fspath(glob_path), recursive=recursive),
+            missing_ok,
+            FileNotFoundError("No match any file: %r" % glob_path),
+        ):
             yield self.from_path(path)
 
     def is_dir(self, followlinks: bool = False) -> bool:
@@ -556,7 +388,8 @@ class FSPath(URIPath):
 
         :returns: All contents have in the path in ascending alphabetical order
         """
-        return sorted(os.listdir(self.path_without_protocol))
+        self._check_int_path()
+        return sorted(os.listdir(self.path_without_protocol))  # pyre-ignore[6]
 
     def iterdir(self) -> Iterator["FSPath"]:
         """
@@ -593,9 +426,13 @@ class FSPath(URIPath):
 
         :raises: FileExistsError
         """
-        if exist_ok and self.path_without_protocol == "":
+        if exist_ok and (
+            self.path_without_protocol == ""
+            or isinstance(self.path_without_protocol, int)
+        ):
             return
-        return pathlib.Path(self.path_without_protocol).mkdir(
+        self._check_int_path()
+        return pathlib.Path(self.path_without_protocol).mkdir(  # pyre-ignore[6]
             mode=mode, parents=parents, exist_ok=exist_ok
         )
 
@@ -604,7 +441,8 @@ class FSPath(URIPath):
 
         :returns: Real path of given path
         """
-        return fspath(os.path.realpath(self.path_without_protocol))
+        self._check_int_path()
+        return fspath(os.path.realpath(self.path_without_protocol))  # pyre-ignore[6]
 
     def relpath(self, start: Optional[str] = None) -> str:
         """Return the relative path of given path
@@ -612,7 +450,13 @@ class FSPath(URIPath):
         :param start: Given start directory
         :returns: Relative path from start
         """
-        return fspath(os.path.relpath(self.path_without_protocol, start=start))
+        self._check_int_path()
+        return fspath(
+            os.path.relpath(
+                self.path_without_protocol,  # pyre-ignore[6]
+                start=start,
+            )
+        )
 
     def rename(self, dst_path: PathLike, overwrite: bool = True) -> "FSPath":
         """
@@ -621,7 +465,32 @@ class FSPath(URIPath):
         :param dst_path: Given destination path
         :param overwrite: whether or not overwrite file when exists
         """
-        fs_rename(self.path_without_protocol, dst_path, overwrite)
+        self._check_int_path()
+
+        src_path, dst_path = fspath(self.path_without_protocol), fspath(dst_path)
+        if os.path.isfile(src_path):
+            _fs_rename_file(src_path, dst_path, overwrite)
+            return self.from_path(dst_path)
+        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():
+                    self.from_path(src_file_path).rename(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)
+
         return self.from_path(dst_path)
 
     def replace(self, dst_path: PathLike, overwrite: bool = True) -> "FSPath":
@@ -643,9 +512,9 @@ class FSPath(URIPath):
         if missing_ok and not self.exists():
             return
         if self.is_dir():
-            shutil.rmtree(self.path_without_protocol)
+            shutil.rmtree(self.path_without_protocol)  # pyre-ignore[6]
         else:
-            os.remove(self.path_without_protocol)
+            os.remove(self.path_without_protocol)  # pyre-ignore[6]
 
     def _scan(
         self, missing_ok: bool = True, followlinks: bool = False
@@ -724,10 +593,10 @@ class FSPath(URIPath):
 
         :returns: StatResult
         """
-        if follow_symlinks:
+        if follow_symlinks or isinstance(self.path_without_protocol, int):
             result = _make_stat(os.stat(self.path_without_protocol))
         else:
-            result = _make_stat(os.lstat(self.path_without_protocol))
+            result = _make_stat(os.lstat(self.path_without_protocol))  # pyre-ignore[6]
 
         if result.islnk or not result.isdir:
             return result
@@ -735,15 +604,16 @@ class FSPath(URIPath):
         size = 0
         ctime = result.ctime
         mtime = result.mtime
-        for root, _, files in os.walk(self.path_without_protocol):
-            for filename in files:
-                canonical_path = os.path.join(root, filename)
-                stat = os.lstat(canonical_path)
-                size += stat.st_size
-                if ctime > stat.st_ctime:
-                    ctime = stat.st_ctime
-                if mtime < stat.st_mtime:
-                    mtime = stat.st_mtime
+        if not isinstance(self.path_without_protocol, int):
+            for root, _, files in os.walk(self.path_without_protocol):  # pyre-ignore[6]
+                for filename in files:
+                    canonical_path = os.path.join(root, filename)
+                    stat = os.lstat(canonical_path)
+                    size += stat.st_size
+                    if ctime > stat.st_ctime:  # pyre-ignore[16]
+                        ctime = stat.st_ctime
+                    if mtime < stat.st_mtime:
+                        mtime = stat.st_mtime
         return result._replace(size=size, ctime=ctime, mtime=mtime)
 
     def unlink(self, missing_ok: bool = False) -> None:
@@ -752,9 +622,11 @@ class FSPath(URIPath):
 
         :param missing_ok: if False and target file not exists, raise FileNotFoundError
         """
+        self._check_int_path()
+
         if missing_ok and not self.exists():
             return
-        os.unlink(self.path_without_protocol)
+        os.unlink(self.path_without_protocol)  # pyre-ignore[6]
 
     def walk(
         self, followlinks: bool = False
@@ -783,6 +655,8 @@ class FSPath(URIPath):
 
         :returns: A 3-tuple generator
         """
+        self._check_int_path()
+
         if not self.exists(followlinks=followlinks):
             return
 
@@ -790,7 +664,7 @@ class FSPath(URIPath):
             return
 
         path = fspath(self.path_without_protocol)
-        path = os.path.normpath(self.path_without_protocol)
+        path = os.path.normpath(self.path_without_protocol)  # pyre-ignore[6]
 
         stack = [path]
         while stack:
@@ -820,8 +694,13 @@ class FSPath(URIPath):
             eliminating any symbolic links encountered in the path.
         :rtype: FSPath
         """
+        self._check_int_path()
         return self.from_path(
-            fspath(pathlib.Path(self.path_without_protocol).resolve(strict=strict))
+            fspath(
+                pathlib.Path(
+                    self.path_without_protocol  # pyre-ignore[6]
+                ).resolve(strict=strict)
+            )
         )
 
     def md5(self, recalculate: bool = False, followlinks: bool = True):
@@ -853,14 +732,29 @@ class FSPath(URIPath):
         callback: Optional[Callable[[int], None]] = None,
         followlinks: bool = False,
     ):
-        shutil.copy2(
-            self.path_without_protocol, fspath(dst_path), follow_symlinks=followlinks
-        )
+        if isinstance(self.path_without_protocol, int):
+            with open(fspath(dst_path), "wb") as fdst:
+                # This magic number is copied from  copyfileobj
+                length = 16 * 1024
+                while True:
+                    buf = os.read(self.path_without_protocol, length)  # pyre-ignore[6]
+                    if not buf:
+                        break
+                    fdst.write(buf)
+                    if callback is None:
+                        continue
+                    callback(len(buf))
+        else:
+            shutil.copy2(
+                self.path_without_protocol,  # pyre-ignore[6]
+                fspath(dst_path),
+                follow_symlinks=followlinks,
+            )
 
-        # After python3.8, patch `shutil.copyfile` is not a good way,
-        # because `shutil.copy2` will not call it in some cases.
-        if callback:
-            callback(self.stat(follow_symlinks=followlinks).size)
+            # After python3.8, patch `shutil.copyfile` is not a good way,
+            # because `shutil.copy2` will not call it in some cases.
+            if callback:
+                callback(self.stat(follow_symlinks=followlinks).size)
 
     def copy(
         self,
@@ -938,7 +832,7 @@ class FSPath(URIPath):
                 return ignore_files
 
             shutil.copytree(
-                self.path_without_protocol,
+                self.path_without_protocol,  # pyre-ignore[6]
                 dst_path,
                 ignore=ignore_same_file,
                 dirs_exist_ok=True,
@@ -952,7 +846,8 @@ class FSPath(URIPath):
 
         :param dst_path: Destination path
         """
-        return os.symlink(self.path_without_protocol, dst_path)
+        self._check_int_path()
+        return os.symlink(self.path_without_protocol, dst_path)  # pyre-ignore[6]
 
     def readlink(self) -> "FSPath":
         """
@@ -962,7 +857,12 @@ class FSPath(URIPath):
         :returns: Return a FSPath instance representing the path to which
             the symbolic link points.
         """
-        return self.from_path(fs_readlink(self.path_without_protocol))
+        self._check_int_path()
+        return self.from_path(
+            os.readlink(
+                self.path_without_protocol  # pyre-ignore[6]
+            )
+        )
 
     def is_symlink(self) -> bool:
         """Test whether a path is a symbolic link
@@ -984,14 +884,14 @@ class FSPath(URIPath):
 
         returns: Current working directory
         """
-        return self.from_path(fs_cwd())
+        return self.from_path(os.getcwd())
 
     def home(self):
         """Return the home directory
 
         returns: Home directory path
         """
-        return self.from_path(fs_home())
+        return self.from_path(os.path.expanduser("~"))
 
     def joinpath(self, *other_paths: PathLike) -> "FSPath":
         path = fspath(self)
@@ -1005,9 +905,11 @@ class FSPath(URIPath):
 
         :param file_object: stream to be read
         """
-        FSPath(os.path.dirname(self.path_without_protocol)).mkdir(
-            parents=True, exist_ok=True
-        )
+        FSPath(
+            os.path.dirname(
+                self.path_without_protocol  # pyre-ignore[6]
+            )
+        ).mkdir(parents=True, exist_ok=True)
         with open(self.path_without_protocol, "wb") as output:
             output.write(file_object.read())
 
@@ -1024,9 +926,11 @@ class FSPath(URIPath):
         if not isinstance(self.path_without_protocol, int) and (
             "w" in mode or "x" in mode or "a" in mode
         ):
-            FSPath(os.path.dirname(self.path_without_protocol)).mkdir(
-                parents=True, exist_ok=True
-            )
+            FSPath(
+                os.path.dirname(
+                    self.path_without_protocol  # pyre-ignore[6]
+                )
+            ).mkdir(parents=True, exist_ok=True)
         return io.open(
             self.path_without_protocol,
             mode,
@@ -1042,7 +946,8 @@ class FSPath(URIPath):
         """
         A tuple giving access to the path’s various components
         """
-        return pathlib.Path(self.path_without_protocol).parts
+        self._check_int_path()
+        return pathlib.Path(self.path_without_protocol).parts  # pyre-ignore[6]
 
     def chmod(self, mode: int, *, follow_symlinks: bool = True):
         """
@@ -1062,7 +967,8 @@ class FSPath(URIPath):
         Return the name of the group owning the file. KeyError is raised if
         the file’s gid isn’t found in the system database.
         """
-        return pathlib.Path(self.path_without_protocol).group()
+        self._check_int_path()
+        return pathlib.Path(self.path_without_protocol).group()  # pyre-ignore[6]
 
     def is_socket(self) -> bool:
         """
@@ -1072,7 +978,9 @@ class FSPath(URIPath):
         False is also returned if the path doesn’t exist or is a broken symlink;
         other errors (such as permission errors) are propagated.
         """
-        return pathlib.Path(self.path_without_protocol).is_socket()
+        if isinstance(self.path_without_protocol, int):
+            return bool(stat_issock(os.stat(self.path_without_protocol).st_mode))
+        return pathlib.Path(self.path_without_protocol).is_socket()  # pyre-ignore[6]
 
     def is_fifo(self) -> bool:
         """
@@ -1082,7 +990,9 @@ class FSPath(URIPath):
         False is also returned if the path doesn’t exist or is a broken symlink;
         other errors (such as permission errors) are propagated.
         """
-        return pathlib.Path(self.path_without_protocol).is_fifo()
+        if isinstance(self.path_without_protocol, int):
+            return bool(stat_isfifo(os.stat(self.path_without_protocol).st_mode))
+        return pathlib.Path(self.path_without_protocol).is_fifo()  # pyre-ignore[6]
 
     def is_block_device(self) -> bool:
         """
@@ -1092,7 +1002,11 @@ class FSPath(URIPath):
         False is also returned if the path doesn’t exist or is a broken symlink;
         other errors (such as permission errors) are propagated.
         """
-        return pathlib.Path(self.path_without_protocol).is_block_device()
+        if isinstance(self.path_without_protocol, int):
+            return bool(stat_isblk(os.stat(self.path_without_protocol).st_mode))
+        return pathlib.Path(
+            self.path_without_protocol  # pyre-ignore[6]
+        ).is_block_device()
 
     def is_char_device(self) -> bool:
         """
@@ -1102,21 +1016,31 @@ class FSPath(URIPath):
         False is also returned if the path doesn’t exist or is a broken symlink;
         other errors (such as permission errors) are propagated.
         """
-        return pathlib.Path(self.path_without_protocol).is_char_device()
+        if isinstance(self.path_without_protocol, int):
+            return bool(stat_ischr(os.stat(self.path_without_protocol).st_mode))
+        return pathlib.Path(
+            self.path_without_protocol  # pyre-ignore[6]
+        ).is_char_device()
 
     def owner(self) -> str:
         """
         Return the name of the user owning the file. KeyError is raised if the file’s
         uid isn’t found in the system database.
         """
-        return pathlib.Path(self.path_without_protocol).owner()
+        self._check_int_path()
+        return pathlib.Path(self.path_without_protocol).owner()  # pyre-ignore[6]
 
     def absolute(self) -> "FSPath":
         """
         Make the path absolute, without normalization or resolving symlinks.
         Returns a new path object
         """
-        return self.from_path(os.path.abspath(self.path_without_protocol))
+        self._check_int_path()
+        return self.from_path(
+            os.path.abspath(
+                self.path_without_protocol  # pyre-ignore[6]
+            )
+        )
 
     def rmdir(self):
         """