absfuyu 5.0.0__py3-none-any.whl → 6.1.2__py3-none-any.whl

absfuyu/dxt/strext.py

@@ -3,8 +3,8 @@ Absfuyu: Data Extension
 -----------------------
 str extension
 
-Version: 5.0.0
-Date updated: 11/02/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 # Module Package
@@ -15,14 +15,72 @@ __all__ = ["Text", "TextAnalyzeDictFormat"]
 # Library
 # ---------------------------------------------------------------------------
 import random
+from string import ascii_letters as _ascii_letters
 from typing import NotRequired, Self, TypedDict
 
-from absfuyu.core import ShowAllMethodsMixin, deprecated, versionadded, versionchanged
-from absfuyu.general.generator import Charset, Generator
-from absfuyu.logger import logger
+from absfuyu.core import GetClassMembersMixin, deprecated, versionadded, versionchanged
 from absfuyu.util import set_min_max
 
 
+# Support function
+# ---------------------------------------------------------------------------
+def _generate_string(
+    charset: str | None = None,
+    size: int = 8,
+    times: int = 1,
+    unique: bool = True,
+) -> list[str]:
+    """
+    Generate a list of random string from character set
+    (Random string generator)
+
+    This is a lesser version of
+    ``absfuyu.tools.generator.Generator.generate_string()``
+
+    Parameters
+    ----------
+    charset : str, optional
+        Custom character set, by default ``None``
+        ([a-zA-Z] - string.ascii_letters)
+
+    size : int, optional
+            Length of each string in list, by default ``8``
+
+    times : int, optional
+        How many random string generated, by default ``1``
+
+    unique : bool, optional
+        Each generated text is unique, by default ``True``
+
+    Returns
+    -------
+    list[str]
+        List of random string generated
+    """
+
+    charset = _ascii_letters or charset
+
+    try:
+        char_lst = list(charset)  # type: ignore[arg-type]
+    except Exception:
+        char_lst = charset  # type: ignore[assignment]
+
+    unique_string = []
+    count = 0
+
+    while count < times:
+        gen_string = "".join(random.choice(char_lst) for _ in range(size))  # type: ignore
+        if not unique:
+            unique_string.append(gen_string)
+            count += 1
+        else:
+            if gen_string not in unique_string:
+                unique_string.append(gen_string)
+                count += 1
+
+    return unique_string
+
+
 # Class
 # ---------------------------------------------------------------------------
 class TextAnalyzeDictFormat(TypedDict):
@@ -58,9 +116,12 @@ class TextAnalyzeDictFormat(TypedDict):
     is_palindrome: NotRequired[bool]
 
 
-class Text(ShowAllMethodsMixin, str):
+class Text(GetClassMembersMixin, str):
     """
     ``str`` extension
+
+    >>> # For a list of new methods
+    >>> Text.show_all_methods()
     """
 
     def divide(self, string_split_size: int = 60) -> list[str]:
@@ -154,9 +215,7 @@ class Text(ShowAllMethodsMixin, str):
         splt_len = len(temp)
 
         if custom_var_name is None:
-            splt_name = Generator.generate_string(
-                charset=Charset.ALPHABET, size=split_var_len, times=splt_len + 1
-            )
+            splt_name = _generate_string(size=split_var_len, times=splt_len + 1)
             for i in range(splt_len):
                 output.append(f"{splt_name[i]}='{temp[i]}'")
         else:
@@ -361,14 +420,15 @@ class Text(ShowAllMethodsMixin, str):
         probability = int(set_min_max(probability))
         text = self.lower()
 
-        temp = []
-        for x in text:
-            if random.randint(1, 100) <= probability:
-                x = x.upper()
-            temp.append(x)
-        logger.debug(temp)
-        return self.__class__("".join(temp))
+        random_caps = (
+            x.upper() if random.randint(1, 100) <= probability else x for x in text
+        )
+        return self.__class__("".join(random_caps))
 
