tensorneko-util 0.3.16__py3-none-any.whl → 0.3.18__py3-none-any.whl

tensorneko_util/io/_path_conversion.py

@@ -0,0 +1,25 @@
+from typing import Union
+from pathlib import Path
+
+
+def _path2str(path: Union[str, Path]) -> str:
+    """
+    Convert a path to a string.
+
+    Args:
+        path (``Union[str, Path]``): The path to be converted.
+
+    Returns:
+        ``str``: The string of the path.
+
+    Examples::
+
+        >>> _path2str("a/b/c")
+        'a/b/c'
+        >>> _path2str(Path("a/b/c"))
+        'a/b/c'
+
+    """
+    if isinstance(path, Path):
+        return str(path)
+    return path

tensorneko_util/io/audio/audio_reader.py

@@ -1,9 +1,11 @@
-from typing import Optional
+from typing import Optional, Union
+from pathlib import Path
 
 import numpy as np
 
 from .audio_data import AudioData
 from .._default_backends import _default_audio_io_backend
+from .._path_conversion import _path2str
 from ...backend.audio_lib import AudioLib
 
 
@@ -11,12 +13,12 @@ class AudioReader:
     """AudioReader for reading audio file"""
 
     @staticmethod
-    def of(path: str, channel_first: bool = True, backend: Optional[AudioLib] = None) -> AudioData:
+    def of(path: Union[str, Path], channel_first: bool = True, backend: Optional[AudioLib] = None) -> AudioData:
         """
         Read audio tensor from given file.
 
         Args:
-            path (``str``): Path to the audio file.
+            path (``str`` | ``pathlib.Path``): Path to the audio file.
             channel_first (``bool``, optional): Whether the audio is channel first. The output shape is (C, T) if true
                 and (T, C) if false. Default: True.
             backend (:class:`~tensorneko.io.audio.audio_lib.AudioLib`, optional): The audio library to use.
@@ -26,6 +28,7 @@ class AudioReader:
             :class:`~.audio_data.AudioData`: The Audio data in the file.
         """
         backend = backend or _default_audio_io_backend()
+        path = _path2str(path)
 
         if backend == AudioLib.PYTORCH:
             if not AudioLib.pytorch_available():
@@ -62,6 +65,6 @@ class AudioReader:
         else:
             raise ValueError("Unknown audio library: {}".format(backend))
 
-    def __new__(cls, path: str, channel_first: bool = True, backend: Optional[AudioLib] = None) -> AudioData:
+    def __new__(cls, path: Union[str, Path], channel_first: bool = True, backend: Optional[AudioLib] = None) -> AudioData:
         """Alias of :meth:`~AudioReader.of`"""
         return cls.of(path, channel_first, backend)

tensorneko_util/io/audio/audio_writer.py

@@ -1,7 +1,9 @@
 from typing import Union
+from pathlib import Path
 
 from .audio_data import AudioData
 from .._default_backends import _default_audio_io_backend
+from .._path_conversion import _path2str
 from ...backend.audio_lib import AudioLib
 from ...util import dispatch
 from ...util.type import T_ARRAY
@@ -12,30 +14,31 @@ class AudioWriter:
 
     @classmethod
     @dispatch
-    def to(cls, path: str, audio: AudioData, channel_first: bool = True, backend: AudioLib = None) -> None:
+    def to(cls, path: Union[str, Path], audio: AudioData, channel_first: bool = True, backend: AudioLib = None) -> None:
         """
         Save wav file from :class:`~tensorneko.io.audio.audio_data.AudioData`.
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             audio (:class:`~tensorneko.io.audio.AudioData`): The AudioData object for output.
             channel_first (``bool``, optional): Whether the audio is channel first. The input shape is (C, T) if true
                 and (T, C) if false. Default: True.
             backend (:class:`~tensorneko.io.audio.audio_lib.AudioLib`, optional): The audio library to use.
                 Default: pytorch.
         """
+        path = _path2str(path)
         return cls.to(path, audio.audio, audio.sample_rate, channel_first, backend)
 
     @classmethod
     @dispatch
