tensorneko-util 0.3.17__py3-none-any.whl → 0.3.19__py3-none-any.whl

tensorneko_util/io/pickle/pickle_reader.py

@@ -1,19 +1,25 @@
 import pickle
+from typing import Union, Any
+from pathlib import Path
+
+from .._path_conversion import _path2str
 
 
 class PickleReader:
 
     @classmethod
-    def of(cls, path: str) -> None:
+    def of(cls, path: Union[str, Path]) -> Any:
         """
         Save the object to a file.
 
         Args:
-            path (``str``): The path to the file.
+            path (``str`` | ``pathlib.Path``): The path to the file.
         """
+        path = _path2str(path)
         with open(path, 'rb') as f:
             return pickle.load(f)
 
-    def __new__(cls, path: str) -> None:
+    def __new__(cls, path: Union[str, Path]) -> Any:
         """Alias to :meth:`~tensorneko_util.io.pickle.PickleReader.of`."""
+        path = _path2str(path)
         return cls.of(path)

tensorneko_util/io/pickle/pickle_writer.py

@@ -1,20 +1,26 @@
 import pickle
+from typing import Union
+from pathlib import Path
+
+from .._path_conversion import _path2str
 
 
 class PickleWriter:
 
     @classmethod
-    def to(cls, path: str, obj: object) -> None:
+    def to(cls, path: Union[str, Path], obj: object) -> None:
         """
         Save the object to a file.
 
         Args:
-            path (``str``): The path to the file.
+            path (``str`` | ``pathlib.Path``): The path to the file.
             obj (``object``): The object to save.
         """
+        path = _path2str(path)
         with open(path, 'wb') as f:
             pickle.dump(obj, f)
 
-    def __new__(cls, path: str, obj: object) -> None:
+    def __new__(cls, path: Union[str, Path], obj: object) -> None:
         """Alias to :meth:`~tensorneko_util.io.pickle.PickleWriter.to`."""
+        path = _path2str(path)
         return cls.to(path, obj)

tensorneko_util/io/reader.py

@@ -1,5 +1,7 @@
-from typing import Type
+from typing import Type, Union, Any
+from pathlib import Path
 
+from ._path_conversion import _path2str
 from .audio import AudioReader
 from .image import ImageReader
 from .json import JsonReader
@@ -88,8 +90,10 @@ class Reader:
         else:
             raise ImportError("To use the toml reader, please install toml.")
 
-    def __call__(self, path: str, *args, **kwargs):
+    def __call__(self, path: Union[str, Path], *args, **kwargs) -> Any:
         """Automatically infer the file type and return the corresponding result. """
+        path = _path2str(path)
+
         if path.endswith(".jpg") or path.endswith(".jpeg") or path.endswith(".png") or path.endswith(".bmp"):
             return self.image(path, *args, **kwargs)
         elif path.endswith(".txt"):

tensorneko_util/io/text/text_reader.py

@@ -1,24 +1,32 @@
+from typing import Union
+from pathlib import Path
+
+from .._path_conversion import _path2str
+
+
 class TextReader:
     """TextReader for reading text file"""
 
     @staticmethod
-    def of_plain(path: str, encoding: str = "UTF-8") -> str:
+    def of_plain(path: Union[str, Path], encoding: str = "UTF-8") -> str:
         """
         Read texts of a file.
 
         Args:
-            path (``str``): Text file path.
+            path (``str`` | ``pathlib.Path``): Text file path.
             encoding (``str``, optional): File encoding. Default "UTF-8".
 
         Returns:
             ``str``: The texts of given file.
         """
+        path = _path2str(path)
         with open(path, "r", encoding=encoding) as file:
             text = file.read()
         return text
 
     of = of_plain
 
-    def __new__(cls, path: str, encoding: str = "UTF-8") -> str:
+    def __new__(cls, path: Union[str, Path], encoding: str = "UTF-8") -> str:
         """Alias of :meth:`~TextReader.of"""
+        path = _path2str(path)
         return cls.of(path, encoding)

tensorneko_util/io/text/text_writer.py

@@ -1,21 +1,29 @@
+from typing import Union
+from pathlib import Path
+
+from .._path_conversion import _path2str
+
+
 class TextWriter:
     """TextWriter for writing files for text"""
 
     @staticmethod
