speechjenerator 0.1.0__tar.gz

speechjenerator-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: speechjenerator
+Version: 0.1.0
+Summary: It does TTS.
+Author: Warren Davies
+Requires-Python: >=3.10,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: basejenerator (>=0.2.0,<0.3.0)
+Requires-Dist: gtts (>=2.5.4,<3.0.0)
+Requires-Dist: kokoro (>=0.9.4,<0.10.0)
+Requires-Dist: sounddevice (>=0.5.5,<0.6.0)
+Requires-Dist: soundfile (>=0.13.1,<0.14.0)
+Description-Content-Type: text/markdown
+
+# model-registry-template
+A template for projects that require the ability to select from multiple models.
+

speechjenerator-0.1.0/README.md

@@ -0,0 +1,2 @@
+# model-registry-template
+A template for projects that require the ability to select from multiple models.

speechjenerator-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "speechjenerator"
+version = "0.1.0"
+description = "It does TTS."
+authors = [{ name = "Warren Davies"}]
+readme = "README.md"
+homepage = "https://github.com/WarrenDavies/speechjenerator"
+repository = "https://github.com/WarrenDavies/speechjenerator"
+packages = [
+    { include = "speechjenerator", from = "src" }
+]
+requires-python = ">=3.10,<3.13"
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.13"
+basejenerator = "^0.2.0"
+gtts = "^2.5.4"
+sounddevice = "^0.5.5"
+soundfile = "^0.13.1"
+kokoro = "^0.9.4"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

speechjenerator-0.1.0/src/speechjenerator/__init__.py

@@ -0,0 +1,5 @@
+import pkgutil
+import importlib
+
+for _, name, _ in pkgutil.walk_packages(__path__, __name__ + "."):
+    importlib.import_module(name)

speechjenerator-0.1.0/src/speechjenerator/artifacts/gtts_artifact.py

@@ -0,0 +1,72 @@
+import os
+import platform
+import subprocess
+
+import sounddevice as sd
+import soundfile as sf
+
+from basejenerator.artifacts.base_artifact import BaseArtifact
+
+class GTTSArtifact(BaseArtifact):
+    """
+    Holds a gTTS "model" object. This is more like a promise to create an audio file.
+    Due to how gTTS works, the Google Translate API is not called until `.save()`
+    is called.
+
+    Attributes:
+        data (str): The gTTS "model" object.
+        item_extras (dict): any additional metadata related to this artifact
+    """
+
+    def __init__(self, data, item_extras):
+        self.data = data 
+        self.item_extras = item_extras
+        self.extension = ".mp3"
+        self.system = platform.system()
+        self.linux_mp3_players = [
+            ["mpg123", "--quiet"],
+            ["mpv", "--no-terminal"],
+        ]
+        self.player_funcs = {
+            "Windows": self._play_on_windows,
+            "Darwin": self._play_on_mac,
+            "Linux": self._play_on_linux
+        }
+
+    def save(self, path):
+        """
+        Called Google Translate API, gets the audio as WAV, and saves to disk.
+        """
+        self.data.save(path)
+
+
+    def _play_on_windows(self, path):
+        os.startfile(path)
+
+    def _play_on_mac(self, path):
+        subprocess.run(['afplay', path])
+
+    def _play_on_linux(self, path):
+        for player_command in self.linux_mp3_players:
+            player_command.append(path)
+            try:
+                subprocess.run(player_command, check=True)
+                break
+            except FileNotFoundError:
+                continue
+
+    def play(self, path=None):
+        """
+        Calls Google Translate API, gets the audio as mp3, saves to disk,
+        and plays the audio on the system in which speechjenerator is running
+        using .
+        """
+        if not path:
+            path = self.data["config"]["path"]
+        self.save(path)
+
+        mp3_player = self.player_funcs[self.system]
+        try:
+            mp3_player(path)
+        except Exception as e:
+            print(f"Error playing audio: {e}")

speechjenerator-0.1.0/src/speechjenerator/artifacts/registry.py

