Restructure audiobot, update main for faster startup

Signed-off-by: Skye <[email protected]>

Author: skye-cyber

audiobot/__init__.py

@@ -1,4 +1,9 @@
 """
+    ///////]    ///    ///  ///////]    (O)    //////]     /////      //////]   /////////
+   //     //   ///    ///  //      //  ///  ///     ///   //   /   ///     ///    ///
+  /////////   ///    ///  //       /  ///  ///      ///  /////    ///      ///   ///
+ //     //   ///    ///  //       /  ///   //      //   //    /   //      //    ///
+//     //   //////////  /////// /   ///     ///////    ///////     ///////     ///
 Perform audio modifications such as adding voice effect to an audio or video file\n
 <b>Operation</b>:
 <ul>
@@ -15,9 +20,27 @@
 </ul>
 """
 
-from .cli import Argsmain as main
-
+from .cli import cli, ArgumentsProcessor
+from .utils.logging_utils import LoggingFormatter, colored_logger
+from .utils.visualizer import audiowave_visualizer
+from .utils.metadata_utils import get_audio_bitrate
+from .core.codec import AudioSegmentArrayCodec
+from .core.effects import VoiceEffectProcessor
+from .core.audio.core import AudioModulator, AudioDenoiser
 
+__version__ = "0.2.0"
+__all__ = [
+    "cli",
+    "ArgumentsProcessor",
+    "LoggingFormatter",
+    "colored_logger",
+    "audiowave_visualizer",
+    "get_audio_bitrate",
+    "AudioSegmentArrayCodec",
+    "VoiceEffectProcessor",
+    "AudioModulator",
+    "AudioDenoiser",
+]
 LOGO = """
     ///////]    ///    ///  ///////]    (O)    //////]     /////      //////]   /////////
    //     //   ///    ///  //      //  ///  ///     ///   //   /   ///     ///    ///

audiobot/cli.py

@@ -1,4 +1,12 @@
 #!/usr/bin/python3
+
+
+"""
+CLI Entry point for audiobot.\n
+<b>Implements</b>:\n
+    Argsmain->cmd argument handler either from other packages or directly form cli
+"""
+
 import argparse
 import logging
 
@@ -7,16 +15,16 @@
 import magic
 from .utils.metadata_utils import transcribe_audio
 from filemac.utils.colors import fg, rs
-from .processor import VideoProcessor, AudioProcessor
-from .logging_config import setup_colored_logger
-from .config import Config
+from .core.processor import VideoProcessor, AudioProcessor
+from .utils.logging_utils import colored_logger
+from .config.core import Config
 
 RESET = rs
 
-Clogger = setup_colored_logger()
+Clogger = colored_logger()
 
 
-class Processor:
+class ArgumentsProcessor:
     def __init__(self, args, parser):
         self.args = args
         self.parser = parser
@@ -98,7 +106,7 @@ def batch_processor(self):
             Clogger.info(e)
 
 
-def Argsmain(argsv=None):
+def cli(argsv=None):
     """
     Recieve and process agruments from audio/video audio effects
     """
@@ -181,8 +189,8 @@ def Argsmain(argsv=None):
         config.options["cutoff"] = args.cutoff
         config.options["noise"] = args.noise
     # Call argument processor
-    Processor(args, parser).process()
+    ArgumentsProcessor(args, parser).process()
 
 
 if __name__ == "__main__":
-    Argsmain()
+    cli()

audiobot/config/__init__.py

@@ -1,18 +1,18 @@
 import numpy as np
-from .logging_config import setup_colored_logger
+from ...utils.logging_utils import colored_logger
 import librosa
 from pydub import AudioSegment, effects
 from scipy.signal import butter, lfilter, sosfilt
-from .config import Config
+from ...config.core import Config
 from filemac.utils.colors import fg, rs
 
 RESET = rs
 
-Clogger = setup_colored_logger()
+Clogger = colored_logger()
 config = Config()
 
 
-class Modulator:
+class AudioModulator:
     def __init__(self):
         self._cutoff = config.options.get("cutoff")
 
@@ -172,7 +172,7 @@ def normalize(self, audio_segment):
         return effects.normalize(audio_segment)
 
 
-class Denoiser:
+class AudioDenoiser:
     def __init__(self, sample_rate=44100):
         self.sample_rate = sample_rate
         # Dictionaries to cache filter coefficients by cutoff value

audiobot/config.py renamed to audiobot/config/core.py

@@ -1,10 +1,10 @@
 from pydub import effects
 from .codec import AudioSegmentArrayCodec
-from .modulator import Modulator
-from .logging_config import setup_colored_logger
+from .audio.core import AudioModulator
+from ..utils.logging_utils import colored_logger
 from pydub import AudioSegment
 
-# logger = setup_colored_logger()
+# logger = colored_logger()
 
 
 class VoiceEffectProcessor:
@@ -13,42 +13,42 @@ def __init__(self, audio_segment, effect: str, verbosity: bool = False):
         self.audio_segment = audio_segment
         self.verbosity = verbosity
         self.handler = AudioSegmentArrayCodec()
-        self.logger = setup_colored_logger()
+        self.logger = colored_logger()
 
     def _apply_chipmunk(self):
-        return Modulator().pitch_shift(
+        return AudioModulator().pitch_shift(
             effects.speedup(self.audio_segment, 1.01), n_steps=9
         )
 
     def _apply_high(self):
-        return Modulator().pitch_shift(self.audio_segment, n_steps=4)
+        return AudioModulator().pitch_shift(self.audio_segment, n_steps=4)
 
     def _apply_lowpass(self):
-        return Modulator().lowpass(self.audio_segment)
+        return AudioModulator().lowpass(self.audio_segment)
 
     def _apply_highpass(self):
-        return Modulator().highpass(self.audio_segment)
+        return AudioModulator().highpass(self.audio_segment)
 
     def _apply_robotic(self):
-        return Modulator().pitch_shift(
+        return AudioModulator().pitch_shift(
             effects.speedup(self.audio_segment, 1.01), n_steps=-10
         )
 
     def _apply_demonic(self):
         return (
-            Modulator()
+            AudioModulator()
             .pitch_shift(effects.speedup(self.audio_segment, 1.01), n_steps=-10)
             .overlay(
                 AudioSegment.silent(duration=700) + self.audio_segment.fade_out(500)
             )
         )
 
     def _apply_hacker(self):
-        return Modulator().hacker(self.audio_segment)
+        return AudioModulator().hacker(self.audio_segment)
 
     def _apply_distortion(self):
         samples, sample_rate = self.handler.audiosegment_to_numpy(self.audio_segment)
-        distorted_samples = Modulator().distort(samples)
+        distorted_samples = AudioModulator().distort(samples)
         return self.handler.numpy_to_audiosegment(
             distorted_samples,
             sample_rate,
@@ -57,18 +57,18 @@ def _apply_distortion(self):
         )
 
     def _apply_deep(self):
-        return Modulator().pitch_shift(self.audio_segment, n_steps=-4)
+        return AudioModulator().pitch_shift(self.audio_segment, n_steps=-4)
 
     def _apply_echo(self):
         delay = AudioSegment.silent(duration=1000)
         return self.audio_segment.overlay(delay + self.audio_segment)
 
     def _apply_whisper(self):
-        return Modulator().whisper(self.audio_segment)
+        return AudioModulator().whisper(self.audio_segment)
 
     def _apply_reverb(self):
         samples, sample_rate = self.handler.audiosegment_to_numpy(self.audio_segment)
-        reverbed_samples = Modulator().reverb(samples)
+        reverbed_samples = AudioModulator().reverb(samples)
         return self.handler.numpy_to_audiosegment(
             reverbed_samples,
             sample_rate,
@@ -77,10 +77,10 @@ def _apply_reverb(self):
         )
 
     def denoise(self):
-        from .modulator import Denoiser
+        from .modulator import AudioDenoiser
 
         sample, sample_rate = self.handler.audiosegment_to_numpy(self.audio_segment)
-        denoised_sample = Denoiser().denoise(sample)
+        denoised_sample = AudioDenoiser().denoise(sample)
         audio_segment = self.handler.numpy_to_audiosegment(
             denoised_sample,
             sample_rate,

audiobot/core/__init__.py

@@ -1,18 +1,18 @@
 import os
-from .modulator import Modulator
+from .audio.core import AudioModulator
 from moviepy import AudioFileClip, VideoFileClip
-from .logging_config import setup_colored_logger
+from ..utils.logging_utils import colored_logger
 from pydub import AudioSegment
-from .utils.visualizer import visualize_audio_wave
-from .utils.metadata_utils import get_bitrate
+from ..utils.visualizer import audiowave_visualizer
+from ..utils.metadata_utils import get_audio_bitrate
 from .effects import VoiceEffectProcessor
 from filemac.utils.colors import fg, rs
 import sys
-import io
+# import io
 
 RESET = rs
 
-Clogger = setup_colored_logger()
+Clogger = colored_logger()
 
 
 class VideoProcessor:
@@ -36,7 +36,7 @@ def process_video_file(
 
         try:
             # Get the original video bitrate
-            original_bitrate = get_bitrate(input_file, verbosity)
+            original_bitrate = get_audio_bitrate(input_file, verbosity)
             if verbosity and original_bitrate:
                 Clogger.info(
                     f"Original video bitrate: {fg.YELLOW_FG}{original_bitrate}{RESET}"
@@ -45,8 +45,8 @@ def process_video_file(
             # Capture stdout and stderr
             old_stdout = sys.stdout
             old_stderr = sys.stderr
-            sys.stdout = captured_stdout = io.StringIO()
-            sys.stderr = captured_stderr = io.StringIO()
+            # sys.stdout = captured_stdout = io.StringIO()
+            # sys.stderr = captured_stderr = io.StringIO()
 
             # Load the video
             try:
@@ -69,7 +69,7 @@ def process_video_file(
             modified_audio = VoiceEffectProcessor(audio_segment, effect).apply_effect()
 
             # Normalize the modified audio
-            modified_audio = Modulator().normalize(modified_audio)
+            modified_audio = AudioModulator().normalize(modified_audio)
 
             # Export the modified audio to a WAV file
             if verbosity:
@@ -105,10 +105,10 @@ def process_video_file(
             )
 
             Clogger.info(f"Modified video saved as: {output_file}")
-            Clogger.debug(f"Final bitrate = {get_bitrate(output_file)}")
+            Clogger.debug(f"Final bitrate = {get_audio_bitrate(output_file)}")
             # Optional: visualize the before and after audio
             if visualize:
-                visualize_audio_wave(audio_file, "modified_audio.wav")
+                audiowave_visualizer(audio_file, "modified_audio.wav")
 
             # Clean up temporary files
             if os.path.exists(audio_file):
@@ -140,15 +140,15 @@ def process_audio_file(
                 print(f"- INFO - Audio channels: {audio_segment.channels}")
                 print(f"- INFO - Audio sample width: {audio_segment.sample_width}")
             modified_audio = VoiceEffectProcessor(audio_segment, effect).apply_effect()
-            modified_audio = Modulator().normalize(modified_audio)
+            modified_audio = AudioModulator().normalize(modified_audio)
             output_file = os.path.join(
                 output_dir, f"{effect}_{os.path.basename(input_file)}"
             )
             modified_audio.export(output_file, format="wav")
             Clogger.info(f"Modified audio saved as: {output_file}")
 
             if visualize:
-                visualize_audio_wave(input_file, output_file)
+                audiowave_visualizer(input_file, output_file)
 
         except Exception as e:
             Clogger.error(f"Error processing audio file {input_file}: {e}")

audiobot/modulator.py renamed to audiobot/core/audio/core.py

@@ -4,7 +4,7 @@
 RESET = rs
 
 
-class CustomFormatter(logging.Formatter):
+class LoggingFormatter(logging.Formatter):
     COLORS = {
         logging.DEBUG: fg.BBLUE_FG,
         logging.INFO: fg.GREEN_FG,
@@ -19,7 +19,7 @@ def format(self, record):
         return f"{log_color}{log_message}{RESET}"
 
 
-def setup_colored_logger(logger_name="colored_logger") -> logging.Logger:
+def colored_logger(logger_name="colored_logger") -> logging.Logger:
     """
     Sets up a colored logger with a single handler.
 
@@ -30,7 +30,7 @@ def setup_colored_logger(logger_name="colored_logger") -> logging.Logger:
 
     if not logger.handlers:  # Check if handlers already exist
         handler = logging.StreamHandler()
-        handler.setFormatter(CustomFormatter("- %(levelname)s - %(message)s"))
+        handler.setFormatter(LoggingFormatter("- %(levelname)s - %(message)s"))
         logger.addHandler(handler)
         logger.setLevel(logging.INFO)