venSpeakerPy 0.1.0__py3-none-any.whl

venSpeakerPy/__init__.py

@@ -0,0 +1,3 @@
+import lib_speak
+import lib_helper
+import lib_sl_text

venSpeakerPy/__main__.py

@@ -0,0 +1,99 @@
+import argparse
+import pathlib
+
+from .lib_helper import settings_selero
+
+
+def main(args):
+    from .lib_speak import Speaker
+
+    sample_rate = (
+        args.sample_rate
+        if args.sample_rate
+        else settings_selero[args.language]["sample_rate"]
+    )
+
+    sp = Speaker(**settings_selero[args.language]["sp"])
+
+    file = pathlib.Path(args.file)
+    text = file.read_text()
+
+    if args.type_out == "speak":
+        sp.speak(text, sample_rate=sample_rate, speed=args.speed)
+    elif args.type_out == "mp3":
+        sp.to_mp3(
+            text=text,
+            name_text=args.name_text if args.name_text else file.name,
+            sample_rate=sample_rate,
+            audio_dir=args.audio_dir / "mp3",
+            speed=args.speed,
+        )
+    else:
+        raise KeyError("Не указано - Каким образом вывести сентезированный текст")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="🎙️ SpeakerPy: CLI для синтеза речи с использованием SpeakerPy 🎙️",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="Примеры использования:\n"
+        "  python -m speakerpy -l ru -t speak -f ./books/example.txt;\n"
+        "  python -m speakerpy -l ru -t mp3 -f ./books/example.txt;\n"
+        "  python -m speakerpy -l en -t speak -f ./books/example.txt;\n"
+        "  python -m speakerpy -l en -t mp3 -f ./books/example.txt;\n",
+    )
+    y = "\033[33m"
+    r = "\033[0m"
+    parser.add_argument(
+        "-l",
+        "--language",
+        choices=list(settings_selero.keys()),
+        required=True,
+        help=f"{y}Язык синтеза (ru | en){r}",
+    )
+    parser.add_argument(
+        "-f",
+        "--file",
+        type=str,
+        required=True,
+        help=f"{y}Путь к файлу с текстом для озвучивания{r}",
+    )
+    parser.add_argument(
+        "-t",
+        "--type_out",
+        choices=["mp3", "speak"],
+        required=True,
+        help=f"{y}Каким образом вывести синтезированный текст (mp3 | speak){r}",
+    )
+    parser.add_argument(
+        "-sr",
+        "--sample_rate",
+        type=int,
+        default=48000,
+        help=f"{y}Частота дискретизации (по умолчанию: 48000){r}",
+    )
+    parser.add_argument(
+        "-s",
+        "--speed",
+        type=float,
+        default=1.0,
+        help=f"{y}Скорость чтения (по умолчанию: 1.0){r}",
+    )
+    parser.add_argument(
+        "-n",
+        "--name_text",
+        type=str,
+        default="",
+        help=f"{y}Имя для текста, с таким именем сохранится итоговый mp3 файл (по умолчанию: имя файла с текстом){r}",
+    )
+    parser.add_argument(
+        "-a",
+        "--audio_dir",
+        type=str,
+        default=pathlib.Path(__file__).parent.parent,
+        help=f"{y}Папка для сохранения готовых аудио файлов (по умолчанию: текущая папка){r}",
+    )
+
+    args = parser.parse_args()
+
+    main(args)

venSpeakerPy/lib_helper.py

@@ -0,0 +1,16 @@
+from time import process_time
+
+
+def timeit(func):
+    """Декоратор замера времени выполнения функции"""
+
+    def wrapper(*args, **kwargs):
+        start_time = process_time()
+        result = func(*args, **kwargs)
+        end_time = process_time()
+        print(
+            f"Время выполнения функции '{func.__name__}': {end_time - start_time} секунд"
+        )
+        return result
+
+    return wrapper

venSpeakerPy/lib_sl_text.py