@@ -0,0 +1,52 @@
+"""
+Implements a simple decorator-based model registry for dynamically managing
+different artifact classes.
+
+This system allows concrete subclasses to register themselves
+using a specific string key, enabling the application to instantiate the 
+correct class based on a configuration setting without explicit imports.
+"""
+
+ARTIFACT_REGISTRY = {}
+
+def register_model(name):
+    """
+    A decorator factory used to register a subclass.
+
+    The decorated class is stored in the global ARTIFACT_REGISTRY dictionary
+    under the provided `name`.
+
+    Args:
+        name (str): The string key used to reference the model class
+                    in the configuration.
+
+    Returns:
+        Callable: A decorator function that takes a class and registers it.
+    """
+    def decorator(cls):
+        ARTIFACT_REGISTRY[name] = cls
+        return cls
+    return decorator
+
+
+def get_class(artifact_name):
+    """
+    Retrieves and instantiates the correct class based on the
+    configuration dictionary.
+
+    It looks up the class in ARTIFACT_REGISTRY using `artifact_name`.
+
+    Args:
+        artifact_name: Must correspond to a registered artifact name.
+
+    Returns:
+        An instantiated object of the registered class.
+
+    Raises:
+        KeyError: If the value of `artifact_name` is not found in the
+                  ARTIFACT_REGISTRY.
+    """
+    Class_ = ARTIFACT_REGISTRY[artifact_name]
+    artifact = Class_()
+
+    return model_object

speechjenerator-0.1.0/src/speechjenerator/artifacts/wav_artifact.py

@@ -0,0 +1,76 @@
+import os
+import platform
+import subprocess
+import datetime
+import soundfile as sf
+
+from basejenerator.artifacts.base_artifact import BaseArtifact
+
+
+class WavArtifact(BaseArtifact):
+    """
+    
+    Attributes:
+        data (str): The gTTS "model" object.
+        item_extras (dict): any additional metadata related to this artifact
+    """
+
+    def __init__(self, data, item_extras):
+        self.data = data 
+        self.item_extras = item_extras
+        self.extension = ".wav"
+        self.system = platform.system()
+        self.linux_players = [
+            ["mpv", "--no-terminal"],
+            ["mpg123", "--quiet"],
+
+        ]
+        self.player_funcs = {
+            "Windows": self._play_on_windows,
+            "Darwin": self._play_on_mac,
+            "Linux": self._play_on_linux
+        }
+
+
+    def save(self, path):
+        """
+        """
+        if "chunk_index" in self.item_extras:
+            extension = f"_{str(self.item_extras['chunk_index'])}{self.extension}"
+        else:
+            extension = self.extension
+
+        self.path = f'{path}{extension}'
+        sf.write(self.path, self.data.data, 24000)
+
+
+    def _play_on_windows(self, path):
+        os.startfile(path)
+
+
+    def _play_on_mac(self, path):
+        subprocess.run(['afplay', path])
+
+
+    def _play_on_linux(self, path):
+        for player_command in self.linux_players:
+            player_command.append(path)
+            try:
+                subprocess.run(player_command, check=True)
+                break
+            except FileNotFoundError:
+                continue
+
+
+    def play(self, path=None):
+        """
+        """
+        if not path:
+            path = self.data["config"]["path"]
+        self.save(path)
+
+        player = self.player_funcs[self.system]
+        try:
+            player(self.path)
+        except Exception as e:
+            print(f"Error playing audio: {e}")

