Implement CLI logging and fix the cannot identify image file issue (GH-58)

Author: ArtyomVancyan

.github/workflows/tests.yml

@@ -1,7 +1,10 @@
 name: Tests Ubuntu | MacOS
 
 on:
-  - pull_request
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
 
 jobs:
   test:

README.md

@@ -68,7 +68,7 @@ Run the following command in the package's root directory to install it in edita
 python3 -m pip install -e .
 ```
 This command will install the package in your local environment and allow you to make changes to the code and see the
-updates immediately. It will also install all the required dependencies listed in the [requirements.txt](requirements.txt) file.
+updates immediately. It will also install all the required dependencies.
 
 ## Contribute
 
@@ -85,6 +85,14 @@ install [tox](https://github.com/tox-dev/tox) and run the tests for configured e
 python3 -m pip install tox && tox
 ```
 
+If you want to run tests only for the current environment with your local Python interpreter, you can use the following
+commands.
+
+```bash
+python3 -m pip install -r tests/requirements.txt
+python3 -m pytest
+```
+
 ## License
 
-Copyright (C) 2023 Artyom Vancyan. [Apache 2.0](LICENSE)
+Copyright (C) 2023 Artyom Vancyan. [Apache 2.0](https://github.com/pysnippet/thumbnails/blob/master/LICENSE)

requirements.txt

@@ -35,6 +35,7 @@ install_requires =
     imageio-ffmpeg>=0.4.7
     imageio>=2.23.0
     pillow>=8.4.0
+    rich>=13.0.0
 python_requires = >=3.7
 package_dir =
     =src

setup.cfg

@@ -22,7 +22,7 @@
 from .thumbnail import ThumbnailVTT
 from .thumbnail import register_thumbnail
 
-__version__ = "0.1.5"
+__version__ = "0.1.6"
 __all__ = (
     "Generator",
     "Thumbnail",

src/thumbnails/__init__.py

@@ -12,8 +12,7 @@ class _FFMpeg:
     """This class is used to parse the metadata of a video file."""
 
     def __init__(self, filepath):
-        duration, self.size = self._parse_metadata(filepath)
-        self.duration = int(duration + 1)
+        self.duration, self.size = self._parse_metadata(filepath)
 
     @staticmethod
     def _parse_duration(stdout):

src/thumbnails/ffmpeg.py

@@ -12,6 +12,7 @@
 from .constants import DEFAULT_SKIP
 from .pathtools import listdir
 from .pathtools import metadata_path
+from .progress import use_progress
 from .thumbnail import ThumbnailExistsError
 from .thumbnail import ThumbnailFactory
 from .video import Video
@@ -45,6 +46,7 @@ def worker(video, fmt, base, skip, output):
         thumbnail.prepare_frames()
         thumbnail.generate()
 
+    @use_progress
     def generate(self):
         self.inputs = [file for file in self.inputs if re.match(r"^.*\.(?:(?!png|vtt|json).)+$", file)]
         self.inputs = dict(zip(map(lambda i: metadata_path(i, self.output, self.format), self.inputs), self.inputs))
@@ -59,7 +61,7 @@ def generate(self):
                 self.inputs.values(),
             )
 
-        with concurrent.futures.ProcessPoolExecutor() as executor:
+        with concurrent.futures.ThreadPoolExecutor() as executor:
             executor.map(
                 functools.partial(
                     self.worker,

src/thumbnails/generator.py

@@ -0,0 +1,52 @@
+import functools
+
+from rich.progress import Progress as RichProgress
+from rich.progress import SpinnerColumn
+from rich.progress import TextColumn
+
+
+class Progress:
+    _running = False
+    _instance = RichProgress(SpinnerColumn(finished_text="*"),
+                             TextColumn("[white]{task.description}{task.fields[status]}"))
+
+    def __init__(self, description):
+        if self._running:
+            self.task = self._instance.add_task(description, status=" ... [yellow]processing")
+        self.description = description
+
+    def update(self, description, status=" ... [yellow]processing"):
+        if self._running:
+            self._instance.update(self.task, description=description, status=status, refresh=True)
+
+    @classmethod
+    def start(cls):
+        cls._running = True
+        cls._instance.start()
+
+    @classmethod
+    def stop(cls):
+        cls._running = False
+        cls._instance.stop()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, _):
+        # Set finished time to 0 to hide the spinner
+        self._instance.tasks[self.task].finished_time = 0
+        if exc_type is not None:
+            return self.update(exc_val, status=" ... [red]failure")
+        self.update(self.description, status=" ... [green]success")
+
+
+def use_progress(func):
+    """Decorator for using the progress bar."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        Progress.start()
+        func(*args, **kwargs)
+        Progress.stop()
+
+    return wrapper

src/thumbnails/progress.py

@@ -12,6 +12,7 @@
 from .pathtools import ensure_tree
 from .pathtools import extract_name
 from .pathtools import metadata_path
+from .progress import Progress
 
 
 def register_thumbnail(typename):
@@ -45,7 +46,9 @@ def __init__(self, video, base, skip, output):
         self.thumbnail_dir = self.calc_thumbnail_dir()
         self.metadata_path = self._get_metadata_path()
         self._perform_skip()
-        self.extract_frames()
+
+        with Progress("Extracting the frames by the given interval"):
+            self.extract_frames()
 
     def _get_metadata_path(self):
         """Initiates the name of the thumbnail metadata file."""
@@ -100,12 +103,16 @@ def prepare_frames(self):
         master = Image.new(mode="RGBA", size=next(thumbnails))
         master_path = os.path.join(self.thumbnail_dir, extract_name(self.filepath) + ".png")
 
-        for frame, *_, x, y in thumbnails:
-            with Image.open(frame) as image:
-                image = image.resize((self.width, self.height), Image.ANTIALIAS)
-                master.paste(image, (x, y))
+        with Progress("Preprocessing the frames before merging") as progress:
+            for frame, *_, x, y in thumbnails:
+                offset = extract_name(frame).replace("-", ":").split(".")[0]
+                progress.update("Processing [bold]%s[/bold] frame" % offset)
+                with Image.open(frame) as image:
+                    image = image.resize((self.width, self.height), Image.ANTIALIAS)
+                    master.paste(image, (x, y))
 
-        master.save(master_path)
+        with Progress("Saving the result at '%s'" % master_path):
+            master.save(master_path)
 
     def generate(self):
         def format_time(secs):
@@ -117,12 +124,14 @@ def format_time(secs):
         route = os.path.join(prefix, extract_name(self.filepath) + ".png")
         route = pathlib.Path(route).as_posix()
 
-        for _, start, end, x, y in self.thumbnails():
-            thumbnail_data = "%s --> %s\n%s#xywh=%d,%d,%d,%d\n\n" % (
-                format_time(start), format_time(end),
-                route, x, y, self.width, self.height,
-            )
-            metadata.append(thumbnail_data)
+        with Progress("Saving thumbnail metadata at '%s'" % self.metadata_path) as progress:
+            for _, start, end, x, y in self.thumbnails():
+                progress.update("Generating metadata for '%s'" % route)
+                thumbnail_data = "%s --> %s\n%s#xywh=%d,%d,%d,%d\n\n" % (
+                    format_time(start), format_time(end),
+                    route, x, y, self.width, self.height,
+                )
+                metadata.append(thumbnail_data)
 
         with open(self.metadata_path, "w") as fp:
             fp.writelines(metadata)

src/thumbnails/thumbnail.py

@@ -10,6 +10,7 @@
 
 from .ffmpeg import _FFMpeg
 from .frame import _Frame
+from .progress import Progress
 
 ffmpeg_bin = get_ffmpeg_exe()
 
@@ -19,7 +20,7 @@ def arange(start, stop, step):
 
     def _generator():
         nonlocal start
-        while start < stop:
+        while start <= stop:
             yield start
             start += step
 
@@ -41,8 +42,9 @@ def __init__(self, filepath, compress, interval):
         self.__frames_count = None
         self.__columns = None
 
-        _FFMpeg.__init__(self, filepath)
-        _Frame.__init__(self, self.size)
+        with Progress("Parsing metadata from the video"):
+            _FFMpeg.__init__(self, filepath)
+            _Frame.__init__(self, self.size)
 
     @property
     def filepath(self):
@@ -77,6 +79,7 @@ def calc_columns(self):
         for col in range(1, self.frames_count):
             if (col * width) / (self.frames_count // col * height) > ratio:
                 return col
+        return 1  # fixes the case when the video is too short
 
     def _extract_frame(self, start_time):
         """Extracts a single frame from the video by the offset."""