@@ -0,0 +1,138 @@
+import os
+import pathlib
+import re
+from string import punctuation, whitespace
+from typing import Generator, Literal
+
+import nltk
+from num2words import num2words
+from transliterate import translit
+
+nltk.download("punkt")
+nltk.download("punkt_tab")
+
+
+def nltk_remove_other_model_but_russian(directory: str | pathlib.Path):
+    """Удалить все языки кроме русского
+
+    directory: Путь к директории в которой искать файлы
+    """
+
+    extension = ".pickle"  # замените на нужное расширение
+
+    # обходим все файлы в указанной директории
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            # если файл имеет нужное расширение, выводим его путь
+            if file.endswith(extension) and not file.startswith("russian"):
+                abs_path = os.path.join(root, file)
+                os.remove(abs_path)
+
+
+class SeleroText:
+    """
+    Класс для хранения, и удобного использования текста,
+    который вы хотите синтезировать в голос
+    """
+
+    #: Флаг, который используется для чтения модели nltk единожды
+    IF_INIT = False
+    #: Путь для хранения моделей nltk
+    download_dir = pathlib.Path(__file__).parent.parent / "models/nltk_store"
+    ###
+    #
+    #: Максимальное количество сиголов в куске текста. Если больше, то это уже новый кусок
+    _max_chunk_symbols = 1000
+    #: Символы которые нужно исключать
+    exclude_characters = whitespace + punctuation
+
+    def __init__(self, text: str, to_language: Literal["ru"]) -> None:
+        """Преобразовать текст в подходящий формат."""
+        self.text = text
+        self.to_language = to_language
+        ###
+        #
+        # Инициализация моделей nltk
+        #
+        if not self.IF_INIT:
+            os.makedirs(self.download_dir, exist_ok=True)
+            # nltk.download(
+            #     "punkt",
+            #     download_dir=self.download_dir,
+            # )
+            if self.to_language in ("ru"):
+                # Удалить все модели языки кроме русского языка
+                nltk_remove_other_model_but_russian(self.download_dir)
+            self.IF_INIT = True
+        #
+        self._normal()
+
+    def chunk(self) -> Generator[str, None, None]:
+        """Поделить текст на куски"""
+
+        # 3. Разделения по предложениям
+        for t in self._punkt(self.text):
+            if t:
+                # 4. Разделения длинных предложений
+                for t2 in self._split_long_string(t, self._max_chunk_symbols):
+                    # В тексте должны быть буквы
+                    if re.search(r"\w", t2):
+                        yield t2
+
+    ##########################
+    #
+    #
+    def _normal(self) -> str:
+        """Преобразовать текст в подходящий формат для синтеза
+
+        to_language: В какой язык сделать тралит
+        """
+        # 1. Транскрипция иностранного языка
+        if self.to_language in ("ru"):
+            self.text = translit(self.text, self.to_language)
+        # 2. Текстовое описание цифр
+        self.text = self._nums_to_text()
+
+    def _transcription(self) -> str:
+        """Транскрипция иностранного языка (Типа hello->хелоо)"""
+        self.text = translit(self.text, self.to_language)
+
+    def _nums_to_text(self) -> str:
+        """Преобразует числа в буквы: 1 -> один, 23 -> двадцать три"""
+        return re.sub(
+            r"(\d+)",
+            lambda x: num2words(int(x.group(0)), lang=self.to_language),
+            self.text,
+        )
+
+    @staticmethod
+    def _punkt(text: str) -> Generator[str, None, None]:
+        """Разделения по предложениям"""
+        for t in nltk.sent_tokenize(text, language="russian"):
+            # Оставляем в строке только буквы, цифры и знаки пунктуации.
+            yield re.sub(r"[^a-zA-Zа-яА-Я0-9.,!?;:\-\–\'\"\s]", "", t)
+
+    @staticmethod
+    def _split_long_string(text: str, slice_length: int) -> Generator[str, None, None]:
+        """Поделить текст на части.
+
+        :param text: Текст
+        :param slice_length: Через сколько символов делить строку
+        """
+        words = text.split()
+        current_slice = []
+        current_length = 0
+        for word in words:
+            # Добавляем текущее слово к текущей "кусочной" строке,
+            # если она еще не началась или длина слова и пробела не превышает slice_length.
+            if not current_slice or current_length + len(word) + 1 <= slice_length:
+                current_slice.append(word)
+                current_length += len(word) + 1
+            else:
+                # Иначе, если текущая "кусочная" строка уже достаточно длинная,
+                # то добавляем ее в результат и начинаем новую "кусочную" строку с текущего слова.
+                yield " ".join(current_slice)
+                current_slice = [word]
+                current_length = len(word)
+        # Добавляем последнюю "кусочную" строку в результат.
+        yield " ".join(current_slice)