-    def to(cls, path: str, audio: T_ARRAY, sample_rate: int = 16000, channel_first: bool = True,
+    def to(cls, path: Union[str, Path], audio: T_ARRAY, sample_rate: int = 16000, channel_first: bool = True,
         backend: AudioLib = None
     ):
         """
         Save wav file from :class:`~torch.Tensor` or :class:`~numpy.ndarray` with (C, T).
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             audio (:class:`~torch.Tensor` | :class:`~numpy.ndarray`): The tensor or array of audio.
             sample_rate (``int``, optional): The sample rate of the audio. Default: 16000.
             channel_first (``bool``, optional): Whether the audio is channel first. The input shape is (C, T) if true
@@ -44,6 +47,7 @@ class AudioWriter:
                 Default: pytorch.
         """
         backend = backend or _default_audio_io_backend()
+        path = _path2str(path)
 
         if backend == AudioLib.PYTORCH:
             if not AudioLib.pytorch_available():
@@ -53,6 +57,6 @@ class AudioWriter:
         else:
             raise ValueError("Unknown audio library: {}".format(backend))
 
-    def __new__(cls, path: str, audio: Union[AudioData, T_ARRAY], *args, **kwargs):
+    def __new__(cls, path: Union[str, Path], audio: Union[AudioData, T_ARRAY], *args, **kwargs):
         """Alias to :meth:`~AudioWriter.to`"""
         return cls.to(path, audio, *args, **kwargs)

tensorneko_util/io/hdf5/hdf5_reader.py

@@ -1,21 +1,27 @@
+from typing import Union
+from pathlib import Path
+
 import h5py
 
+from .._path_conversion import _path2str
+
 
 class Hdf5Reader:
 
     @classmethod
-    def of(cls, path: str) -> h5py.File:
+    def of(cls, path: Union[str, Path]) -> h5py.File:
         """
         Open a hdf5 file.
 
         Args:
-            path (``str``): Path to the hdf5 file.
+            path (``str`` | ``pathlib.Path``): Path to the hdf5 file.
 
         Returns:
             :class:`h5py.File`: The opened hdf5 file.
 
         """
+        path = _path2str(path)
         return h5py.File(path, "r")
 
-    def __new__(cls, path: str):
+    def __new__(cls, path: Union[str, Path]):
         return cls.of(path)

tensorneko_util/io/hdf5/hdf5_writer.py

@@ -1,10 +1,13 @@
+from typing import Union
+from pathlib import Path
+
 import h5py
 
 
 class Hdf5Writer:
 
     @classmethod
-    def to(cls, path: str):
+    def to(cls, path: Union[str, Path]):
         raise NotImplementedError("Hdf5Writer is not implemented yet.")
 
     def __new__(cls, *args, **kwargs):

tensorneko_util/io/image/image_reader.py

@@ -1,8 +1,10 @@
-from typing import Optional
+from typing import Optional, Union
+from pathlib import Path
 
 import numpy as np
 from einops import rearrange
 
+from .._path_conversion import _path2str
 from ...backend.visual_lib import VisualLib
 from ...util.type import T_ARRAY
 from .._default_backends import _default_image_io_backend
@@ -12,12 +14,12 @@ class ImageReader:
     """ImageReader for reading images as :class:`~torch.Tensor`"""
 
     @classmethod
-    def of(cls, path: str, channel_first: bool = False, backend: Optional[VisualLib] = None) -> T_ARRAY:
+    def of(cls, path: Union[str, Path], channel_first: bool = False, backend: Optional[VisualLib] = None) -> T_ARRAY:
         """
         Read image tensor of given file.
 
         Args:
-            path (``str``): Path of the JPEG or PNG image.
+            path (``str`` | ``pathlib.Path``): Path of the JPEG or PNG image.
             channel_first (``bool``, optional): Get image dimension (H, W, C) if False or (C, H, W) if True.
                 Default: False.
             backend (:class:`~tensorneko_util.backend.visual_lib.VisualLib`, optional): The backend library for saving.
@@ -27,6 +29,7 @@ class ImageReader:
             :class:`~numpy.ndarray` | :class:`~torch.Tensor`: A float tensor of image, with value range of 0. to 1.
         """
         backend = backend or _default_image_io_backend()
+        path = _path2str(path)
 
         if backend == VisualLib.OPENCV:
             if not VisualLib.opencv_available():
@@ -61,6 +64,6 @@ class ImageReader:
 
         return img
 
-    def __new__(cls, path: str, channel_first: bool = True, backend: Optional[VisualLib] = None) -> T_ARRAY:
+    def __new__(cls, path: Union[str, Path], channel_first: bool = True, backend: Optional[VisualLib] = None) -> T_ARRAY:
         """Alias of :meth:`~ImageReader.of`"""
         return cls.of(path, channel_first, backend)

tensorneko_util/io/image/image_writer.py

@@ -1,11 +1,13 @@
 import pathlib
-from typing import Optional
+from typing import Optional, Union
+from pathlib import Path
 
 import numpy as np
 from einops import rearrange
 from numpy import ndarray
 
 from .._default_backends import _default_image_io_backend
+from .._path_conversion import _path2str
 from ...backend.visual_lib import VisualLib
 from ...util.type import T_ARRAY
 
@@ -37,14 +39,14 @@ class ImageWriter:
         return img_out
 
     @classmethod
-    def to_jpeg(cls, path: str, image: T_ARRAY, quality: int = 75, channel_first: bool = False,
+    def to_jpeg(cls, path: Union[str, Path], image: T_ARRAY, quality: int = 75, channel_first: bool = False,
         backend: Optional[VisualLib] = None
     ) -> None:
         """
         Save as jpeg files from :class:`~torch.Tensor` or :class:`~numpy.ndarray`. The value range is [0, 1].
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             image (:class:`~torch.Tensor` | :class:`~numpy.ndarray`): The image tensor for output.
             quality (``int``, optional): The quality level for jpg from 0 to 100. Higher means quality is better.
                 Default: 75.
@@ -54,6 +56,7 @@ class ImageWriter:
                 Default: "opencv" if installed else "matplotlib".
         """
         backend = backend or _default_image_io_backend()
+        path = _path2str(path)
         image = cls._convert_img_format(image, backend, channel_first)
 
         if backend == VisualLib.OPENCV:
@@ -73,14 +76,14 @@ class ImageWriter:
             raise ValueError("Unknown backend library.")
 
     @classmethod
-    def to_png(cls, path: str, image: T_ARRAY, compression_level: int = 6, channel_first: bool = False,
+    def to_png(cls, path: Union[str, Path], image: T_ARRAY, compression_level: int = 6, channel_first: bool = False,
         backend: Optional[VisualLib] = None
     ) -> None:
         """
         Save as png files from :class:`~torch.Tensor` or :class:`~numpy.ndarray` with (C, H, W) or (H, W, C).
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             image (:class:`~torch.Tensor` | :class:`~numpy.ndarray`): The image tensor for output.
             compression_level (``int``, optional): The compression level png from 0 to 9. Higher means quality is worse.
                 Default: 6
@@ -90,6 +93,7 @@ class ImageWriter:
                 Default: "opencv" if installed else "matplotlib".
         """
         backend = backend or _default_image_io_backend()
+        path = _path2str(path)
         image = cls._convert_img_format(image, backend, channel_first)
         if backend == VisualLib.OPENCV:
             if not VisualLib.opencv_available():
@@ -119,16 +123,17 @@ class ImageWriter:
             raise ValueError("Unknown backend library.")
 
     @classmethod
-    def to(cls, path: str, image: T_ARRAY, *args, **kwargs) -> None:
+    def to(cls, path: Union[str, Path], image: T_ARRAY, *args, **kwargs) -> None:
         """
         Save as png files from :class:`~torch.Tensor` or :class:`~numpy.ndarray` with (C, H, W).
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             image (:class:`~torch.Tensor` | :class:`~numpy.ndarray`): The image tensor for output.
             *args: The arguments for :meth:`ImageWriter.to_jpeg` or :meth:`ImageWriter.to_png`.
             **kwargs: The keyword arguments for :meth:`ImageWriter.to_jpeg` or :meth:`ImageWriter.to_png`.
         """
+        path = _path2str(path)
         ext = pathlib.Path(path).suffix
         if ext in ('.jpg', '.jpeg'):
             cls.to_jpeg(path, image, *args, **kwargs)
@@ -137,6 +142,6 @@ class ImageWriter:
         else:
             raise ValueError("Unknown file extension. Now only support .jpg, .jpeg and .png.")
 
-    def __new__(cls, path: str, image: T_ARRAY, *args, **kwargs) -> None:
+    def __new__(cls, path: Union[str, Path], image: T_ARRAY, *args, **kwargs) -> None:
         """Alias of :meth:`ImageWriter.to`"""
         cls.to(path, image, *args, **kwargs)

tensorneko_util/io/json/json_reader.py

@@ -1,7 +1,9 @@
 import json
 import warnings
-from typing import Union, Optional, List
+from typing import Union, Optional, List, Union
+from pathlib import Path
 
+from .._path_conversion import _path2str
 from ...util.type import T
 
 
@@ -18,13 +20,13 @@ class JsonReader:
                 return orjson.loads(file.read())
 
     @classmethod
-    def of(cls, path: str, clazz: Optional[T] = None, encoding: str = "UTF-8", fast: bool = True
+    def of(cls, path: Union[str, Path], clazz: Optional[T] = None, encoding: str = "UTF-8", fast: bool = True
     ) -> Union[T, dict, list]:
         """
         Read json files to ``list`` or ``dict``.
 
         Args:
-            path (``str``): Json file path.
+            path (``str`` | ``pathlib.Path``): Json file path.
             clazz: (``T``, optional): The object of the json read for. The type should be decorated by
                 :func:`json_data`. This should be ``T`` or ``List[T]`` or ``List[List[T]]``
             encoding (``str``, optional): The encoding for python ``open`` function. Default: "UTF-8"
@@ -34,6 +36,7 @@ class JsonReader:
         Returns:
             ``dict`` | ``list`` | ``object``: The object of given json.
         """
+        path = _path2str(path)
         if fast:
             try:
                 import orjson
@@ -73,13 +76,13 @@ class JsonReader:
 
 
     @classmethod
-    def of_jsonl(cls, path: str, clazz: Optional[T] = None, encoding: str = "UTF-8", fast: bool = True
+    def of_jsonl(cls, path: Union[str, Path], clazz: Optional[T] = None, encoding: str = "UTF-8", fast: bool = True
     ) -> List[Union[T, dict, list]]:
         """
         Read jsonl files to ``list`` or ``dict``.
 
         Args:
-            path (``str``): Jsonl file path.
+            path (``str`` | ``pathlib.Path``): Jsonl file path.
             clazz: (``T``, optional): The object of the jsonl read for. The type should be decorated by
                 :func:`json_data`. This should be ``T`` or ``List[T]`` or ``List[List[T]]``
             encoding (``str``, optional): The encoding for python ``open`` function. Default: "UTF-8"
@@ -89,6 +92,7 @@ class JsonReader:
         Returns:
             ``List[dict]`` | ``List[list]`` | ``List[T]``: The object of given jsonl.
         """
+        path = _path2str(path)
         if fast:
             try:
                 import orjson
@@ -139,12 +143,12 @@ class JsonReader:
 
         return obj
 
-    def __new__(cls, path: str, clazz: T = None, encoding: str = "UTF-8", fast: bool = True) -> Union[T, dict, list]:
+    def __new__(cls, path: Union[str, Path], clazz: T = None, encoding: str = "UTF-8", fast: bool = True) -> Union[T, dict, list]:
         """
         Read json or jsonl file smartly.
 
         Args:
-            path (``str``): Json or jsonl file path.
+            path (``str`` | ``pathlib.Path``): Json or jsonl file path.
             clazz: (``T``, optional): The object of the json read for. The type should be decorated by
                 :func:`json_data`. This should be ``T`` or ``List[T]`` or ``List[List[T]]``
             encoding (``str``, optional): The encoding for python ``open`` function. Default: "UTF-8"
@@ -154,6 +158,7 @@ class JsonReader:
         Returns:
             ``dict`` | ``list`` | ``object``: The object of given json or jsonl.
         """
+        path = _path2str(path)
         if path.endswith(".jsonl"):
             return cls.of_jsonl(path, clazz, encoding, fast)
         else:

tensorneko_util/io/json/json_writer.py

@@ -1,6 +1,9 @@
 import json
 import warnings
 from typing import Union
+from pathlib import Path
+
+from .._path_conversion import _path2str
 
 
 class JsonWriter:
@@ -25,14 +28,14 @@ class JsonWriter:
                 file.write(orjson.dumps(obj, option=option))
 
     @classmethod
-    def to(cls, path: str, obj: Union[dict, list, object], encoding: str = "UTF-8", indent: int = 4,
+    def to(cls, path: Union[str, Path], obj: Union[dict, list, object], encoding: str = "UTF-8", indent: int = 4,
         ensure_ascii: bool = False, fast: bool = True
     ) -> None:
         """
         Save as Json file from a dictionary, list or json_dict.
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             obj (``dict`` | ``list`` | ``object``): The json data which need to be used for output. The type should be
                 ``dict``, ``list`` or the ``object`` decorated by :func:`~tensorneko.io.text.text_reader.json_data`.
             encoding (``str``, optional): Python file IO encoding parameter. Default: "UTF-8".
@@ -41,6 +44,7 @@ class JsonWriter:
             fast (``bool``, optional): Whether to use faster `orjson`. If `orjson` is not installed, use
                 `json` library. Default: True
         """
+        path = _path2str(path)
         if fast:
             try:
                 import orjson
@@ -64,8 +68,9 @@ class JsonWriter:
         else:
             raise TypeError("Not implemented type. Only support dict, list, json_data.")
 
-    def __new__(cls, path: str, obj: Union[dict, list, object], encoding: str = "UTF-8", indent: int = 4,
+    def __new__(cls, path: Union[str, Path], obj: Union[dict, list, object], encoding: str = "UTF-8", indent: int = 4,
         ensure_ascii: bool = False, fast: bool = True
     ) -> None:
         """Alias of :meth:`~tensorneko.io.json.json_writer.JsonWriter.to`."""
+        path = _path2str(path)
         cls.to(path, obj, encoding, indent, ensure_ascii, fast)

tensorneko_util/io/matlab/mat_reader.py

@@ -1,20 +1,24 @@
-from typing import Dict, Any
+from typing import Dict, Any, Union
+from pathlib import Path
 
 import scipy.io
 
+from .._path_conversion import _path2str
+
 
 class MatReader:
 
     @classmethod
-    def of(cls, path: str) -> Dict[str, Any]:
+    def of(cls, path: Union[str, Path]) -> Dict[str, Any]:
         """
         Read a mat file.
 
         Args:
-            path (``str``): The path of the mat file.
+            path (``str`` | ``pathlib.Path``): The path of the mat file.
         """
+        path = _path2str(path)
         return scipy.io.loadmat(path)
 
-    def __new__(cls, path: str) -> Dict[str, Any]:
+    def __new__(cls, path: Union[str, Path]) -> Dict[str, Any]:
         """Alias to :meth:`~tensorneko_util.io.matlab.MatReader.of`."""
         return cls.of(path)

tensorneko_util/io/matlab/mat_writer.py

@@ -1,21 +1,25 @@
-from typing import Dict, Any
+from typing import Dict, Any, Union
+from pathlib import Path
 
 import scipy.io
 
+from .._path_conversion import _path2str
+
 
 class MatWriter:
 
     @classmethod
-    def to(cls, path: str, data: Dict[str, Any]) -> None:
+    def to(cls, path: Union[str, Path], data: Dict[str, Any]) -> None:
         """
         Write data to a mat file.
 
         Args:
-            path (``str``): path to write.
+            path (``str`` | ``pathlib.Path``): path to write.
             data (``Dict[str, Any]``): data to write.
         """
+        path = _path2str(path)
         scipy.io.savemat(path, data)
 
-    def __new__(cls, path: str, data: Dict[str, Any]) -> None:
+    def __new__(cls, path: Union[str, Path], data: Dict[str, Any]) -> None:
         """Alias to :meth:`~tensorneko_util.io.mat_writer.MatWriter.to`."""
         cls.to(data, path)

tensorneko_util/io/npy/npy_reader.py

@@ -1,46 +1,51 @@
 from typing import Union
+from pathlib import Path
 
 import numpy as np
 from numpy.lib.npyio import NpzFile
 
+from .._path_conversion import _path2str
+
 
 class NpyReader:
 
     @classmethod
-    def of(cls, path: str) -> Union[np.ndarray, NpzFile]:
+    def of(cls, path: Union[str, Path]) -> Union[np.ndarray, NpzFile]:
         """
         Read numpy array from file.
 
         Args:
-            path (``str``): Path of the numpy file.
+            path (``str`` | ``pathlib.Path``): Path of the numpy file.
 
         Returns:
             :class:`~numpy.ndarray` | :class:`~numpy.lib.npyio.NpzFile`: The numpy array.
         """
+        path = _path2str(path)
         return np.load(path)
 
     @classmethod
-    def of_csc(cls, path: str) -> np.ndarray:
+    def of_csc(cls, path: Union[str, Path]) -> np.ndarray:
         """
         Read numpy array from file as CSC sparse matrix.
 
         Args:
-            path (``str``): Path of the numpy file.
+            path (``str`` | ``pathlib.Path``): Path of the numpy file.
 
         Returns:
             :class:`~numpy.ndarray`: The numpy array.
 
         """
+        path = _path2str(path)
         import scipy.sparse
         return scipy.sparse.load_npz(path).toarray()
 
     @classmethod
-    def of_txt(cls, path: str, delimiter: str = ' ', dtype: type = float) -> np.ndarray:
+    def of_txt(cls, path: Union[str, Path], delimiter: str = ' ', dtype: type = float) -> np.ndarray:
         """
         Read numpy array from file as text format.
 
         Args:
-            path (``str``): Path of the numpy file.
+            path (``str`` | ``pathlib.Path``): Path of the numpy file.
             delimiter (``str``, optional): The delimiter for each element.
                 Default: ' '
             dtype (``type``, optional): The data type for each element.
@@ -49,10 +54,11 @@ class NpyReader:
         Returns:
             :class:`~numpy.ndarray`: The numpy array.
         """
+        path = _path2str(path)
         return np.loadtxt(path, delimiter=delimiter, dtype=dtype)
 
-    @classmethod
-    def __new__(cls, path: str, *args, **kwargs) -> Union[np.ndarray, NpzFile]:
+    def __new__(cls, path: Union[str, Path], *args, **kwargs) -> Union[np.ndarray, NpzFile]:
+        path = _path2str(path)
         ext = path.split(".")[-1]
         if ext in ("npz", "npy"):
             return cls.of(path)

tensorneko_util/io/npy/npy_writer.py

@@ -1,64 +1,73 @@
+from typing import Union
+from pathlib import Path
+
 import numpy as np
 
+from .._path_conversion import _path2str
+
 
 class NpyWriter:
 
     @classmethod
-    def to(cls, path: str, arr: np.ndarray) -> None:
+    def to(cls, path: Union[str, Path], arr: np.ndarray) -> None:
         """
         Save numpy array to file.
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             arr (:class:`~numpy.ndarray`): The numpy array for output.
         """
+        path = _path2str(path)
         np.save(path, arr)
 
     @classmethod
-    def to_csc(cls, path: str, arr: np.ndarray) -> None:
+    def to_csc(cls, path: Union[str, Path], arr: np.ndarray) -> None:
         """
         Save numpy array to file as CSC sparse matrix.
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             arr (:class:`~numpy.ndarray`): The numpy array for output.
         """
+        path = _path2str(path)
         import scipy.sparse
         scipy.sparse.save_npz(path, scipy.sparse.csc_matrix(arr))
 
     @classmethod
-    def to_npz(cls, path: str, compressed: bool = False, **kwargs) -> None:
+    def to_npz(cls, path: Union[str, Path], compressed: bool = False, **kwargs) -> None:
         """
         Save numpy array to file as npz format.
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             compressed (``bool``, optional): The flag for compressed npz file.
                 Default: False
             **kwargs: The numpy arrays for output.
         """
+        path = _path2str(path)
         if compressed:
             np.savez_compressed(path, **kwargs)
         else:
             np.savez(path, **kwargs)
 
     @classmethod
-    def to_txt(cls, path: str, arr: np.ndarray, delimiter: str = ' ', newline: str = '\n') -> None:
+    def to_txt(cls, path: Union[str, Path], arr: np.ndarray, delimiter: str = ' ', newline: str = '\n') -> None:
         """
         Save numpy array to file as text format.
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             arr (:class:`~numpy.ndarray`): The numpy array for output.
             delimiter (``str``, optional): The delimiter for each element.
                 Default: ' '
             newline (``str``, optional): The newline for each row.
                 Default: '\n'
         """
+        path = _path2str(path)
         np.savetxt(path, arr, delimiter=delimiter, newline=newline)
 
-    @classmethod
-    def __new__(cls, path: str, *args, **kwargs) -> None:
+    def __new__(cls, path: Union[str, Path], *args, **kwargs) -> None:
+        path = _path2str(path)
         ext = path.split(".")[-1]
         if ext == "npy":
             return cls.to(path, *args, **kwargs)