+    @deprecated(
+        "5.2.0",
+        reason="str already has swapcase() method, will be removed in version 5.3.0",
+    )
     @versionchanged("5.0.0", reason="Use ``str.swapcase()``")
     def reverse_capslock(self) -> Self:
         """
@@ -406,7 +466,7 @@ class Text(ShowAllMethodsMixin, str):
         """
         return list(self)
 
-    @deprecated("5.0.0", reason="Unused")
+    @deprecated("5.0.0", reason="Unused, will be removed in version 5.3.0")
     def to_listext(self) -> None:
         """Deprecated, will be removed soon"""
         raise NotImplementedError("Deprecated, will be removed soon")

absfuyu/extra/__init__.py

@@ -3,8 +3,8 @@ Absfuyu: Extra
 --------------
 Features that require additional libraries
 
-Version: 1.0.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 

absfuyu/extra/audio/__init__.py

@@ -0,0 +1,8 @@
+"""
+Absfuyu: Audio
+--------------
+Audio related
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""

absfuyu/extra/audio/_util.py

@@ -0,0 +1,57 @@
+"""
+Absfuyu: Audio
+--------------
+Audio convert, lossless checker
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["StatusCode", "ResultStatus"]
+
+# Library
+# ---------------------------------------------------------------------------
+from enum import StrEnum
+from pathlib import Path
+
+# Class Enum, Result
+# ---------------------------------------------------------------------------
+try:
+    from rich import print
+
+    class StatusCode(StrEnum):
+        OK = "[bold green]OK[/]"
+        SKIP = "[bold yellow]SKIP[/]"
+        ERROR = "[bold red]ERROR[/]"
+        LOSSLESS = "[bold green]LOSSLESS[/]"
+        NOT_LOSSLESS = "[bold red]NOT LOSSLESS[/]"
+        HIRES = "[bold blue]HIRES[/]"
+
+except ImportError:
+
+    class StatusCode(StrEnum):
+        OK = "OK"
+        SKIP = "SKIP"
+        ERROR = "ERROR"
+        LOSSLESS = "LOSSLESS"
+        NOT_LOSSLESS = "NOT LOSSLESS"
+        HIRES = "HIRES"
+
+
+class ResultStatus:
+    """
+    Result status
+    """
+
+    def __init__(self, status: StatusCode, path: Path) -> None:
+        self.status = status
+        self.path = path
+
+    def __repr__(self) -> str:
+        return f"{self.status} : {self.path.name}"
+
+    def print(self) -> None:
+        """Print repr (for rich package)"""
+        print(self.status, ": ", self.path.name)

absfuyu/extra/audio/convert.py