-    def to_plain(path: str, text: str, encoding: str = "UTF-8") -> None:
+    def to_plain(path: Union[str, Path], text: str, encoding: str = "UTF-8") -> None:
         """
         Save as a plain text file.
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             text (``str``): The content for output.
             encoding (``str``, optional): Python file IO encoding parameter. Default: "UTF-8".
         """
+        path = _path2str(path)
         with open(path, "w", encoding=encoding) as file:
             file.write(text)
 
     to = to_plain
 
-    def __new__(cls, path: str, text: str, encoding: str = "UTF-8") -> None:
+    def __new__(cls, path: Union[str, Path], text: str, encoding: str = "UTF-8") -> None:
         """Alias of :meth:`~TextWriter.to`"""
+        path = _path2str(path)
         cls.to(path, text, encoding)

tensorneko_util/io/toml/toml_reader.py

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

tensorneko_util/io/toml/toml_writer.py

@@ -1,21 +1,27 @@
 import toml
+from typing import Union
+from pathlib import Path
+
+from .._path_conversion import _path2str
 
 
 class TomlWriter:
 
     @classmethod
-    def to(cls, path: str, obj: dict):
+    def to(cls, path: Union[str, Path], obj: dict):
         """
         Save as Toml file from a dictionary.
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             obj (``dict``): The toml data which need to be used for output.
         """
+        path = _path2str(path)
         with open(path, "w", encoding="UTF-8") as f:
             toml.dump(obj, f)
 
     @classmethod
-    def __new__(cls, path: str, obj: dict):
+    def __new__(cls, path: Union[str, Path], obj: dict):
         """Alias of :meth:`~tensorneko.io.toml.toml_writer.TomlWriter.to`."""
+        path = _path2str(path)
         cls.to(path, obj)

tensorneko_util/io/video/video_reader.py

@@ -1,11 +1,13 @@
 from itertools import islice, takewhile
-from typing import Optional
+from typing import Optional, Union
+from pathlib import Path
 
 import numpy as np
 from einops import rearrange
 
 from .video_data import VideoData
 from .._default_backends import _default_video_io_backend
+from .._path_conversion import _path2str
 from ...backend.visual_lib import VisualLib
 from ...util import dispatch
 
@@ -13,12 +15,12 @@ from ...util import dispatch
 class VideoReader:
 
     @classmethod
-    def of(cls, path: str, channel_first: bool = True, backend: Optional[VisualLib] = None) -> VideoData:
+    def of(cls, path: Union[str, Path], channel_first: bool = True, backend: Optional[VisualLib] = None) -> VideoData:
         """
         Read video array from given file.
 
         Args:
-            path (``str``): Path to the video file.
+            path (``str`` | ``pathlib.Path``): Path to the video file.
             channel_first (``bool``, optional): Get image dimension (T, H, W, C) if False or (T, C, H, W) if True.
                 Default: True.
             backend (:class:`~tensorneko.backend.visual_lib.VisualLib`, optional): VisualLib backend.
@@ -30,6 +32,7 @@ class VideoReader:
                 an audio tensor of (T, C) and a :class:`~tensorneko.io.video.video_data.VideoInfo` contains fps info.
         """
         backend = backend or _default_video_io_backend()
+        path = _path2str(path)
         if backend == VisualLib.OPENCV:
             if not VisualLib.opencv_available():
                 raise ValueError("OpenCV is not installed.")
@@ -83,13 +86,13 @@ class VideoReader:
             raise ValueError("Unknown backend: {}".format(backend))
 
     @classmethod
