ascii-art-python 2.0.2__tar.gz → 2.1.1__tar.gz

{ascii_art_python-2.0.2/src/ascii_art_python.egg-info → ascii_art_python-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ascii_art_python
-Version: 2.0.2
+Version: 2.1.1
 Summary: A Python library and CLI tool for converting images and videos into ASCII art.
 Author-email: Guillem Prieur <prieurguillem38@gmail.com>
 Project-URL: Homepage, https://gitlab.pprriieeuurr.fr/guill_prieur/ascii-art-python-2

{ascii_art_python-2.0.2 → ascii_art_python-2.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ascii_art_python"
-version = "2.0.2"
+version = "2.1.1"
 authors = [
     { name="Guillem Prieur", email="prieurguillem38@gmail.com" },
 ]
@@ -12,6 +12,7 @@ description = "A Python library and CLI tool for converting images and videos in
 readme = "README.md"
 requires-python = ">=3.9"
 
+
 keywords = [
     "ascii", 
     "ascii-art", 

{ascii_art_python-2.0.2 → ascii_art_python-2.1.1}/src/ascii_art_python/__init__.py

@@ -1,7 +1,7 @@
 """
 Module from https://gitlab.pprriieeuurr.fr/guill_prieur/ascii-art-python-2
 """
-__version__ = "2.0.2"
+__version__ = "2.1.1"
 from . import new_skool
 from . import old_skool
 from . import full_mode

{ascii_art_python-2.0.2 → ascii_art_python-2.1.1}/src/ascii_art_python/ascii_base.py

@@ -10,7 +10,7 @@ import pathlib
 import sys
 import time
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Union
+from typing import Any, Callable, List, Optional
 
 import cv2
 import numpy as np
@@ -51,8 +51,8 @@ class Image(ABC):
     def __init__(
         self,
         image: PIL.Image.Image,
-        height: Union[int, None] = None,
-        width: Union[int, None] = None,
+        height: Optional[int] = None,
+        width: Optional[int] = None,
     ) -> None:
         """
         Initializes the base Image instance.
@@ -61,10 +61,10 @@ class Image(ABC):
         -----------
         image : PIL.Image.Image
             The source image to be processed.
-        height : Union[int, None]
+        height : Optional[int]
             The target height for the output image. If None, it scales proportionally
             or maintains the original height depending on the width parameter.
-        width : Union[int, None]
+        width : Optional[int]
             The target width for the output image. If None, it scales proportionally
             or maintains the original width depending on the height parameter.
         """
@@ -113,7 +113,7 @@ class Image(ABC):
             raise ValueError("height must be a positive integer")
         self._height = value
 
-    def get_backgrounds(self, bg_chars: Union[list[str], None] = None, better: bool = True) -> list[str]:
+    def get_backgrounds(self, bg_chars: Optional[List[str]] = None, better_contrast: bool = True) -> List[str]:
         """
         Calculates the background ASCII characters based on image luminosity.
 
@@ -122,13 +122,15 @@ class Image(ABC):
 
         Parameters
         -----------
-        bg_chars : Union[list[str], None]
+        bg_chars : Optional[List[str]]
             A list of single characters ordered by visual density. 
             If None, the default background characters are used.
+        better_contrast : bool
+            If True, the program will increase the contrast to improve the result.
 
         Returns
         --------
-        list[str]
+        List[str]
             A list of strings, where each string represents a row of 
             the background ASCII image.
         """
@@ -140,19 +142,22 @@ class Image(ABC):
             raise ValueError("bg_chars must be a list of strings")
         if not all(len(char) == 1 for char in bg_chars):
             raise ValueError("bg_chars must be a list of strings of length 1")
-        if not isinstance(better, bool):
-            raise TypeError("better must be a bool")
+        if not isinstance(better_contrast, bool):
+            raise TypeError("better_contrast must be a bool")
 
         image = self.__source.convert("L").resize((self.width, self.height))
-        if better:
+        if better_contrast:
             image = PIL.ImageOps.autocontrast(image, 1)
 
         conversion_factor = len(bg_chars) / 256
         img_array = np.array(image)
         indices = (img_array * conversion_factor).astype(int)
-        return ["".join(np.array(bg_chars)[row]) for row in indices]
+        np_bg_chars = np.array(bg_chars)
+        return ["".join(np_bg_chars[row]) for row in indices]
 
-    def get_edges(self, edge_chars: Union[list[str], None] = None) -> list[str]:
+    def get_edges(
+        self, edge_chars: Optional[List[str]] = None, color_edges: bool = False
+    ) -> List[str]:
         """
         Detects image edges and maps them to directional ASCII characters.
 
@@ -161,20 +166,24 @@ class Image(ABC):
 
         Parameters
         -----------
-        edge_chars : Union[list[str], None]
+        edge_chars : Optional[List[str]]
             A list of exactly 4 single characters representing vertical, 
             diagonal-up, horizontal, and diagonal-down edges respectively. 
             If None, default edge characters are used.
+        color_edges : bool
+            If True, performs edge detection on LAB color channels to catch 
+            isoluminant edges (better quality but slower). If False, uses 
+            grayscale edge detection (faster, recommended for videos).
 
         Returns
         --------
-        list[str]
+        List[str]
             A list of strings, where each string represents a row of 
             the foreground ASCII edges.
         """
         if edge_chars is None:
             edge_chars = self.DEFAULT_EDGE_CHARS
-        if not (isinstance(edge_chars, list)):
+        if not isinstance(edge_chars, list):
             raise TypeError("edge_chars must be a list")
         if len(edge_chars) != 4:
             raise ValueError("edge_chars must be a list of 4 characters")
@@ -182,33 +191,48 @@ class Image(ABC):
             raise ValueError("edge_chars must be a list of strings")
         if not all(len(char) == 1 for char in edge_chars):
             raise ValueError("edge_chars must be a list of strings of length 1")
+        if not isinstance(color_edges, bool):
+            raise TypeError("color_edges must be a bool")
 
         img_pil = self.__source.convert("RGB").resize((self.width, self.height))
         img_rgb = np.array(img_pil)
-        img_lab = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2LAB)
-        l_chan, a_chan, b_chan = cv2.split(img_lab)
-        edges_l = cv2.Canny(l_chan, 50, 150)
-        edges_a = cv2.Canny(a_chan, 20, 80)
-        edges_b = cv2.Canny(b_chan, 20, 80)
-        edge_mask = (edges_l | edges_a | edges_b) == 255
-        sobel_x = cv2.Sobel(l_chan, cv2.CV_64F, 1, 0)
-        sobel_y = cv2.Sobel(l_chan, cv2.CV_64F, 0, 1)
+
+        if color_edges:
+            img_lab = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2LAB)
+            l_chan, a_chan, b_chan = cv2.split(img_lab)
+            edges_l = cv2.Canny(l_chan, 50, 150)
+            edges_a = cv2.Canny(a_chan, 20, 80)
+            edges_b = cv2.Canny(b_chan, 20, 80)
+            edge_mask = (edges_l | edges_a | edges_b) == 255
+            sobel_target = l_chan
+        else:
+            img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
+            edges_gray = cv2.Canny(img_gray, 50, 150)
+            edge_mask = edges_gray == 255
+            sobel_target = img_gray
+
+        sobel_x = cv2.Sobel(sobel_target, cv2.CV_64F, 1, 0)
+        sobel_y = cv2.Sobel(sobel_target, cv2.CV_64F, 0, 1)
         angles = np.degrees(np.arctan2(sobel_y, sobel_x)) % 180
+
         char_matrix = np.full((self.height, self.width), " ", dtype=object)
         char_matrix[edge_mask & ((angles >= 67.5) & (angles < 112.5))] = edge_chars[2]
         char_matrix[edge_mask & ((angles >= 22.5) & (angles < 67.5))] = edge_chars[1]
         char_matrix[edge_mask & ((angles >= 112.5) & (angles < 157.5))] = edge_chars[3]
         char_matrix[edge_mask & ((angles < 22.5) | (angles >= 157.5))] = edge_chars[0]
+
         return ["".join(row) for row in char_matrix]
 
     @abstractmethod
-    def to_list(self) -> list[str]:
+    def to_list(self, **kwargs: Any) -> List[str]:
         """
-        Abstract method to convert the image to a list of ASCII strings.
+        An abstract method for converting the image into a list of ASCII strings.
+
+        Accepts additional parameters via kwargs depending on the mode.
 
         Returns
         --------
-        list[str]
+        List[str]
             A list of ASCII strings representing the fully processed image.
         """
 
@@ -260,7 +284,7 @@ class Image(ABC):
 
     @classmethod
     def from_path(
-        cls, path: str, height: Union[int, None] = None, width: Union[int, None] = None
+        cls, path: str, height: Optional[int] = None, width: Optional[int] = None
     ) -> "Image":
         """
         Instantiates an Image object from a file path.
@@ -269,9 +293,9 @@ class Image(ABC):
         -----------
         path : str
             The system path to the image file.
-        height : Union[int, None]
+        height : Optional[int]
             The desired output height.
-        width : Union[int, None]
+        width : Optional[int]
             The desired output width.
 
         Returns
@@ -330,7 +354,7 @@ class Image(ABC):
 
         return cls(output_image, width=text_width, height=len(content_list) * font_size)
 
-    def export(self, filename: str = "mika_export"):
+    def export(self, filename: str = "mika_export", font_size: int = 15):
         """
         Exports the rendered ASCII image to a PNG file.
 
@@ -344,7 +368,7 @@ class Image(ABC):
             raise TypeError("filename must be a string")
         if pathlib.Path.is_file(pathlib.Path(filename + ".png")):
             raise ValueError("file must not exist")
-        self.to_image().save(f"{filename}.png")
+        self.to_image(font_size = font_size).save(f"{filename}.png")
 
 
 class Video:
@@ -385,30 +409,26 @@ class Video:
         if pathlib.Path.is_file(pathlib.Path(output_path)):
             raise ValueError("output_path must not exist")
 
-        source_video = VideoFileClip(source_video_path)
-        audio = source_video.audio
-        target_video = VideoFileClip(target_video_path)
-
-        final_video = target_video.with_audio(audio)
+        with VideoFileClip(source_video_path) as source_video, VideoFileClip(target_video_path) as target_video:
+            audio = source_video.audio
+            final_video = target_video.with_audio(audio)
 
-        final_video.write_videofile(
-            output_path,
-            codec="libx264",
-            audio_codec="aac",
-            fps=target_video.fps,
-            logger=None,
-        )
+            final_video.write_videofile(
+                output_path,
+                codec="libx264",
+                audio_codec="aac",
+                fps=target_video.fps,
+                logger=None,
+            )
 
-        source_video.close()
-        target_video.close()
-        final_video.close()
+            final_video.close()
 
     def __init__(
         self,
         path: str,
         cls_image: type["Image"],
-        width: Union[int, None] = None,
-        height: Union[int, None] = None,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
         fps: int = 10,
     ) -> None:
         """
@@ -421,9 +441,9 @@ class Video:
         cls_image : type[Image]
             The specific Image class (e.g., full_mode.Image) used to process 
             each frame of the video.
-        width : Union[int, None]
+        width : Optional[int]
             The target width for the output frames.
-        height : Union[int, None]
+        height : Optional[int]
             The target height for the output frames.
         fps : int
             The maximum frames per second for processing and exporting.
@@ -451,44 +471,30 @@ class Video:
             raise ValueError("Error: Unable to read video frames to determine size.")
 
         image_test = self.cls_image(
-            PIL.Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+            PIL.Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)),
+            width = width,
+            height = height
         )
-        self._cached_original_size = (image_test.width * 15, image_test.height * 15)
+        self.width = image_test.width
+        self.height = image_test.height
 
-        original_size = self._cached_original_size
-        if height is None and width is None:
-            self.width, self.height = original_size
-        elif height is not None and width is None:
-            self.height = height
-            self.width = int(self.height * original_size[0] / original_size[1])
-        elif height is None and width is not None:
-            self.width = width
-            self.height = int(self.width * original_size[1] / original_size[0])
-        elif height is not None and width is not None:
-            self.height = height
-            self.width = width
-
-        self.__cap = None
+        self._cap = None
         self.__frame_skip = max(1, int(self._cached_fps / self.max_fps))
         self.__frame_count = 0
 
     def __enter__(self):
-        if self.__cap is not None:
-            self.__cap.release()
-        self.__cap = cv2.VideoCapture(self.path)
-        if not self.__cap.isOpened():
+        if self._cap is not None:
+            self._cap.release()
+        self._cap = cv2.VideoCapture(self.path)
+        if not self._cap.isOpened():
             raise ValueError(f"Error: Unable to open the video at '{self.path}'")
         self.__frame_count = 0
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if self.__cap is not None:
-            self.__cap.release()
-            self.__cap = None
-
-    @property
-    def original_size(self) -> tuple[int, int]:
-        return self._cached_original_size
+        if self._cap is not None:
+            self._cap.release()
+            self._cap = None
 
     @property
     def fps(self) -> float:
@@ -522,26 +528,26 @@ class Video:
         self._height = value
 
     def __iter__(self) -> "Video":
-        if self.__cap is None or not self.__cap.isOpened():
-            self.__cap = cv2.VideoCapture(self.path)
+        if self._cap is None or not self._cap.isOpened():
+            self._cap = cv2.VideoCapture(self.path)
         self.__frame_count = 0
         return self
 
     def __next__(self) -> Any:
-        if self.__cap is None:
+        if self._cap is None:
             raise StopIteration
 
         while True:
-            success, frame = self.__cap.read()
+            success, frame = self._cap.read()
 
             if not success:
-                self.__cap.release()
-                self.__cap = None
+                self._cap.release()
+                self._cap = None
                 raise StopIteration
 
             if self.__frame_count % self.__frame_skip == 0:
                 result_frame = self.cls_image(
-                    PIL.Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)),
+                    PIL.Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)),
                     width=self.width,
                     height=self.height,
                 )
@@ -551,10 +557,10 @@ class Video:
             self.__frame_count += 1
 
     def __del__(self) -> None:
-        if hasattr(self, "_Video__cap") and self.__cap is not None:
-            self.__cap.release()
+        if hasattr(self, "_cap") and self._cap is not None:
+            self._cap.release()
 
-    def export(self, filename: str = "mika_export", sound: bool = False):
+    def export(self, filename: str = "mika_export", sound: bool = False, font_size: int = 12) -> None:
         """
         Exports the processed ASCII video to an mp4 file.
 
@@ -575,36 +581,38 @@ class Video:
             raise TypeError("sound must be a bool")
         if pathlib.Path.is_file(pathlib.Path(filename + ".mp4")):
             raise ValueError("filename must not exist")
+        if not isinstance(font_size, int):
+            raise TypeError("font_size must be an int")
+        if font_size <= 0:
+            raise ValueError("font_size must be a positive integer")
+
+        out_width = self.width * font_size
+        out_height = self.height * font_size
 
-        out_width = self.width * 15
-        out_height = self.height * 15
-        
         if out_width % 2 != 0:
             out_width += 1
         if out_height % 2 != 0:
             out_height += 1
-
         fourcc = cv2.VideoWriter_fourcc(*"mp4v")
         out = cv2.VideoWriter(
             filename + ".mp4",
             fourcc,
             self.fps / max(1, int(self.fps / self.max_fps)),
             (out_width, out_height),
-            True,
+            False,
         )
 
         with self:
             for frame in tqdm(self, "Exporting frames", len(self)):
-                pil_img = frame.to_image(font_size=15)
-                
+                pil_img = frame.to_image(font_size = font_size)
+
                 if pil_img.size != (out_width, out_height):
                     pil_img = pil_img.resize((out_width, out_height))
-                
+
                 tab = np.array(pil_img)
-                tab_bgr = cv2.cvtColor(tab, cv2.COLOR_GRAY2BGR)
-                
-                out.write(tab_bgr)
-                
+
+                out.write(tab)
+
         out.release()
 
         if sound:
@@ -627,11 +635,20 @@ class Video:
         if not callable(func_print):
             raise TypeError("func_print must be a callable")
 
-        time_between = 1 / min(self.fps, self.max_fps)
-        next_sleep = time.time() + time_between
+        actual_frame_skip = max(1, int(self.fps / self.max_fps))
+        effective_fps = self.fps / actual_frame_skip
+
+        frame_duration = 1.0 / effective_fps
 
         with self:
-            for frame in self:
-                time.sleep(max(next_sleep - time.time(), 0))
+            start_time = time.perf_counter()
+
+            for i, frame in enumerate(self):
+                expected_time = start_time + (i * frame_duration)
+
+                sleep_time = expected_time - time.perf_counter()
+
+                if sleep_time > 0:
+                    time.sleep(sleep_time)
+
                 func_print(frame.get_alternate_lines())
-                next_sleep += time_between

ascii_art_python-2.1.1/src/ascii_art_python/cli.py

@@ -0,0 +1,182 @@
+"""
+Command-line interface module for ASCII generation.
+
+Provides click-based commands to export or print ASCII art
+from image and video files.
+"""
+
+import mimetypes
+import shutil
+from typing import Any, Optional, Tuple
+
+import click
+
+from . import full_mode, new_skool, old_skool
+from .tools import clean_print
+
+MODES = {
+    "full_mode": full_mode,
+    "old_skool": old_skool,
+    "new_skool": new_skool,
+}
+
+
+def _get_media_type_and_module(source_path: str, mode: str) -> Tuple[str, Any]:
+    """
+    Determines the media type of the source file and retrieves the corresponding module.
+
+    Parameters
+    -----------
+    source_path : str
+        The file path to the input media.
+    mode : str
+        The desired ASCII generation mode.
+
+    Returns
+    --------
+    Tuple[str, Any]
+        A tuple containing the media type ('image' or 'video') and the associated module.
+
+    Raises
+    -------
+    click.ClickException
+        If the media type cannot be determined or the mode is invalid.
+    """
+    media_type, _ = mimetypes.guess_type(source_path)
+
+    if media_type is None:
+        raise click.ClickException("Error: Unable to determine the file type (image or video).")
+
+    if media_type.startswith("image"):
+        base_type = "image"
+    elif media_type.startswith("video"):
+        base_type = "video"
+    else:
+        raise click.ClickException(f"Error: Unsupported media type '{media_type}'.")
+
+    if mode not in MODES:
+        raise click.ClickException(f"Error: Mode '{mode}' is not recognized.")
+
+    return base_type, MODES[mode]
+
+
+@click.command()
+@click.argument("source_path", type=click.Path(exists=True))
+@click.argument("target_filename", type=click.STRING)
+@click.option(
+    "--width",
+    "-w",
+    type=int,
+    default=None,
+    help="The number of characters in the width of the output."
+)
+@click.option(
+    "--height",
+    "-h",
+    type=int,
+    default=None,
+    help="The number of characters in the height of the output."
+)
+@click.option(
+    "--mode",
+    "-m",
+    type=click.Choice(list(MODES.keys())),
+    default="full_mode",
+    help="The ASCII generation mode to use."
+)
+@click.option(
+    "--fontsize",
+    "-f",
+    type=int,
+    default=12,
+    help="The size of each character in the exported video."
+)
+@click.option(
+    "--sound/--no-sound", 
+    type=bool,
+    default=True,
+    help="If the file is a video, export it with or without audio."
+)
+def create_and_export(
+    source_path: str,
+    target_filename: str,
+    width: Optional[int],
+    height: Optional[int],
+    mode: str,
+    fontsize: int,
+    sound: bool,
+) -> None:
+    """
+    Creates and exports an ASCII art image or video.
+
+    Processes the input file located at SOURCE_PATH and exports the result
+    to TARGET_FILENAME with the specified settings.
+    """
+    click.echo(f"▶ Converting '{source_path}'...")
+    click.echo(f"▶ Settings: length=({width}, {height}), mode={mode}")
+
+    media_type, module = _get_media_type_and_module(source_path, mode)
+    click.echo(f"▶ Export type: {media_type}")
+
+    if media_type == "image":
+        image = module.Image.from_path(source_path, height=height, width=width)
+        image.export(target_filename, font_size=fontsize)
+        click.echo("✓ Conversion complete!")
+
+    elif media_type == "video":
+        video = module.Video(source_path, width=width, height=height)
+        click.echo(
+            f"Please note: You are about to export a video with the following settings: "
+            f"length=({video.width}, {video.height}) font_size={fontsize}"
+        )
+        click.confirm("Do you want to continue?", abort=True)
+        video.export(target_filename, sound=sound, font_size=fontsize)
+
+        click.echo("✓ Conversion complete!")
+        if sound:
+            click.echo(f"✓ Your file is available here: {target_filename}_audio.mp4")
+        else:
+            click.echo(f"✓ Your file is available here: {target_filename}.mp4")
+
+
+@click.command()
+@click.argument("source_path", type=click.Path(exists=True))
+@click.option(
+    "--mode",
+    "-m",
+    type=click.Choice(list(MODES.keys())),
+    default="full_mode",
+    help="The ASCII generation mode to use."
+)
+def create_and_echo(source_path: str, mode: str) -> None:
+    """
+    Creates and prints an ASCII art image or video in the terminal.
+
+    Processes the input file located at SOURCE_PATH and outputs the result
+    directly to the standard output.
+    """
+    max_width, max_height = shutil.get_terminal_size()
+    max_height *= 2
+
+    click.echo(f"▶ Converting '{source_path}'...")
+    click.echo(f"▶ Settings: mode={mode}")
+
+    media_type, module = _get_media_type_and_module(source_path, mode)
+    click.echo(f"▶ Echo type: {media_type}")
+
+    if media_type == "image":
+        image = module.Image.from_path(source_path, height=max_height)
+        if image.width > max_width:
+            image = module.Image.from_path(source_path, width=max_width)
+
+        click.echo(image.get_alternate_lines())
+        click.echo("✓ Conversion complete!")
+
+    elif media_type == "video":
+        video = module.Video(source_path, height=max_height)
+        if video.width > max_width:
+            video = module.Video(source_path, width=max_width)
+
+        click.clear()
+        video.print_in_terminal(clean_print)
+        click.echo("✓ Conversion complete!")

{ascii_art_python-2.0.2 → ascii_art_python-2.1.1}/src/ascii_art_python/full_mode.py

@@ -5,7 +5,7 @@ This module provides classes to process images and videos in full mode,
 combining backgrounds and edges for detailed ASCII representation.
 """
 
-from typing import Union
+from typing import Optional, Any, List
 
 from . import ascii_base
 
@@ -20,20 +20,29 @@ class Image(ascii_base.Image):
     combining background characters and foreground edges.
     """
 
-    def to_list(self) -> list[str]:
+    def to_list(self, better_contrast: bool = True, color_edges: bool = False, **kwargs: Any) -> List[str]:
         """
         Converts the image to a list of ASCII strings.
 
         Combines the background characters and edge characters. If an edge
         character is empty (" "), it uses the corresponding background character.
 
+        Parameters
+        -----------
+        better_contrast : bool
+            If True, the program will increase the contrast to improve the result.
+        color_edges : bool
+            If True, performs edge detection on LAB color channels to catch 
+            isoluminant edges (better quality but slower). If False, uses 
+            grayscale edge detection (faster, recommended for videos).
+
         Returns
         --------
-        list[str]
+        List[str]
             A list of strings where each string represents a row of the ASCII image.
         """
-        backgrounds = self.get_backgrounds()
-        edges = self.get_edges()
+        backgrounds = self.get_backgrounds(better_contrast = better_contrast)
+        edges = self.get_edges(color_edges = color_edges)
         result = [""] * len(edges)
         for i, e in enumerate(edges):
             for j, f in enumerate(e):
@@ -52,8 +61,8 @@ class Video(ascii_base.Video):
     def __init__(
         self,
         path: str,
-        width: Union[int, None] = None,
-        height: Union[int, None] = None,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
         fps: int = 10,
     ) -> None:
         """
@@ -63,9 +72,9 @@ class Video(ascii_base.Video):
         -----------
         path : str
             The file path to the input video.
-        width : Union[int, None]
+        width : Optional[int]
             The desired width of the output video. If None, it is calculated automatically.
-        height : Union[int, None]
+        height : Optional[int]
             The desired height of the output video. If None, it is calculated automatically.
         fps : int
             The frames per second to process the video at (default is 10).

{ascii_art_python-2.0.2 → ascii_art_python-2.1.1}/src/ascii_art_python/new_skool.py

@@ -5,7 +5,7 @@ This module provides classes to process images and videos in new skool mode,
 relying entirely on background characters for the ASCII representation.
 """
 
-from typing import Union
+from typing import Optional, Any, List
 
 from . import ascii_base
 
@@ -20,19 +20,24 @@ class Image(ascii_base.Image):
     using only the background characters.
     """
 
-    def to_list(self) -> list[str]:
+    def to_list(self, better_contrast: bool = True, **kwargs: Any) -> List[str]:
         """
         Converts the image to a list of ASCII strings.
 
         Retrieves and returns only the background characters representing 
         the image, ignoring edges.
 
+        Parameters
+        -----------
+        better_contrast : bool
+            If True, the program will increase the contrast to improve the result.
+
         Returns
         --------
-        list[str]
+        List[str]
             A list of strings where each string represents a row of the ASCII image.
         """
-        return self.get_backgrounds()
+        return self.get_backgrounds(better_contrast = better_contrast)
 
 
 class Video(ascii_base.Video):
@@ -46,8 +51,8 @@ class Video(ascii_base.Video):
     def __init__(
         self,
         path: str,
-        width: Union[int, None] = None,
-        height: Union[int, None] = None,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
         fps: int = 10,
     ) -> None:
         """
@@ -57,9 +62,9 @@ class Video(ascii_base.Video):
         -----------
         path : str
             The file path to the input video.
-        width : Union[int, None]
+        width : Optional[int]
             The desired width of the output video. If None, it is calculated automatically.
-        height : Union[int, None]
+        height : Optional[int]
             The desired height of the output video. If None, it is calculated automatically.
         fps : int
             The frames per second to process the video at (default is 10).

{ascii_art_python-2.0.2 → ascii_art_python-2.1.1}/src/ascii_art_python/old_skool.py

@@ -5,7 +5,7 @@ This module provides classes to process images and videos in old skool mode,
 relying entirely on foreground edges for the ASCII representation.
 """
 
-from typing import Union
+from typing import Optional, Any, List
 
 from . import ascii_base
 
@@ -20,19 +20,26 @@ class Image(ascii_base.Image):
     using only the edge characters.
     """
 
-    def to_list(self) -> list[str]:
+    def to_list(self, color_edges: bool = False, **kwargs: Any) -> List[str]:
         """
         Converts the image to a list of ASCII strings.
 
         Retrieves and returns only the edge characters representing 
         the image, ignoring backgrounds.
 
+        Parameters
+        -----------
+        color_edges : bool
+            If True, performs edge detection on LAB color channels to catch 
+            isoluminant edges (better quality but slower). If False, uses 
+            grayscale edge detection (faster, recommended for videos).
+
         Returns
         --------
-        list[str]
+        List[str]
             A list of strings where each string represents a row of the ASCII image.
         """
-        return self.get_edges()
+        return self.get_edges(color_edges = color_edges)
 
 
 class Video(ascii_base.Video):
@@ -46,8 +53,8 @@ class Video(ascii_base.Video):
     def __init__(
         self,
         path: str,
-        width: Union[int, None] = None,
-        height: Union[int, None] = None,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
         fps: int = 10,
     ) -> None:
         """
@@ -57,9 +64,9 @@ class Video(ascii_base.Video):
         -----------
         path : str
             The file path to the input video.
-        width : Union[int, None]
+        width : Optional[int]
             The desired width of the output video. If None, it is calculated automatically.
-        height : Union[int, None]
+        height : Optional[int]
             The desired height of the output video. If None, it is calculated automatically.
         fps : int
             The frames per second to process the video at (default is 10).

{ascii_art_python-2.0.2 → ascii_art_python-2.1.1/src/ascii_art_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ascii_art_python
-Version: 2.0.2
+Version: 2.1.1
 Summary: A Python library and CLI tool for converting images and videos into ASCII art.
 Author-email: Guillem Prieur <prieurguillem38@gmail.com>
 Project-URL: Homepage, https://gitlab.pprriieeuurr.fr/guill_prieur/ascii-art-python-2

{ascii_art_python-2.0.2 → ascii_art_python-2.1.1}/tests/test_ascii_api.py

@@ -168,8 +168,7 @@ class TestVideoBase:
         assert vid.path == "fake_video.mp4"
         assert vid.max_fps == 12
         assert vid.fps == 24.0 # Mocked value returned by cv2.CAP_PROP_FPS
-        # The hidden original size is (frame_width * 20, frame_height * 20)
-        assert vid.original_size == (50 * 15, 50 * 15)
+        assert vid.height * vid.width == 2500
 
     @patch('pathlib.Path.is_file', return_value=False)
     def test_video_initialization_file_not_found(self, mock_is_file):
@@ -196,18 +195,25 @@ class TestVideoBase:
     @patch.object(ascii_base, 'VideoFileClip')
     def test_transfer_audio(self, mock_videofileclip, mock_is_file):
         """Tests the audio transfer logic (mocked)."""
-        mock_is_file.side_effect = lambda path: path.name != "output.mp4" # output.mp4 should not exist
-        
+        mock_is_file.side_effect = lambda path: path.name != "output.mp4"
+
         mock_source = MagicMock()
         mock_target = MagicMock()
         mock_final = MagicMock()
-        
-        # MoviePy mocks configuration
+
+        mock_source.__enter__.return_value = mock_source
+        mock_target.__enter__.return_value = mock_target
+    
         mock_videofileclip.side_effect = [mock_source, mock_target]
         mock_target.with_audio.return_value = mock_final
-        
+
         ascii_base.Video.transfer_audio("source.mp4", "target.mp4", "output.mp4")
-        
+
         mock_target.with_audio.assert_called_once_with(mock_source.audio)
+        
         mock_final.write_videofile.assert_called_once()
-        mock_source.close.assert_called_once()
+        
+        mock_source.__exit__.assert_called_once()
+        mock_target.__exit__.assert_called_once()
+        
+        mock_final.close.assert_called_once()

ascii_art_python-2.0.2/src/ascii_art_python/cli.py

@@ -1,107 +0,0 @@
-import mimetypes
-import shutil
-import sys
-import click
-from . import full_mode, old_skool, new_skool
-
-from .tools import clean_print
-
-MODES = {
-    "full_mode": full_mode,
-    "old_skool": old_skool,
-    "new_skool": new_skool
-}
-
-@click.command()
-@click.argument("source_path", type=click.Path(exists=True))
-@click.argument("target_filename", type=click.STRING)
-@click.option("--width", "-w", type=int, default=None, help="The number of characters in the width of the output")
-@click.option("--height", "-h", type=int, default=None, help="The number of characters in the height of the output")
-@click.option("--mode", "-m", type=click.Choice(["full_mode", "old_skool", "new_skool"]), default="full_mode", help="full_mode / old_skool / new_skool")
-@click.option("--sound/--no-sound", type=bool, default=True, help="If the file is a video file, export it with or without audio.")
-def create_and_export(source_path, target_filename, width, height, mode, sound):
-    """
-    Creates and exports an ASCII art image or video.
-    """
-    click.echo(f"▶ Converting '{source_path}'...")
-    click.echo(f"▶ Settings: length=({width}, {height}), mode={mode}")
-
-    type_mime, _ = mimetypes.guess_type(source_path)
-
-    if type_mime is None:
-        click.secho("✗ Error: Unable to determine which export type to use")
-        sys.exit(1)
-    elif type_mime.startswith('image'):
-        click.echo("▶ Export type: image")
-        if mode not in MODES:
-            click.secho(f"✗ Error: Mode '{mode}' is not recognized.")
-            sys.exit(1)
-
-        module = MODES[mode]
-        image = module.Image.from_path(source_path, width, height)
-        image.export(target_filename)
-        click.echo("✓ Conversion complete!")
-    elif type_mime.startswith('video'):
-        click.echo("▶ Export type: video")
-        if mode not in MODES:
-            click.secho(f"✗ Error: Mode '{mode}' is not recognized.")
-            sys.exit(1)
-
-        module = MODES[mode]
-        video = module.Video(source_path, width, height)
-        click.echo(f"Please note: You are about to export a video with the following settings: length=({video.width}, {video.height})")
-        click.confirm("Do you want to continue?", abort=True)
-        video.export(target_filename, sound=sound)
-        click.echo("✓ Conversion complete!")
-        if sound:
-            click.echo(f"✓ Your file is available here: {target_filename}_audio.mp4")
-        else:
-            click.echo(f"✓ Your file is available here: {target_filename}.mp4")
-    else:
-        click.secho("✗ Error: Unable to determine which export type to use")
-        sys.exit(1)
-
-
-@click.command()
-@click.argument("source_path", type=click.Path(exists=True))
-@click.option("--mode", "-m", default="full_mode", help="full_mode / old_skool / new_skool")
-def create_and_echo(source_path, mode):
-    """
-    Creates and prints an ASCII art image or video.
-    """
-    max_width, max_height = shutil.get_terminal_size()
-    max_height *= 2
-    click.echo(f"▶ Converting '{source_path}'...")
-    click.echo(f"▶ Settings: mode={mode}")
-
-    type_mime, _ = mimetypes.guess_type(source_path)
-
-    if type_mime is None:
-        click.secho("✗ Error: Unable to determine which export type to use")
-        sys.exit(1)
-    elif type_mime.startswith('image'):
-        click.echo("▶ Echo type: image")
-        if mode not in MODES:
-            click.secho(f"✗ Error: Mode '{mode}' is not recognized.")
-            sys.exit(1)
-
-        module = MODES[mode]
-        image = module.Image.from_path(source_path, width, height)
-        click.echo(image.get_alternate_lines())
-        click.echo("✓ Conversion complete!")
-    elif type_mime.startswith('video'):
-        click.echo("▶ Echo type: video")
-        if mode not in MODES:
-            click.secho(f"✗ Error: Mode '{mode}' is not recognized.")
-            sys.exit(1)
-
-        module = MODES[mode]
-        video = module.Video(source_path, height = max_height)
-        if video.width > max_width:
-            video = module.Video(source_path, width = max_width)
-        click.clear()
-        video.print_in_terminal(clean_print)
-        click.echo("✓ Conversion complete!")
-    else:
-        click.secho("✗ Error: Unable to determine which export type to use")
-        sys.exit(1)