@@ -0,0 +1,192 @@
+"""
+Absfuyu: Audio
+--------------
+Audio convert
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["DirectoryAudioConvertMixin"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import json
+import subprocess
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+from typing import Literal
+
+from absfuyu.core.dummy_func import tqdm
+from absfuyu.extra.audio._util import ResultStatus as ConvertStatus
+from absfuyu.extra.audio._util import StatusCode
+from absfuyu.util import is_command_available
+from absfuyu.util.path import DirectoryBase
+
+
+# Class
+# ---------------------------------------------------------------------------
+class DirectoryAudioConvertMixin(DirectoryBase):
+    """
+    Directory - Audio convert to mp3
+
+    - convert_to_mp3
+    """
+
+    def __init__(self, source_path, create_if_not_exist=False):
+        super().__init__(source_path, create_if_not_exist)
+        is_command_available(["ffmpeg"], "ERROR: ffmpeg not installed to PATH")
+
+    def _read_metadata(self, audio_path: Path, /) -> dict:
+        """
+        Read audio metadata
+
+        Parameters
+        ----------
+        audio_path : Path
+            Path to audio
+
+        Returns
+        -------
+        dict
+            Audio's metadata
+        """
+        cmd = [
+            "ffprobe",
+            "-v",
+            "quiet",
+            "-print_format",
+            "json",
+            "-show_format",
+            str(audio_path.resolve()),
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        data = json.loads(result.stdout)
+
+        if "format" in data and "tags" in data["format"]:
+            return data["format"]["tags"]
+        return {}
+
+    def convert_one(self, audio_path: Path | str, bitrate: Literal["128k", "320k"] = "320k") -> ConvertStatus:
+        """
+        Convert audio to mp3
+
+        Parameters
+        ----------
+        audio_path : Path | str
+            Path to audio
+
+        bitrate : Literal["128k", "320k"], optional
+            Bitrate, by default "320k"
+
+        Returns
+        -------
+        ConvertStatus
+            Result
+        """
+        audio_path = Path(audio_path)
+        mp3_path = audio_path.with_suffix(".mp3")
+
+        if mp3_path.exists():
+            return ConvertStatus(StatusCode.SKIP, mp3_path)
+
+        metadata = self._read_metadata(audio_path)
+
+        ffmpeg_cmd = ["ffmpeg", "-y", "-i", str(audio_path.resolve())]
+
+        # Add metadata tags
+        for key, value in metadata.items():
+            ffmpeg_cmd.extend(["-metadata", f"{key}={value}"])
+
+        ffmpeg_cmd.extend(["-vn", "-codec:a", "libmp3lame", "-b:a", bitrate, str(mp3_path.resolve())])
+
+        subprocess.run(ffmpeg_cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return ConvertStatus(StatusCode.OK, mp3_path)
+
+    def convert_to_mp3_single_thread(
+        self,
+        from_format: str = ".flac",
+        recursive: bool = True,
+        bitrate: Literal["128k", "320k"] = "320k",
+    ) -> None:
+        """
+        Convert audios to .mp3 - Single thread
+
+        Parameters
+        ----------
+        from_format : str, optional
+            Audio format, by default ".flac"
+
+        recursive : bool, optional
+            Include audio in child folder, by default True
+
+        bitrate : Literal["128k", "320k"], optional
+            Bitrate, by default "320k"
+        """
+        audios = list(self.source_path.rglob(f"{'**/*'if recursive else '*'}{from_format}"))
+
+        if not audios:
+            print(f"No {from_format.upper()} files found.")
+            return None
+
+        print(f"Found {len(audios)} {from_format.upper()} files.")
+
+        results: list[ConvertStatus] = []
+        for x in tqdm(audios, desc="Converting", unit="file", unit_scale=True):
+            results.append(self.convert_one(x, bitrate=bitrate))
+
+        print("\n--- Summary ---")
+        for line in results:
+            line.print()
+
+    def convert_to_mp3(
+        self,
+        from_format: str = ".flac",
+        workers: int | None = None,
+        recursive: bool = True,
+        bitrate: Literal["128k", "320k"] = "320k",
+    ) -> None:
+        """
+        Convert audios to .mp3
+
+        Parameters
+        ----------
+        from_format : str, optional
+            Audio format, by default ".flac"
+
+        workers : int | None, optional
+            Number of parallel processing threads, by default None
+
+        recursive : bool, optional
+            Include audio in child folder, by default True
+
+        bitrate : Literal["128k", "320k"], optional
+            Bitrate, by default "320k"
+        """
+        audios = list(self.source_path.rglob(f"{'**/*'if recursive else '*'}{from_format}"))
+
+        if not audios:
+            print(f"No {from_format.upper()} files found.")
+            return None
+
+        print(f"Found {len(audios)} {from_format.upper()} files.")
+
+        results: list[ConvertStatus] = []
+        with ProcessPoolExecutor(max_workers=workers) as executor:
+            futures = {executor.submit(self.convert_one, x, bitrate): x for x in audios}
+
+            for fut in tqdm(
+                as_completed(futures),
+                total=len(futures),
+                desc="Converting",
+                unit="file",
+                unit_scale=True,
+            ):
+                results.append(fut.result())
+
+        print("\n--- Summary ---")
+        for line in results:
+            line.print()

absfuyu/extra/audio/lossless.py

@@ -0,0 +1,281 @@
+"""
+Absfuyu: Audio
+--------------
+Audio lossless checker
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["AudioInfo", "DirectoryAudioLosslessCheckMixin"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import json
+import subprocess
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, NamedTuple
+
+from absfuyu.core.dummy_func import tqdm
+from absfuyu.extra.audio._util import ResultStatus, StatusCode
+from absfuyu.util import is_command_available
+from absfuyu.util.path import DirectoryBase
+from absfuyu.util.shorten_number import Duration
+
+try:
+    import numpy as np
+except ImportError:
+    from subprocess import run
+
+    from absfuyu.config import ABSFUYU_CONFIG
+
+    if ABSFUYU_CONFIG._get_setting("auto-install-extra").value:  # type: ignore
+        cmd = "python -m pip install -U absfuyu[extra]".split()
+        run(cmd)
+    else:
+        raise SystemExit("This feature is in absfuyu[extra] package")  # noqa: B904
+
+
+# Class
+# ---------------------------------------------------------------------------
+class FrequencyRange(NamedTuple):
+    """Audio frequency range"""
+
+    min: int | float
+    max: int | float
+
+
+@dataclass
+class AudioInfo:
+    """
+    Audio infomation
+
+    Parameters
+    ----------
+    sample_rate : int | None, optional
+        Sample rate (Hz)
+
+    bit_depth : int, optional
+        Bit depth
+
+    channels : int | None, optional
+        Number of channels
+
+    codec : str | None, optional
+        Audio codec
+
+    duration_raw : float, optional
+        Duration of audio (second)
+
+    bitrate : Any | None, optional
+        Bitrate
+
+    audio_path : Path | None, optional
+        Path to audio
+
+    Returns
+    -------
+    AudioInfo
+        Audio infomation
+    """
+
+    sample_rate: int | None = field(default=None, metadata={"unit": "Hz"})
+    bit_depth: int = field(default=0, metadata={"unit": "bit"})
+    channels: int | None = field(default=None)
+    codec: str | None = field(default=None)
+    duration_raw: float = field(default=0.0, repr=False, metadata={"unit": "second"})
+    bitrate: int | None = field(default=None)
+    audio_path: Path | None = field(default=None, repr=False)  # hide path in repr
+
+    # computed fields
+    duration: float = field(init=False)
+    freq_range: FrequencyRange = field(init=False, metadata={"unit": "Hz"})
+
+    def __post_init__(self):
+        self.duration = Duration(self.duration_raw)
+
+        # Resource intensive method
+        # _, sampling_rate = librosa.load(audio_path, sr=None)
+        # freqs = librosa.fft_frequencies(sr=sampling_rate)
+        freqs = np.fft.rfftfreq(n=2048, d=1.0 / self.sample_rate)
+        self.freq_range = FrequencyRange(freqs[0], freqs[-1])
+
+    @property
+    def is_lossless(self) -> bool:
+        """
+        Audio is lossless when frequencies above 20,000 are not cut off
+
+        Returns
+        -------
+        bool
+            If audio is lossless
+        """
+        return self.freq_range[1] >= 20000
+
+    @property
+    def is_hi_res(self) -> bool:
+        """
+        Audio is HiRes when lossless and have sample rate >= 48,000Hz or bit rate >= 16 bit
+
+        Returns
+        -------
+        bool
+            If audio is lossless
+        """
+        bd = 0 if self.bit_depth is None else self.bit_depth
+        return all([self.sample_rate >= 48000, bd >= 24, self.is_lossless])
+
+
+class DirectoryAudioLosslessCheckMixin(DirectoryBase):
+    """
+    Directory - Audio lossless checker
+
+    - lossless_check
+    """
+
+    def get_audio_info(self, audio_path: Path, /) -> AudioInfo:
+        """
+        Return audio info using ffprobe.
+
+        Parameters
+        ----------
+        audio_path : Path
+            Path to audio
+
+        Returns
+        -------
+        AudioInfo
+            Audio infomation
+        """
+
+        is_command_available(["ffmpeg"], "ERROR: ffmpeg not installed to PATH")
+
+        # Probe
+        cmd = [
+            "ffprobe",
+            "-v",
+            "error",
+            "-print_format",
+            "json",
+            "-show_streams",
+            "-select_streams",
+            "a:0",
+            str(audio_path.resolve()),
+        ]
+
+        result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        data: dict[str, Any] = json.loads(result.stdout)["streams"][0]
+
+        bit_depth = data.get("bits_per_sample") or data.get("bits_per_raw_sample")
+        if bit_depth is not None:
+            bit_depth = int(bit_depth)
+
+        ai = AudioInfo(
+            sample_rate=int(data.get("sample_rate", 0)),
+            bit_depth=bit_depth,
+            channels=data.get("channels"),
+            codec=data.get("codec_name"),
+            duration_raw=float(data["duration"]) if "duration" in data else None,
+            bitrate=int(data["bit_rate"]) if "bit_rate" in data else None,
+            audio_path=audio_path,
+        )
+        return ai
+
+    def lossless_check_one(self, audio_path: Path) -> ResultStatus:
+        """
+        Check if audio is lossless
+
+        Parameters
+        ----------
+        audio_path : Path
+            Path to audio
+
+        Returns
+        -------
+        ResultStatus
+            If audio is lossless
+        """
+        res = self.get_audio_info(audio_path)
+        if res.is_hi_res:
+            return ResultStatus(StatusCode.HIRES, audio_path)
+        elif res.is_lossless:
+            return ResultStatus(StatusCode.LOSSLESS, audio_path)
+        return ResultStatus(StatusCode.NOT_LOSSLESS, audio_path)
+
+    def lossless_check_single_thread(self, from_format: str = ".flac", recursive: bool = True) -> None:
+        """
+        Check if audios in directory are lossless - single thread version
+
+        Parameters
+        ----------
+        from_format : str, optional
+            Audio format, by default ".flac"
+
+        recursive : bool, optional
+            Include audio in child folder, by default True
+        """
+        audios = list(self.source_path.rglob(f"{'**/*'if recursive else '*'}{from_format}"))
+
+        if not audios:
+            print(f"No {from_format.upper()} files found.")
+            return None
+
+        print(f"Found {len(audios)} {from_format.upper()} files.")
+
+        results: list[ResultStatus] = []
+        for x in tqdm(audios, desc="Checking", unit="file", unit_scale=True):
+            results.append(self.lossless_check_one(x))
+
+        print("\n--- Summary ---")
+        for line in results:
+            line.print()
+
+    def lossless_check(
+        self,
+        from_format: str = ".flac",
+        recursive: bool = True,
+        workers: int | None = None,
+    ) -> None:
+        """
+        Check if audios in directory are lossless
+
+        Parameters
+        ----------
+        from_format : str, optional
+            Audio format, by default ".flac"
+
+        recursive : bool, optional
+            Include audio in child folder, by default True
+
+        workers : int | None, optional
+            Number of parallel processing threads, by default None
+        """
+        audios = list(self.source_path.rglob(f"{'**/*'if recursive else '*'}{from_format}"))
+
+        if not audios:
+            print(f"No {from_format.upper()} files found.")
+            return None
+
+        print(f"Found {len(audios)} {from_format.upper()} files.")
+
+        results: list[ResultStatus] = []
+        with ProcessPoolExecutor(max_workers=workers) as executor:
+            futures = {executor.submit(self.lossless_check_one, x): x for x in audios}
+
+            for fut in tqdm(
+                as_completed(futures),
+                total=len(futures),
+                desc="Checking",
+                unit="file",
+                unit_scale=True,
+            ):
+                results.append(fut.result())
+
+        print("\n--- Summary ---")
+        for line in results:
+            line.print()