venSpeakerPy/lib_speak.py

@@ -0,0 +1,251 @@
+import pathlib
+import threading
+import time
+from typing import Generator, Literal
+from scipy.signal import resample_poly
+
+import sounddevice
+import soundfile
+import torch
+from silero import silero_tts
+import numpy as np
+
+from lib_helper import timeit
+from lib_sl_text import SeleroText
+
+
+class SpeakerBase:
+    #: Для синхронизации потоков озвучки текста
+    _th_lock_speak = threading.Lock()
+
+    def __init__(
+            self,
+            model_id,
+            language: Literal["ru", "en"],
+            speaker: Literal["aidar", "baya", "kseniya", "xenia", "random"],
+            device="cpu",
+            ) -> None:
+        self.language = language
+        self.model_id = model_id
+        # Модель
+        self.model = self._init_models(
+            model_id=model_id,
+            language=language,
+            device=device,
+            )
+        # Голос
+        self.speaker = speaker
+
+    @staticmethod
+    def _init_models(
+            model_id: str,
+            language: Literal["ru"] = "ru",
+            device: Literal[
+                "cpu",
+                "cuda",
+                "ipu",
+                "xpu",
+                "mkldnn",
+                "opengl",
+                "opencl",
+                "ideep",
+                "hip",
+                "ve",
+                "fpga",
+                "ort",
+                "xla",
+                "lazy",
+                "vulkan",
+                "mps",
+            ] = "cpu",
+            ):
+        """
+        Инициализация ИИ модели
+
+        model_id: Доступные модели https://github.com/snakers4/silero-models/blob/master/models.yml (четверку тут использовать не получится)
+        """
+        _device = torch.device(device)
+        _model, *_any = silero_tts(language=language, speaker=model_id, device=_device)
+        return _model
+
+    def _synthesize_text(
+            self, text: str, sample_rate: int, put_accent: bool = True, put_yo: bool = True
+            ) -> torch.Tensor:
+        """Синтезировать текст"""
+        audio: torch.Tensor = self.model.apply_tts(
+            text=text,
+            speaker=self.speaker,
+            sample_rate=sample_rate,
+            put_accent=put_accent,
+            put_yo=put_yo,
+            )
+        return audio
+
+    def _speak(
+            self,
+            th_name: int,
+            text: str,
+            audio: torch.Tensor,
+            sample_rate: int,
+            speed: float = 1.0,
+            ):
+        """Озвучить текст
+
+        :param audio: Аудио
+        :param sample_rate: Частота
+        :param speed: Скорость воспроизведения [от 1.0 до 2.0]
+        """
+        _speed = sample_rate * speed
+        # Блокировка потока. Может говорить только один поток
+        with self._th_lock_speak:
+            # print(f"Th: {th_name}\t| {text}")
+            sounddevice.play(audio, samplerate=_speed)
+            time.sleep((len(audio) / _speed + 0.02))
+            sounddevice.stop()
+
+
+class Speaker(SpeakerBase):
+    def speak(
+            self,
+            text: str,
+            sample_rate: int,
+            speed: float = 1.0,
+            *,
+            volume: float = 1.0,
+            put_accent: bool = True,
+            put_yo: bool = False,
+            normalize: bool = False,
+            limiting: bool = False,
+            ) -> Generator[tuple[bytes, str], None, None]:
+        """
+        Генерация и озвучка текста с поддержкой тегов <long:x:duration>
+
+        :param text: Текст для озвучки (поддерживает <long:буква:время>)
+        :param sample_rate: Частота дискретизации
+        :param speed: Скорость воспроизведения
+        :param volume: Громкость (0.0 - 2.0)
+        :param put_accent: Автоматическая постановка ударения
+        :param put_yo: Автоматическая постановка буквы ё
+        :param normalize: Нормализация звука (вряд ли вообще понадобится, но пусть будет)
+        :param limiting: Ограничение звука (вряд ли вообще понадобится, но пусть будет)
+        :return: Чанки аудио в формате bytes
+        """
+        if not (0.0 <= volume <= 2.0):
+            raise ValueError("Параметр volume должен быть в диапазоне от 0.0 до 2.0")
+        sl_text = SeleroText(text, to_language=self.language)
+
+        # Генерация чанков с выводом байтов по мере готовности
+        chunks = list(sl_text.chunk())
+        for i, _chunk_text in enumerate(chunks):
+            audio: torch.Tensor = self._synthesize_text(
+                _chunk_text,
+                sample_rate=sample_rate,
+                put_accent=put_accent,
+                put_yo=put_yo,
+                )
+            scaled_audio = (audio.numpy() / 5 * volume).astype(np.float32)
+
+            adjusted_audio = resample_poly(scaled_audio, up=100, down=int(100 * speed)) if speed != 1 else scaled_audio
+
+            normal = self.normalize(adjusted_audio) if normalize else adjusted_audio
+            limited = self.limiter(normal) if limiting else normal
+
+            if len(limited) > 0:
+                yield adjusted_audio.tobytes(), _chunk_text
+
+                # Если это последний чанк — добавим тишину
+            if i == len(chunks) - 1:
+                silence = np.zeros(int(sample_rate * 0.15), dtype=np.float32)  # 150 мс тишины
+                yield silence.tobytes(), ""
+
+    @timeit
+    def to_wav(
+            self,
+            text: str,
+            name_text: str,
+            sample_rate: int,
+            audio_dir: pathlib.Path | str,
+            speed: float = 1.0,
+            volume: float = 1.0,
+            put_accent=True
+            ) -> pathlib.Path:
+        """
+        Синтезировать и сохранить звук в WAV файл
+
+        :param text: Текст
+        :param name_text: Имя текста (используется в имени файла)
+        :param sample_rate: Частота дискретизации
+        :param audio_dir: Куда сохранить файл
+        :param speed: Скорость речи
+        :param volume: Громкость
+        :return: Путь к сохраненному WAV-файлу
+        """
+        name_text = name_text.replace(" ", "_")
+        audio_dir = pathlib.Path(audio_dir)
+        audio_dir.mkdir(parents=True, exist_ok=True)
+
+        output_file = audio_dir / (
+                name_text
+                + ".wav"
+        )
+
+        if output_file.exists():
+            print("Cache___Wav: 0 \t| ", output_file)
+            return output_file
+
+        full_audio = b''.join(self.speak(text=text, sample_rate=sample_rate, speed=speed, volume=volume, put_accent=put_accent, put_yo=True))
+
+        # Сохраняем как WAV
+        with soundfile.SoundFile(output_file, 'w', samplerate=sample_rate, channels=1, subtype='PCM_16') as f:
+            audio_array = np.frombuffer(full_audio, dtype=np.float32)
+            f.write(audio_array)
+
+        print("Build___Wav: 0 \t| ", output_file)
+        return output_file
+
+    def normalize(self, audio, target=0.95):
+        peak = np.max(np.abs(audio))
+        if peak > 0:
+            audio = audio / peak * target
+        return audio
+
+    def limiter(self, audio, threshold=0.9):
+        audio = np.clip(audio, -threshold, threshold)
+        return audio / threshold
+
+
+if __name__ == '__main__':
+    import sounddevice as sd
+    import queue
+
+    audio_queue = queue.Queue()
+
+
+    def audio_player():
+        try:
+            with sd.OutputStream(samplerate=48000, channels=1, dtype='float32') as stream:
+                while True:
+                    speech_chunk = audio_queue.get()
+                    if speech_chunk is None:
+                        break
+                    audio_array = np.frombuffer(speech_chunk, dtype=np.float32)
+                    stream.write(audio_array)
+        except KeyboardInterrupt:
+            print("Stop speaker")
+        finally:
+            sd.stop()
+
+
+    player_thread = threading.Thread(target=audio_player, daemon=True)
+    player_thread.start()
+    speaker = Speaker(model_id="ru_v3", language="ru", speaker="baya", device="cpu")
+    while True:
+        text = input('Text: ')
+        text = text.replace('ё', 'е')
+
+        if text.startswith('!w '):
+            text = text.replace('!w ', '')
+            speaker.to_wav(text=text.text, sample_rate=48000, speed=1.1, volume=0.7, name_text='output', audio_dir='output')
+        else:
+            for chunk, text in speaker.speak(text=text.text, sample_rate=48000, speed=1.1, volume=0.7):
+                audio_queue.put(chunk)