speechjenerator-0.1.0/src/speechjenerator/core/base_class_record.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass, fields, field
+import csv
+import os
+from typing import List
+
+@dataclass
+class BaseClassRecord():
+    """
+    A data container for tracking and saving inference metadata.
+
+    This class serves as a structured record for a single inference event.
+    It includes functionality to serialize its own data to a CSV file, handling
+    formatting (e.g., float precision) and file management (creation vs. appending).
+
+    Attributes:
+        gen_data_file_path (str): Path to the CSV file where records are saved.
+        filename (str): Name of the generated file.
+        timestamp (str): Timestamp of generation.
+        model (str): Name of the model used.
+        device (str): Compute device used (e.g., 'cuda', 'cpu').
+        dtype (str): Data type used (e.g., 'float16').
+        total_generation_time (float): Total time taken
+        rating (float): Placeholder for user rating (defaults to -1).
+        fields_to_not_save (list[str]): Internal list of field names to exclude from the CSV.
+    """
+    gen_data_file_path: str = ""
+    filename: str = ""
+    timestamp: str = ""
+    model: str = ""
+    device: str = ""
+    dtype: str = ""
+    total_generation_time: float = 0
+    rating: float = -1
+    fields_to_not_save: list[str] = field(default_factory=list)
+
+
+    def __post_init__(self):
+        """
+        Post-initialization hook to define excluded fields.
+
+        Populates `fields_to_not_save` with technical fields that should not
+        appear in the final CSV report (e.g., file paths or the exclusion list itself).
+        """
+        self.fields_to_not_save += ["gen_data_file_path", "fields_to_not_save", "path_to_csv"]
+
+
+    def create_data_row(self):
+        """
+        Constructs a list of values for the CSV row based on current attributes.
+
+        Iterates through the dataclass fields, filtering out those in `fields_to_not_save`.
+        Floats are formatted to 2 decimal places.
+
+        Returns:
+            list: A list of values corresponding to the CSV columns.
+        """
+        row = []
+        for field in fields(self):
+            if field.name in self.fields_to_not_save:
+                continue
+            field_value = getattr(self, field.name)
+
+            if isinstance(field_value, float):
+                row.append(f"{field_value:.2f}")
+            else:
+                row.append(field_value)
+        return row
+
+
+    def append_data_to_csv(self):
+        """
+        Appends the current record to the CSV file.
+
+        Opens the file at `gen_data_file_path` in append mode and writes
+        the data row generated by `create_data_row()`.
+        """
+        with open(self.gen_data_file_path, "a", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(self.create_data_row())
+
+
+    def create_header_row(self):
+        """
+        Generates the CSV header row based on field names.
+
+        Returns:
+            list[str]: A list of column names, excluding those in `fields_to_not_save`.
+        """
+        headers = []
+        for header in fields(self):
+            if header.name in self.fields_to_not_save:
+                continue
+            headers.append(header.name)
+        return headers
+
+
+    def create_new_stats_file(self):
+        """
+        Creates a new CSV file and writes the header row.
+
+        Uses 'x' mode to open the file, which ensures a new file is created
+        and raises an error if the file already exists (though `save_data()` guards against this).
+        """
+        with open(self.gen_data_file_path, "x", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(self.create_header_row())
+
+
+    def save_data(self):
+        """
+        Saves the record of the generation stats to disk.
+
+        Checks if the target CSV file exists:
+        - If no: Creates the file and writes headers.
+        - If yes: Appends the current data row.
+        """
+        if not os.path.exists(self.gen_data_file_path):
+            self.create_new_stats_file()
+
+        self.append_data_to_csv()
+        

speechjenerator-0.1.0/src/speechjenerator/core/base_speech_generator.py

@@ -0,0 +1,114 @@
+from abc import ABC, abstractmethod
+import datetime
+import time
+import os
+import random
+import torch
+import gc
+
+from basejenerator.base_generator import BaseGenerator
+
+
+class BaseSpeechGenerator(BaseGenerator):
+    """
+    Abstract base class for TTS.
+
+    This class handles... 
+    
+    Subclasses must implement create_pipeline() and run_pipeline()
+
+    Attributes:
+        config (dict): Configuration dictionary containing model parameters, paths, and settings.
+    """
+
+    def __init__(self, config):
+        """
+        Initializes the object with a config.
+
+        Args:
+            config (dict): A dictionary containing configuration parameters.
+                Expected keys include:
+                - 
+        """
+        self.config = config
+        self.device = self.set_device()
+ 
+
+    def set_device(self):
+        """
+        Sets the computation device based on CUDA availability.
+
+        Sets `self.device` to 'cuda' if available, otherwise defaults to 'cpu'.
+        """
+        if "device" in self.config:
+            return self.config["device"]
+
+        if torch.cuda.is_available():
+            return "cuda"
+        else:
+            return "cpu"
+
+
+    @abstractmethod
+    def load(self):
+        """
+        Abstract method to initialize the model pipeline.
+        
+        Subclasses must implement this to load the specific model and tokenizer/pipeline object, assigning it to self.pipe (e.g., a Hugging Face Pipeline object).
+        """
+        pass
+
+
+    @abstractmethod
+    def prepare(self):
+        """
+        Reset lifecycle without tearing down the model - e.g., clear cache, etc.
+        """
+        pass
+
+
+    @abstractmethod
+    def warmup(self):
+        """
+        Initial inference run to create cache etc., mainly for benchmarking.
+        """
+        pass
+
+
+    def generate(self):
+        """
+        The public API that runs inference.
+
+        Returns:
+            GeneratorOutput
+        """
+        return self.generate_impl()
+
+
+    @abstractmethod
+    def generate_impl(self):
+        """
+        The public API that runs inference.
+
+        Returns:
+            GeneratorOutput        
+        """
+        pass
+
+
+    def teardown(self):
+        """
+        Deletes the pipeline, empties the torch cache, and forces Python's garbage collector to run. Clears the slate to create
+        another pipeline.
+        """
+        if self.model is None:
+            print("No pipeline found. You cannot teardown that which was not created.")
+            return
+
+        del self.model
+        self.model = None
+
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        gc.collect()

speechjenerator-0.1.0/src/speechjenerator/examples/gtts_example.py

@@ -0,0 +1,17 @@
+from speechjenerator import registry
+
+output_path = "./outputs/test.wav"
+config = {
+    "model": "gtts",
+
+    "text": "Hazlo o no lo hagas. Intentar no existe.",
+    "lang": "es"
+
+}
+
+speech_generator = registry.get_model_class(config)
+speech_generator.load()
+print(speech_generator.config)
+output = speech_generator.generate()
+speech = output.batch[0]
+speech.play(output_path)

speechjenerator-0.1.0/src/speechjenerator/examples/kokoro_example.py

@@ -0,0 +1,26 @@
+from speechjenerator import registry
+import datetime
+
+
+output_path = "./outputs/"
+config = {
+    "model": "kokoro",
+    "text": """Do, or do not. There is no try.""",
+    "lang": "a",
+    "voice": "af_heart",
+}
+
+
+filename_stem = datetime.datetime.now().strftime(format="%Y-%m-%d_%H-%M-%s")
+speech_generator = registry.get_model_class(config)
+print("loading model...")
+speech_generator.load()
+print("warmup run...")
+speech_generator.warmup()
+print("running inference...")
+output = speech_generator.generate()
+for chunk in output.batch:
+    chunk.play(output_path + filename_stem)
+print("tearing down...")    
+speech_generator.teardown()
+print("done!")

speechjenerator-0.1.0/src/speechjenerator/local/__init__.py

@@ -0,0 +1,6 @@
+# import pkgutil
+# import importlib
+
+# for module in pkgutil.iter_modules(__path__):
+#     importlib.import_module(f"{__name__}.{module.name}")
+    

speechjenerator-0.1.0/src/speechjenerator/local/kokoro.py

@@ -0,0 +1,88 @@
+import time
+import datetime 
+
+from kokoro import KPipeline
+
+from basejenerator.generator_output import GeneratorOutput
+
+from speechjenerator.artifacts.wav_artifact import WavArtifact
+from speechjenerator.registry import register_model
+from speechjenerator.core.base_speech_generator import BaseSpeechGenerator
+
+@register_model("kokoro")
+class Kokoro(BaseSpeechGenerator):
+    """
+    Concrete implementation of BaseClass for Kokoro.
+
+    """
+
+    def __init__(self, config):
+        """
+        Initializes the generator.
+
+        Args:
+            config (dict): Configuration dictionary. Must include standard BaseClass
+                           keys plus model-specific keys.
+        """
+        super().__init__(config)
+        self.model = None
+
+
+    def load(self):
+        """
+        Loads Kokoro pipeline.
+        """
+        pipeline = KPipeline(
+            lang_code=self.config["lang"],
+            device=self.device,
+        )
+
+        self.model = pipeline
+
+
+    def prepare(self):
+        """
+        """
+        pass
+
+    
+    def warmup(self):
+        self.generate_impl({
+            "text": "Do or do not. There is no try."
+        })
+
+
+    def generate_impl(self, config = None):
+        """
+        """
+        inf_config = self.config.copy()
+        if config:
+            inf_config.update(config)
+
+        artifacts = []
+        for i, (gs, ps, audio) in enumerate(
+            self.model(
+                text=inf_config["text"], 
+                voice=inf_config["voice"]
+            )
+        ):
+            artifacts.append(
+                WavArtifact(
+                    data=audio,
+                    item_extras={
+                        "text": gs,
+                        "phonemes": ps,
+                        "chunk_index": i
+                    }
+                )
+            )
+    
+        return GeneratorOutput(artifacts)
+
+
+    def get_params_schema(self):
+        class ParamsSchema(BaseModel):
+            text: str = ""
+            lang: str = ""
+
+        return ParamsSchema

speechjenerator-0.1.0/src/speechjenerator/registry.py

@@ -0,0 +1,54 @@
+"""
+Implements a simple decorator-based model registry for dynamically managing
+different model classes.
+
+This system allows concrete subclasses to register themselves
+using a specific string key, enabling the application to instantiate the 
+correct class based on a configuration setting without explicit imports.
+"""
+
+MODEL_REGISTRY = {}
+
+def register_model(name):
+    """
+    A decorator factory used to register a subclass.
+
+    The decorated class is stored in the global MODEL_REGISTRY dictionary
+    under the provided `name`.
+
+    Args:
+        name (str): The string key used to reference the model class
+                    in the configuration.
+
+    Returns:
+        Callable: A decorator function that takes a class and registers it.
+    """
+    def decorator(cls):
+        MODEL_REGISTRY[name] = cls
+        return cls
+    return decorator
+
+
+def get_model_class(config):
+    """
+    Retrieves and instantiates the correct class based on the
+    configuration dictionary.
+
+    It looks up the class in MODEL_REGISTRY using the key found in
+    `config['model']`.
+
+    Args:
+        config (dict): The configuration dictionary, which must contain a
+                       'model' key corresponding to a registered model name.
+
+    Returns:
+        BaseClass: An instantiated object of the registered generator class.
+
+    Raises:
+        KeyError: If the value of `config['model']` is not found in the
+                  MODEL_REGISTRY.
+    """
+    ModelClass = MODEL_REGISTRY[config["model"]]
+    model_object = ModelClass(config)
+
+    return model_object

speechjenerator-0.1.0/src/speechjenerator/remote/__init__.py

@@ -0,0 +1,6 @@
+# import pkgutil
+# import importlib
+
+# for module in pkgutil.iter_modules(__path__):
+#     importlib.import_module(f"{__name__}.{module.name}")
+    

speechjenerator-0.1.0/src/speechjenerator/remote/gtts.py

@@ -0,0 +1,80 @@
+import time
+import datetime 
+
+from gtts import gTTS
+
+from basejenerator.generator_output import GeneratorOutput
+
+from speechjenerator.artifacts.gtts_artifact import GTTSArtifact
+from speechjenerator.registry import register_model
+from speechjenerator.core.base_speech_generator import BaseSpeechGenerator
+
+
+@register_model("gtts")
+class GTTS(BaseSpeechGenerator):
+    """
+    Concrete implementation of BaseClass for gTTS.
+
+    """
+
+    def __init__(self, config):
+        """
+        Initializes the gTTS generator.
+
+        Args:
+            config (dict): Configuration dictionary. Must include standard BaseClass
+                           keys plus model-specific keys.
+        """
+        super().__init__(config)
+
+
+    def load(self):
+        """
+        No-op - gTTS uses a remote API (Google Translate).
+        """
+        pass
+
+
+    def prepare(self):
+        """
+        No-op - gTTS uses a remote API (Google Translate).
+        """
+        pass
+
+
+    def warmup(self):
+        """
+        No-op - gTTS uses a remote API (Google Translate).
+        """
+        pass
+
+
+    def generate_impl(self, text=None, lang=None):
+        """
+        """
+        if not text:
+            text = self.config["text"]
+
+        if not lang:
+            lang = self.config["lang"]
+
+        gtts_obj = gTTS(text=text, lang=lang)
+
+        artifacts = self._quick_wrap([gtts_obj], [{}], GTTSArtifact)
+
+        return GeneratorOutput(artifacts)
+
+
+    def teardown(self):
+        """
+        No-op - gTTS uses a remote API (Google Translate).
+        """
+        pass
+
+
+    def get_params_schema(self):
+        class ParamsSchema(BaseModel):
+            text: str = ""
+            lang: str = ""
+
+        return ParamsSchema