-    def with_indexes(cls, path: str, indexes: np.ndarray,
+    def with_indexes(cls, path: Union[str, Path], indexes: np.ndarray,
         channel_first: bool = True, backend: Optional[VisualLib] = None
     ) -> VideoData:
         """
         Get a video frames with indexes. The audio will be ignored.
         Args:
-            path (``str``): Path to the video file.
+            path (``str`` | ``pathlib.Path``): Path to the video file.
             indexes (``np.ndarray``): Indexes of the video.
             channel_first (``bool``, optional): Get image dimension (T, H, W, C) if False or (T, C, H, W) if True.
                 Default: True.
@@ -102,6 +105,7 @@ class VideoReader:
                 an audio tensor of (T, C) and a :class:`~tensorneko.io.video.video_data.VideoInfo` contains fps info.
         """
         backend = backend or _default_video_io_backend()
+        path = _path2str(path)
         if backend == VisualLib.OPENCV:
             if not VisualLib.opencv_available():
                 raise ValueError("OpenCV is not installed.")
@@ -176,10 +180,11 @@ class VideoReader:
 
     @classmethod
     @dispatch
-    def with_range(cls, path: str, start: int, end: int, step: int, channel_first: bool = True,
+    def with_range(cls, path: Union[str, Path], start: int, end: int, step: int, channel_first: bool = True,
         backend: Optional[VisualLib] = None
     ) -> VideoData:
         backend = backend or _default_video_io_backend()
+        path = _path2str(path)
         if backend == VisualLib.PYTORCH:
             if not VisualLib.pytorch_available():
                 raise ValueError("Torchvision is not installed.")
@@ -202,11 +207,13 @@ class VideoReader:
 
     @classmethod
     @dispatch
-    def with_range(cls, path: str, end: int, channel_first: bool = True,
+    def with_range(cls, path: Union[str, Path], end: int, channel_first: bool = True,
         backend: Optional[VisualLib] = None
     ) -> VideoData:
+        path = _path2str(path)
         return cls.with_range(path, 0, end, 1, channel_first, backend)
 
-    def __new__(cls, path: str, channel_first: bool = False, backend: Optional[VisualLib] = None) -> VideoData:
+    def __new__(cls, path: Union[str, Path], channel_first: bool = False, backend: Optional[VisualLib] = None) -> VideoData:
         """Alias of :meth:`~.VideoReader.of`"""
+        path = _path2str(path)
         return cls.of(path, channel_first, backend)

tensorneko_util/io/video/video_writer.py

@@ -1,13 +1,15 @@
 import pathlib
 import warnings
 from subprocess import Popen
-from typing import Optional, Union
+from typing import Union
+from pathlib import Path
 
 import numpy as np
 from einops import rearrange
 
 from .video_data import VideoData
 from .._default_backends import _default_video_io_backend
+from .._path_conversion import _path2str
 from ...backend.visual_lib import VisualLib
 from ...util import dispatch
 from ...util.type import T_ARRAY
@@ -18,14 +20,14 @@ class VideoWriter:
 
     @classmethod
     @dispatch
-    def to(cls, path: str, video: VideoData, audio_codec: str = None, channel_first: bool = False,
+    def to(cls, path: Union[str, Path], video: VideoData, audio_codec: str = None, channel_first: bool = False,
         backend: VisualLib = None
     ) -> None:
         """
         Write to video file from :class:`~tensorneko.io.video.video_data.VideoData`.
 
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             video (:class:`~tensorneko.io.video.video_data.VideoData`): The VideoData object for output.
             audio_codec (``str``, optional): The audio codec if audio is required. Default: None.
             channel_first (``bool``, optional): Get image dimension (T, H, W, C) if False or (T, C, H, W) if True.
@@ -33,11 +35,12 @@ class VideoWriter:
             backend (:class:`~tensorneko.backend.visual_lib.VisualLib`, optional): VisualLib backend.
                 Default: opencv if installed, then torchvision if installed, then ffmpeg if available.
         """
+        path = _path2str(path)
         cls.to(path, video.video, video.info.video_fps, video.audio, video.info.audio_fps, audio_codec, channel_first, backend)
 
     @classmethod
     @dispatch
-    def to(cls, path: str, video: T_ARRAY, video_fps: float, audio: T_ARRAY = None,
+    def to(cls, path: Union[str, Path], video: T_ARRAY, video_fps: float, audio: T_ARRAY = None,
         audio_fps: int = None, audio_codec: str = None, channel_first: bool = False,
         backend: VisualLib = None
     ) -> None:
@@ -45,7 +48,7 @@ class VideoWriter:
         Write to video file from :class:`~torch.Tensor` or :class:`~numpy.ndarray` with (T, C, H, W).
         TODO: Buggy when the argument is too much.
         Args:
-            path (``str``): The path of output file.
+            path (``str`` | ``pathlib.Path``): The path of output file.
             video (:class:`~torch.Tensor` | :class:`~numpy.ndarray`): The video tensor or array with (T, C, H, W) for
                 output.
             video_fps (``float``): The video fps.
@@ -62,6 +65,7 @@ class VideoWriter:
             if audio_codec is None:
                 raise ValueError("audio_codec is required if audio is required.")
         backend = backend or _default_video_io_backend()
+        path = _path2str(path)
         if channel_first:
             video = rearrange(video, "t c h w -> t h w c")
 
@@ -130,6 +134,7 @@ class VideoWriter:
         else:
             raise ValueError("Unknown backend. Should be one of VisualLib.OPENCV, VisualLib.PYTORCH, VisualLib.FFMPEG.")
 
-    def __new__(cls, path: str, video: Union[T_ARRAY, VideoData], *args, **kwargs):
+    def __new__(cls, path: Union[str, Path], video: Union[T_ARRAY, VideoData], *args, **kwargs):
         """Alias of :func:`~tensorneko.io.video.video_io.to`."""
+        path = _path2str(path)
         return cls.to(path, video, *args, **kwargs)

tensorneko_util/io/writer.py

@@ -1,5 +1,7 @@
-from typing import Type
+from typing import Type, Union
+from pathlib import Path
 
+from ._path_conversion import _path2str
 from .audio import AudioWriter
 from .image import ImageWriter
 from .json import JsonWriter
@@ -88,8 +90,10 @@ class Writer:
         else:
             raise ImportError("To use the toml writer, please install toml.")
 
-    def __call__(self, path: str, obj, *args, **kwargs):
+    def __call__(self, path: Union[str, Path], obj, *args, **kwargs):
         """Automatically infer the file type and return the corresponding result. """
+        path = _path2str(path)
+
         if path.endswith(".jpg") or path.endswith(".jpeg") or path.endswith(".png") or path.endswith(".bmp"):
             self.image(path, obj, *args, **kwargs)
         elif path.endswith(".txt"):

tensorneko_util/io/yaml/yaml_reader.py

@@ -1,27 +1,31 @@
 from typing import Type, Dict, Any, Union
-
+from pathlib import Path
 import yaml
 from yaml import Loader as Loader_, BaseLoader, FullLoader, SafeLoader, UnsafeLoader
 
+from .._path_conversion import _path2str
+
 L = Type[Union[Loader_, BaseLoader, FullLoader, SafeLoader, UnsafeLoader]]
 
 
 class YamlReader:
 
     @classmethod
-    def of(cls, path: str, Loader: L = Loader_) -> Dict[str, Any]:
+    def of(cls, path: Union[str, Path], Loader: L = Loader_) -> Dict[str, Any]:
         """
         Load a YAML file and return a Python dict.
         Args:
-            path (``str``): YAML file path.
+            path (``str`` | ``pathlib.Path``): YAML file path.
             Loader: (``Loader_ | BaseLoader | FullLoader | SafeLoader | UnsafeLoader``, optional): The loader for yaml. Default: :class:`yaml.Loader`
 
         Returns:
             ``dict``: The Python dict of given YAML file.
         """
+        path = _path2str(path)
         with open(path, "r") as file:
             return yaml.load(file, Loader=Loader)
 
-    def __new__(cls, path: str, Loader: L = Loader_):
+    def __new__(cls, path: Union[str, Path], Loader: L = Loader_):
         """Alias of :meth:`~tensorneko_util.io.yaml.yaml_reader.YamlReader.of`."""
+        path = _path2str(path)
         return cls.of(path, Loader)

tensorneko_util/io/yaml/yaml_writer.py

@@ -1,23 +1,26 @@
-from typing import Any
-
+from typing import Any, Union
+from pathlib import Path
 import yaml
 
+from .._path_conversion import _path2str
+
 
 class YamlWriter:
 
     @classmethod
-    def to(cls, path: str, obj: Any) -> None:
+    def to(cls, path: Union[str, Path], obj: Any) -> None:
         """
         Write a Python object to a YAML file.
 
         Args:
-            path (``str``): YAML file path.
+            path (``str`` | ``pathlib.Path``): YAML file path.
             obj (``Any``): The Python object to write.
         """
+        path = _path2str(path)
         with open(path, "w") as f:
             yaml.dump(obj, f)
 
-    def __new__(cls, path: str, obj: Any) -> None:
+    def __new__(cls, path: Union[str, Path], obj: Any) -> None:
         """Alias of :meth:`~tensorneko_util.io.yaml.yaml_writer.YamlWriter.to`."""
+        path = _path2str(path)
         cls.to(path, obj)
-        return None

tensorneko_util/msg/gotify.py

@@ -16,7 +16,7 @@ def push_gotify(message: str, url: Optional[str] = None, token: Optional[str] =
         message (``str``): The message to be sent.
         url (``str``, optional): The URL of the Gotify server. If not provided, it will be read from the environment variable GOTIFY_URL.
         token (``str``, optional): The token for the Gotify server. If not provided, it will be read from the environment variable GOTIFY_TOKEN.
-        title (``str``, optional): The title of the message. Default is the hostname of the machine.
+        title (``str``, optional): The title of the message. Default is GOTIFY_TITLE then the hostname of the machine.
         priority (``int``, optional): The priority of the message. Default is 0.
 
     Examples::
@@ -26,7 +26,7 @@ def push_gotify(message: str, url: Optional[str] = None, token: Optional[str] =
         # title = "<HOST_NAME>", message = "This is a test message", priority = 0
 
     """
-    title = title or socket.gethostname()
+    title = title or os.environ.get("GOTIFY_TITLE") or socket.gethostname()
     url = url or os.environ.get("GOTIFY_URL")
     if url is None:
         raise ValueError("URL is not provided. Input url argument or set the environment variable GOTIFY_URL.")

tensorneko_util/notebook/__init__.py

@@ -2,7 +2,8 @@ __all__ = []
 
 try:
     from . import display
-    __all__.append("display")
+    from . import animation
+    __all__.extend(["display", "animation"])
     ipython_available = True
 except ImportError:
     ipython_available = False

tensorneko_util/notebook/animation.py

@@ -0,0 +1,20 @@
+from typing import Sequence, Union
+
+import numpy as np
+from matplotlib import pyplot as plt
+from matplotlib.animation import FuncAnimation
+from IPython.display import HTML
+
+
+def to_animation_html(frames: Union[Sequence[np.ndarray], np.ndarray], interval: int = 100) -> str:
+    fig, ax = plt.subplots()
+    im = ax.imshow(frames[0])
+    def update_frame(i):
+        im.set_array(frames[i])
+        return [im]
+
+    return FuncAnimation(fig, update_frame, frames=len(frames), interval=interval).to_jshtml()
+
+
+def show_animation(frames: Union[Sequence[np.ndarray], np.ndarray], interval: int = 100):
+    return HTML(to_animation_html(frames, interval))

tensorneko_util/notebook/display.py

@@ -1,5 +1,5 @@
 import IPython
-from IPython.display import Audio, Video, YouTubeVideo, Code, Image
+from IPython.display import Audio, Video, YouTubeVideo, Code, Image, HTML
 import sys
 
 
@@ -33,6 +33,10 @@ def code(path: str, language: str = None):
     IPython.display.Code._repr_html_ = _jupyterlab_repr_html_
     return IPython.display.display(Code(path, language=language))
 
+def html(source: str):
+    # render HTML in Jupyter
+    return IPython.display.HTML(source)
+
 
 class Display:
     audio = staticmethod(audio)
@@ -40,6 +44,7 @@ class Display:
     image = staticmethod(image)
     youtube_video = staticmethod(youtube_video)
     code = staticmethod(code)
+    html = staticmethod(html)
 
     def __call__(self, path: str, *args, **kwargs):
         ext = path.split(".")[-1]

tensorneko_util/util/__init__.py

@@ -12,6 +12,7 @@ from .eventbus import Event, EventBus, EventHandler, subscribe
 from .singleton import Singleton
 from .downloader import download_file, download_file_thread, download_files_thread
 from .window_merger import WindowMerger
+from .multi_layer_indexer import MultiLayerIndexer
 
 tensorneko_util_path = get_tensorneko_util_path()
 
@@ -56,5 +57,6 @@ __all__ = [
     "download_file_thread",
     "download_files_thread",
     "WindowMerger",
-    "Registry"
+    "Registry",
+    "MultiLayerIndexer"
 ]