venspeakerpy-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: venSpeakerPy
+Version: 0.1.0
+Summary: Python TTS package using Silero models for Russian language
+Home-page: https://github.com/VenalusDev/ven-speaker-py
+Author: VenalusDev
+Author-email: Venalusdev@mail.ru
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy<2.0,>=1.10
+Requires-Dist: sounddevice>=0.4.7
+Requires-Dist: soundfile>=0.12.1
+Requires-Dist: torch<3.0,>=2.1
+Requires-Dist: nltk<4.0,>=3.9
+Requires-Dist: num2words<0.6,>=0.5
+Requires-Dist: transliterate>=1.10.2
+Requires-Dist: silero>=0.4
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ven-speaker-py
+
+**Форк библиотеки `speakerpy` с модификациями и улучшениями для потоковой работы с аудио и TTS.**
+
+![logo](https://raw.githubusercontent.com/denisxab/speakerpy/main/docs/source/_static/logo315x318.png)
+
+
+## 🔹 Описание
+
+ven-speaker-py — это Python-библиотека для синтеза речи с модификациями:
+
+- Потоковая передача аудио в байтовом виде.
+- Исправленная функция ~to_mp3~->`to_wav`.
+- Поддержка гибкой настройки скорости, громкости и sample rate.
+- Постепенно добавляются новые функции и улучшения под конкретные задачи.
+
+Библиотека подходит для создания голосовых приложений, озвучивания текста в реальном времени и интеграции с другими проектами.
+
+
+## Особенности и преимущества SpeakerPy
+
+- **Транскрипция чисел и английских слов**: SpeakerPy способен озвучивать числа и английские слова через транскрипцию.
+- **Синтез больших объемов текста**: SpeakerPy может синтезировать большие объемы текста без проблем.
+- **Корректное деление текста на куски**: благодаря использованию библиотеки nltk, SpeakerPy корректно делит большие тексты на предложения.
+- **Кеширование синтезированного текста**: SpeakerPy синтезирует и хранит текст по кускам, что позволяет кешировать уже ранее синтезированный текст и избежать повторного синтезирования. После первой генерации все последующие обычно занимают менее четверти секунды (имеется в виду не полная генерация, а момент, когда начинает зачитываться речь) на обычном процессоре!
+- **Работа в автономном режиме**: SpeakerPy синтезирует звук локально, без подключения к интернету, что позволяет использовать его в автономном режиме.
+- **Сохранение синтезированного текста в MP3**: SpeakerPy предоставляет возможность сохранять синтезированный текст в формате MP3.
+
+## ⚙️ Установка через pip
+
+`ven-speaker-py` можно установить с помощью pip:
+
+```bash
+pip install venspeakerpy
+```
+
+## 🛠️ Основные возможности
+
+- **Преобразование текста в речь.**
+- **Потоковая генерация аудио чанков.**
+- **Поддержка сохранения в различные форматы, включая mp3.**
+- **Настройка скорости, громкости и sample rate.**
+- **Интеграция в голосовые боты и приложения реального времени.**
+
+### 🚀 Системные требования
+
+- 2 ГБ ОЗУ
+- Наличие процессора :D
+
+## 💡 Основные компоненты
+
+Проект состоит из двух основных компонентов: Lib Speak и Lib SL Text.
+
+### Lib Speak
+
+Lib Speak включает классы `Speaker` и `SpeakerBase` для синтеза речи с использованием моделей Silero. Основные методы класса `Speaker`:
+
+1. `speak`: ~~произнесение текста.~~ Теперь это потоковая передача звука в байтах, что позволяет использовать звук где-то еще (например, для трансляции в Discord)
+2. `to_wav`: конвертация текста в аудиофайл wav.
+
+#### 📄 Пример использования функции speak
+
+```python
+from lib_speak import Speaker
+from lib_sl_text import SeleroText
+import sounddevice as sd
+import queue
+import threading
+import numpy as np
+
+speaker = Speaker(model_id="ru_v3", language="ru", speaker="baya", device="cpu")
+
+def text_to_speech(txt: str):
+    audio_queue = queue.Queue()
+
+    def audio_player():
+        with sd.OutputStream(samplerate=48000, channels=1, dtype='float32') as stream:
+            while True:
+                speech_chunk = audio_queue.get()
+                if speech_chunk is None:
+                    break
+                audio_array = np.frombuffer(speech_chunk, dtype=np.float32)
+                stream.write(audio_array)
+
+    player_thread = threading.Thread(target=audio_player, daemon=True)
+    player_thread.start()
+
+    for chunk, text in speaker.speak(text=text.text, sample_rate=48000, speed=1.1, volume=0.7):
+        audio_queue.put(chunk)
+
+    audio_queue.put(None)
+    player_thread.join()
+
+text = SeleroText("Пример текста для синтеза речи")
+text_to_speech(text)
+
+#p.s. я не проверял этот код, просто куски из своего проекта сюда напихал в надежде, что у вас заработает, так что удачи.
+
+```
+
+#### Пример использования функции to_wav
+
+```python
+from lib_speak import Speaker
+
+text = SeleroText("Пример текста для синтеза речи")
+speaker = Speaker(model_id="ru_v3", language="ru", speaker="aidar", device="cpu")
+speaker.to_wav(text=text.text, sample_rate=48000, speed=1.0, volume=1.0, name_text='output', audio_dir='output')
+```
+
+### Lib SL Text
+
+Lib SL Text содержит класс `SeleroText` для обработки текста перед синтезом речи. Основной метод класса `SeleroText`:
+
+1. `chunk`: разделение текста на блоки.
+
+#### Использование класса SeleroText
+
+```python
+text = SeleroText("Привет, мир!", to_language="ru")
+```
+
+Разделение текста на куски с помощью метода `chunk()`:
+
+```python
+for chunk in text.chunk():
+    print(chunk)
+```
+
+## Ресурсы и ссылки
+
+- <a href="https://github.com/snakers4/silero-models/blob/master/models.yml" target="_new">Silero Models на GitHub</a>
+- <a href="https://www.sphinx-doc.org/" target="_new">Sphinx</a>
+- <a href="https://github.com/readthedocs/sphinx_rtd_theme" target="_new">Sphinx RTD Theme</a>
+- <a href="https://readthedocs.org/" target="_new">Read the Docs</a>

venspeakerpy-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+venSpeakerPy/__init__.py,sha256=4mVo6EsL_AqkHIiJNvHAPafPbvmLWMiFlQXizNkusSs,55
+venSpeakerPy/__main__.py,sha256=jdd_SruDTASmB_3yYVUgee9-KQPLtetx0J8lChLCnFE,3319
+venSpeakerPy/lib_helper.py,sha256=JZo9zuRc57X-UhWxieTw9fy0P57opWHjqJV8aPHlqms,472
+venSpeakerPy/lib_sl_text.py,sha256=afQ4iBYzWBQYSjHmmfApeyWUzig9x7x9F4OhfIYDshE,6026
+venSpeakerPy/lib_speak.py,sha256=VwD8No_bnE8nnH1O6PC9OuFiXUvaj9IPplsOZJEQUeQ,9080
+venspeakerpy-0.1.0.dist-info/licenses/LICENSE,sha256=KhpHAy226In6QqqMvi2X6H3ZAFum2Tc0KK2PI-Bu9Rk,1088
+venspeakerpy-0.1.0.dist-info/METADATA,sha256=8qMgVr5TrVetwJO_AXRKRJit9CKev0O3GxeWCi6y3TA,8177
+venspeakerpy-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+venspeakerpy-0.1.0.dist-info/top_level.txt,sha256=aHqh6je2O9RLUo4Z7rIdpAR516r0asGToNwoZr5MbIE,13
+venspeakerpy-0.1.0.dist-info/RECORD,,

venspeakerpy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

venspeakerpy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 VenalusDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

venspeakerpy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+venSpeakerPy