diff --git a/TTS/Kokoro/.venv/Lib/site-packages/__pycache__/_soundfile.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/__pycache__/_soundfile.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e40b9610def323e1b2d0969f929098b68925fe65 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/__pycache__/_soundfile.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/addict/__pycache__/addict.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/addict/__pycache__/addict.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..400ca8b535146231410306e80cbc95adfa9e26b6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/addict/__pycache__/addict.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/annotated_doc-0.0.4.dist-info/licenses/LICENSE b/TTS/Kokoro/.venv/Lib/site-packages/annotated_doc-0.0.4.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..7a254464cc78ccea32b3ded00513c44c4e4da412 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/annotated_doc-0.0.4.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2025 Sebastián Ramírez + +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. diff --git a/TTS/Kokoro/.venv/Lib/site-packages/annotated_doc/__pycache__/__init__.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/annotated_doc/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffeaeb55ea9e5aa88fb4cf55929280a3c4ede32a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/annotated_doc/__pycache__/__init__.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/annotated_doc/__pycache__/main.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/annotated_doc/__pycache__/main.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a03e0ddb823da95831cb7ef9468654f14681a12 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/annotated_doc/__pycache__/main.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/annotated_types-0.7.0.dist-info/licenses/LICENSE b/TTS/Kokoro/.venv/Lib/site-packages/annotated_types-0.7.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d99323a9965f146d5b0888c4ca1bf0727e12b04f --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/annotated_types-0.7.0.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2022 the contributors + +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. diff --git a/TTS/Kokoro/.venv/Lib/site-packages/annotated_types/__pycache__/__init__.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/annotated_types/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a43cfc69ab41836dba54b31dc54a9ebdb7bb5fed Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/annotated_types/__pycache__/__init__.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/annotated_types/__pycache__/test_cases.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/annotated_types/__pycache__/test_cases.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a3aa1dfb59143dd34a388fd96c8abee9d41dcdc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/annotated_types/__pycache__/test_cases.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio-4.12.1.dist-info/licenses/LICENSE b/TTS/Kokoro/.venv/Lib/site-packages/anyio-4.12.1.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..104eebf5a3002fccdaceef3a4cb936173c1c2035 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio-4.12.1.dist-info/licenses/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2018 Alex Grönholm + +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. diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/__init__.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6a8a59890da226b0820a92ba7039daa8034f85b4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/__init__.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/from_thread.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/from_thread.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6dd61864b5296d5ae4e5474249ab0e63713015e1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/from_thread.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/functools.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/functools.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25d41a1a940411f12652b90c80db3fc07ca34ca4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/functools.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/lowlevel.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/lowlevel.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd157a7f3e2bdb65e9707f34f161a2fd52085344 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/lowlevel.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/pytest_plugin.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/pytest_plugin.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2432f6a98358907b3f0550413aa8f86425d0d80a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/pytest_plugin.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/to_interpreter.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/to_interpreter.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2ff04fd296107c7d0d1c96b7b29bb3180de585d2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/to_interpreter.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/to_process.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/to_process.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7661265d3c02e04912e31d276d2a5592720af87a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/to_process.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/to_thread.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/to_thread.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e26af8d7f3780327dc6bbaee8c16ee2320882fa7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/__pycache__/to_thread.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/__init__.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/__pycache__/__init__.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..104dccb4aeaad0b55185b5dd1ead3304518b1bc5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/__pycache__/__init__.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/__pycache__/_trio.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/__pycache__/_trio.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..867d898913d482b94e76dc9d34f2947376c5c131 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/__pycache__/_trio.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/_asyncio.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/_asyncio.py new file mode 100644 index 0000000000000000000000000000000000000000..8ff009e2699a3731e9b42e3318b87ef72f90900c --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/_asyncio.py @@ -0,0 +1,2980 @@ +from __future__ import annotations + +import array +import asyncio +import concurrent.futures +import contextvars +import math +import os +import socket +import sys +import threading +import weakref +from asyncio import ( + AbstractEventLoop, + CancelledError, + all_tasks, + create_task, + current_task, + get_running_loop, + sleep, +) +from asyncio.base_events import _run_until_complete_cb # type: ignore[attr-defined] +from collections import OrderedDict, deque +from collections.abc import ( + AsyncGenerator, + AsyncIterator, + Awaitable, + Callable, + Collection, + Coroutine, + Iterable, + Sequence, +) +from concurrent.futures import Future +from contextlib import AbstractContextManager, suppress +from contextvars import Context, copy_context +from dataclasses import dataclass, field +from functools import partial, wraps +from inspect import ( + CORO_RUNNING, + CORO_SUSPENDED, + getcoroutinestate, + iscoroutine, +) +from io import IOBase +from os import PathLike +from queue import Queue +from signal import Signals +from socket import AddressFamily, SocketKind +from threading import Thread +from types import CodeType, TracebackType +from typing import ( + IO, + TYPE_CHECKING, + Any, + Optional, + TypeVar, + cast, +) +from weakref import WeakKeyDictionary + +from .. import ( + CapacityLimiterStatistics, + EventStatistics, + LockStatistics, + TaskInfo, + abc, +) +from .._core._eventloop import ( + claim_worker_thread, + set_current_async_library, + threadlocals, +) +from .._core._exceptions import ( + BrokenResourceError, + BusyResourceError, + ClosedResourceError, + EndOfStream, + RunFinishedError, + WouldBlock, + iterate_exceptions, +) +from .._core._sockets import convert_ipv6_sockaddr +from .._core._streams import create_memory_object_stream +from .._core._synchronization import ( + CapacityLimiter as BaseCapacityLimiter, +) +from .._core._synchronization import Event as BaseEvent +from .._core._synchronization import Lock as BaseLock +from .._core._synchronization import ( + ResourceGuard, + SemaphoreStatistics, +) +from .._core._synchronization import Semaphore as BaseSemaphore +from .._core._tasks import CancelScope as BaseCancelScope +from ..abc import ( + AsyncBackend, + IPSockAddrType, + SocketListener, + UDPPacketType, + UNIXDatagramPacketType, +) +from ..abc._eventloop import StrOrBytesPath +from ..lowlevel import RunVar +from ..streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike +else: + FileDescriptorLike = object + +if sys.version_info >= (3, 10): + from typing import ParamSpec +else: + from typing_extensions import ParamSpec + +if sys.version_info >= (3, 11): + from asyncio import Runner + from typing import TypeVarTuple, Unpack +else: + import contextvars + import enum + import signal + from asyncio import coroutines, events, exceptions, tasks + + from exceptiongroup import BaseExceptionGroup + from typing_extensions import TypeVarTuple, Unpack + + class _State(enum.Enum): + CREATED = "created" + INITIALIZED = "initialized" + CLOSED = "closed" + + class Runner: + # Copied from CPython 3.11 + def __init__( + self, + *, + debug: bool | None = None, + loop_factory: Callable[[], AbstractEventLoop] | None = None, + ): + self._state = _State.CREATED + self._debug = debug + self._loop_factory = loop_factory + self._loop: AbstractEventLoop | None = None + self._context = None + self._interrupt_count = 0 + self._set_event_loop = False + + def __enter__(self) -> Runner: + self._lazy_init() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.close() + + def close(self) -> None: + """Shutdown and close event loop.""" + loop = self._loop + if self._state is not _State.INITIALIZED or loop is None: + return + try: + _cancel_all_tasks(loop) + loop.run_until_complete(loop.shutdown_asyncgens()) + if hasattr(loop, "shutdown_default_executor"): + loop.run_until_complete(loop.shutdown_default_executor()) + else: + loop.run_until_complete(_shutdown_default_executor(loop)) + finally: + if self._set_event_loop: + events.set_event_loop(None) + loop.close() + self._loop = None + self._state = _State.CLOSED + + def get_loop(self) -> AbstractEventLoop: + """Return embedded event loop.""" + self._lazy_init() + return self._loop + + def run(self, coro: Coroutine[T_Retval], *, context=None) -> T_Retval: + """Run a coroutine inside the embedded event loop.""" + if not coroutines.iscoroutine(coro): + raise ValueError(f"a coroutine was expected, got {coro!r}") + + if events._get_running_loop() is not None: + # fail fast with short traceback + raise RuntimeError( + "Runner.run() cannot be called from a running event loop" + ) + + self._lazy_init() + + if context is None: + context = self._context + task = context.run(self._loop.create_task, coro) + + if ( + threading.current_thread() is threading.main_thread() + and signal.getsignal(signal.SIGINT) is signal.default_int_handler + ): + sigint_handler = partial(self._on_sigint, main_task=task) + try: + signal.signal(signal.SIGINT, sigint_handler) + except ValueError: + # `signal.signal` may throw if `threading.main_thread` does + # not support signals (e.g. embedded interpreter with signals + # not registered - see gh-91880) + sigint_handler = None + else: + sigint_handler = None + + self._interrupt_count = 0 + try: + return self._loop.run_until_complete(task) + except exceptions.CancelledError: + if self._interrupt_count > 0: + uncancel = getattr(task, "uncancel", None) + if uncancel is not None and uncancel() == 0: + raise KeyboardInterrupt # noqa: B904 + raise # CancelledError + finally: + if ( + sigint_handler is not None + and signal.getsignal(signal.SIGINT) is sigint_handler + ): + signal.signal(signal.SIGINT, signal.default_int_handler) + + def _lazy_init(self) -> None: + if self._state is _State.CLOSED: + raise RuntimeError("Runner is closed") + if self._state is _State.INITIALIZED: + return + if self._loop_factory is None: + self._loop = events.new_event_loop() + if not self._set_event_loop: + # Call set_event_loop only once to avoid calling + # attach_loop multiple times on child watchers + events.set_event_loop(self._loop) + self._set_event_loop = True + else: + self._loop = self._loop_factory() + if self._debug is not None: + self._loop.set_debug(self._debug) + self._context = contextvars.copy_context() + self._state = _State.INITIALIZED + + def _on_sigint(self, signum, frame, main_task: asyncio.Task) -> None: + self._interrupt_count += 1 + if self._interrupt_count == 1 and not main_task.done(): + main_task.cancel() + # wakeup loop if it is blocked by select() with long timeout + self._loop.call_soon_threadsafe(lambda: None) + return + raise KeyboardInterrupt() + + def _cancel_all_tasks(loop: AbstractEventLoop) -> None: + to_cancel = tasks.all_tasks(loop) + if not to_cancel: + return + + for task in to_cancel: + task.cancel() + + loop.run_until_complete(tasks.gather(*to_cancel, return_exceptions=True)) + + for task in to_cancel: + if task.cancelled(): + continue + if task.exception() is not None: + loop.call_exception_handler( + { + "message": "unhandled exception during asyncio.run() shutdown", + "exception": task.exception(), + "task": task, + } + ) + + async def _shutdown_default_executor(loop: AbstractEventLoop) -> None: + """Schedule the shutdown of the default executor.""" + + def _do_shutdown(future: asyncio.futures.Future) -> None: + try: + loop._default_executor.shutdown(wait=True) # type: ignore[attr-defined] + loop.call_soon_threadsafe(future.set_result, None) + except Exception as ex: + loop.call_soon_threadsafe(future.set_exception, ex) + + loop._executor_shutdown_called = True + if loop._default_executor is None: + return + future = loop.create_future() + thread = threading.Thread(target=_do_shutdown, args=(future,)) + thread.start() + try: + await future + finally: + thread.join() + + +T_Retval = TypeVar("T_Retval") +T_contra = TypeVar("T_contra", contravariant=True) +PosArgsT = TypeVarTuple("PosArgsT") +P = ParamSpec("P") + +_root_task: RunVar[asyncio.Task | None] = RunVar("_root_task") + + +def find_root_task() -> asyncio.Task: + root_task = _root_task.get(None) + if root_task is not None and not root_task.done(): + return root_task + + # Look for a task that has been started via run_until_complete() + for task in all_tasks(): + if task._callbacks and not task.done(): + callbacks = [cb for cb, context in task._callbacks] + for cb in callbacks: + if ( + cb is _run_until_complete_cb + or getattr(cb, "__module__", None) == "uvloop.loop" + ): + _root_task.set(task) + return task + + # Look up the topmost task in the AnyIO task tree, if possible + task = cast(asyncio.Task, current_task()) + state = _task_states.get(task) + if state: + cancel_scope = state.cancel_scope + while cancel_scope and cancel_scope._parent_scope is not None: + cancel_scope = cancel_scope._parent_scope + + if cancel_scope is not None: + return cast(asyncio.Task, cancel_scope._host_task) + + return task + + +def get_callable_name(func: Callable) -> str: + module = getattr(func, "__module__", None) + qualname = getattr(func, "__qualname__", None) + return ".".join([x for x in (module, qualname) if x]) + + +# +# Event loop +# + +_run_vars: WeakKeyDictionary[asyncio.AbstractEventLoop, Any] = WeakKeyDictionary() + + +def _task_started(task: asyncio.Task) -> bool: + """Return ``True`` if the task has been started and has not finished.""" + # The task coro should never be None here, as we never add finished tasks to the + # task list + coro = task.get_coro() + assert coro is not None + try: + return getcoroutinestate(coro) in (CORO_RUNNING, CORO_SUSPENDED) + except AttributeError: + # task coro is async_genenerator_asend https://bugs.python.org/issue37771 + raise Exception(f"Cannot determine if task {task} has started or not") from None + + +# +# Timeouts and cancellation +# + + +def is_anyio_cancellation(exc: CancelledError) -> bool: + # Sometimes third party frameworks catch a CancelledError and raise a new one, so as + # a workaround we have to look at the previous ones in __context__ too for a + # matching cancel message + while True: + if ( + exc.args + and isinstance(exc.args[0], str) + and exc.args[0].startswith("Cancelled via cancel scope ") + ): + return True + + if isinstance(exc.__context__, CancelledError): + exc = exc.__context__ + continue + + return False + + +class CancelScope(BaseCancelScope): + def __new__( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> CancelScope: + return object.__new__(cls) + + def __init__(self, deadline: float = math.inf, shield: bool = False): + self._deadline = deadline + self._shield = shield + self._parent_scope: CancelScope | None = None + self._child_scopes: set[CancelScope] = set() + self._cancel_called = False + self._cancel_reason: str | None = None + self._cancelled_caught = False + self._active = False + self._timeout_handle: asyncio.TimerHandle | None = None + self._cancel_handle: asyncio.Handle | None = None + self._tasks: set[asyncio.Task] = set() + self._host_task: asyncio.Task | None = None + if sys.version_info >= (3, 11): + self._pending_uncancellations: int | None = 0 + else: + self._pending_uncancellations = None + + def __enter__(self) -> CancelScope: + if self._active: + raise RuntimeError( + "Each CancelScope may only be used for a single 'with' block" + ) + + self._host_task = host_task = cast(asyncio.Task, current_task()) + self._tasks.add(host_task) + try: + task_state = _task_states[host_task] + except KeyError: + task_state = TaskState(None, self) + _task_states[host_task] = task_state + else: + self._parent_scope = task_state.cancel_scope + task_state.cancel_scope = self + if self._parent_scope is not None: + # If using an eager task factory, the parent scope may not even contain + # the host task + self._parent_scope._child_scopes.add(self) + self._parent_scope._tasks.discard(host_task) + + self._timeout() + self._active = True + + # Start cancelling the host task if the scope was cancelled before entering + if self._cancel_called: + self._deliver_cancellation(self) + + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + del exc_tb + + if not self._active: + raise RuntimeError("This cancel scope is not active") + if current_task() is not self._host_task: + raise RuntimeError( + "Attempted to exit cancel scope in a different task than it was " + "entered in" + ) + + assert self._host_task is not None + host_task_state = _task_states.get(self._host_task) + if host_task_state is None or host_task_state.cancel_scope is not self: + raise RuntimeError( + "Attempted to exit a cancel scope that isn't the current tasks's " + "current cancel scope" + ) + + try: + self._active = False + if self._timeout_handle: + self._timeout_handle.cancel() + self._timeout_handle = None + + self._tasks.remove(self._host_task) + if self._parent_scope is not None: + self._parent_scope._child_scopes.remove(self) + self._parent_scope._tasks.add(self._host_task) + + host_task_state.cancel_scope = self._parent_scope + + # Restart the cancellation effort in the closest visible, cancelled parent + # scope if necessary + self._restart_cancellation_in_parent() + + # We only swallow the exception iff it was an AnyIO CancelledError, either + # directly as exc_val or inside an exception group and there are no cancelled + # parent cancel scopes visible to us here + if self._cancel_called and not self._parent_cancellation_is_visible_to_us: + # For each level-cancel() call made on the host task, call uncancel() + while self._pending_uncancellations: + self._host_task.uncancel() + self._pending_uncancellations -= 1 + + # Update cancelled_caught and check for exceptions we must not swallow + cannot_swallow_exc_val = False + if exc_val is not None: + for exc in iterate_exceptions(exc_val): + if isinstance(exc, CancelledError) and is_anyio_cancellation( + exc + ): + self._cancelled_caught = True + else: + cannot_swallow_exc_val = True + + return self._cancelled_caught and not cannot_swallow_exc_val + else: + if self._pending_uncancellations: + assert self._parent_scope is not None + assert self._parent_scope._pending_uncancellations is not None + self._parent_scope._pending_uncancellations += ( + self._pending_uncancellations + ) + self._pending_uncancellations = 0 + + return False + finally: + self._host_task = None + del exc_val + + @property + def _effectively_cancelled(self) -> bool: + cancel_scope: CancelScope | None = self + while cancel_scope is not None: + if cancel_scope._cancel_called: + return True + + if cancel_scope.shield: + return False + + cancel_scope = cancel_scope._parent_scope + + return False + + @property + def _parent_cancellation_is_visible_to_us(self) -> bool: + return ( + self._parent_scope is not None + and not self.shield + and self._parent_scope._effectively_cancelled + ) + + def _timeout(self) -> None: + if self._deadline != math.inf: + loop = get_running_loop() + if loop.time() >= self._deadline: + self.cancel("deadline exceeded") + else: + self._timeout_handle = loop.call_at(self._deadline, self._timeout) + + def _deliver_cancellation(self, origin: CancelScope) -> bool: + """ + Deliver cancellation to directly contained tasks and nested cancel scopes. + + Schedule another run at the end if we still have tasks eligible for + cancellation. + + :param origin: the cancel scope that originated the cancellation + :return: ``True`` if the delivery needs to be retried on the next cycle + + """ + should_retry = False + current = current_task() + for task in self._tasks: + should_retry = True + if task._must_cancel: # type: ignore[attr-defined] + continue + + # The task is eligible for cancellation if it has started + if task is not current and (task is self._host_task or _task_started(task)): + waiter = task._fut_waiter # type: ignore[attr-defined] + if not isinstance(waiter, asyncio.Future) or not waiter.done(): + task.cancel(origin._cancel_reason) + if ( + task is origin._host_task + and origin._pending_uncancellations is not None + ): + origin._pending_uncancellations += 1 + + # Deliver cancellation to child scopes that aren't shielded or running their own + # cancellation callbacks + for scope in self._child_scopes: + if not scope._shield and not scope.cancel_called: + should_retry = scope._deliver_cancellation(origin) or should_retry + + # Schedule another callback if there are still tasks left + if origin is self: + if should_retry: + self._cancel_handle = get_running_loop().call_soon( + self._deliver_cancellation, origin + ) + else: + self._cancel_handle = None + + return should_retry + + def _restart_cancellation_in_parent(self) -> None: + """ + Restart the cancellation effort in the closest directly cancelled parent scope. + + """ + scope = self._parent_scope + while scope is not None: + if scope._cancel_called: + if scope._cancel_handle is None: + scope._deliver_cancellation(scope) + + break + + # No point in looking beyond any shielded scope + if scope._shield: + break + + scope = scope._parent_scope + + def cancel(self, reason: str | None = None) -> None: + if not self._cancel_called: + if self._timeout_handle: + self._timeout_handle.cancel() + self._timeout_handle = None + + self._cancel_called = True + self._cancel_reason = f"Cancelled via cancel scope {id(self):x}" + if task := current_task(): + self._cancel_reason += f" by {task}" + + if reason: + self._cancel_reason += f"; reason: {reason}" + + if self._host_task is not None: + self._deliver_cancellation(self) + + @property + def deadline(self) -> float: + return self._deadline + + @deadline.setter + def deadline(self, value: float) -> None: + self._deadline = float(value) + if self._timeout_handle is not None: + self._timeout_handle.cancel() + self._timeout_handle = None + + if self._active and not self._cancel_called: + self._timeout() + + @property + def cancel_called(self) -> bool: + return self._cancel_called + + @property + def cancelled_caught(self) -> bool: + return self._cancelled_caught + + @property + def shield(self) -> bool: + return self._shield + + @shield.setter + def shield(self, value: bool) -> None: + if self._shield != value: + self._shield = value + if not value: + self._restart_cancellation_in_parent() + + +# +# Task states +# + + +class TaskState: + """ + Encapsulates auxiliary task information that cannot be added to the Task instance + itself because there are no guarantees about its implementation. + """ + + __slots__ = "parent_id", "cancel_scope", "__weakref__" + + def __init__(self, parent_id: int | None, cancel_scope: CancelScope | None): + self.parent_id = parent_id + self.cancel_scope = cancel_scope + + +_task_states: WeakKeyDictionary[asyncio.Task, TaskState] = WeakKeyDictionary() + + +# +# Task groups +# + + +class _AsyncioTaskStatus(abc.TaskStatus): + def __init__(self, future: asyncio.Future, parent_id: int): + self._future = future + self._parent_id = parent_id + + def started(self, value: T_contra | None = None) -> None: + try: + self._future.set_result(value) + except asyncio.InvalidStateError: + if not self._future.cancelled(): + raise RuntimeError( + "called 'started' twice on the same task status" + ) from None + + task = cast(asyncio.Task, current_task()) + _task_states[task].parent_id = self._parent_id + + +if sys.version_info >= (3, 12): + _eager_task_factory_code: CodeType | None = asyncio.eager_task_factory.__code__ +else: + _eager_task_factory_code = None + + +class TaskGroup(abc.TaskGroup): + def __init__(self) -> None: + self.cancel_scope: CancelScope = CancelScope() + self._active = False + self._exceptions: list[BaseException] = [] + self._tasks: set[asyncio.Task] = set() + self._on_completed_fut: asyncio.Future[None] | None = None + + async def __aenter__(self) -> TaskGroup: + self.cancel_scope.__enter__() + self._active = True + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + try: + if exc_val is not None: + self.cancel_scope.cancel() + if not isinstance(exc_val, CancelledError): + self._exceptions.append(exc_val) + + loop = get_running_loop() + try: + if self._tasks: + with CancelScope() as wait_scope: + while self._tasks: + self._on_completed_fut = loop.create_future() + + try: + await self._on_completed_fut + except CancelledError as exc: + # Shield the scope against further cancellation attempts, + # as they're not productive (#695) + wait_scope.shield = True + self.cancel_scope.cancel() + + # Set exc_val from the cancellation exception if it was + # previously unset. However, we should not replace a native + # cancellation exception with one raise by a cancel scope. + if exc_val is None or ( + isinstance(exc_val, CancelledError) + and not is_anyio_cancellation(exc) + ): + exc_val = exc + + self._on_completed_fut = None + else: + # If there are no child tasks to wait on, run at least one checkpoint + # anyway + await AsyncIOBackend.cancel_shielded_checkpoint() + + self._active = False + if self._exceptions: + # The exception that got us here should already have been + # added to self._exceptions so it's ok to break exception + # chaining and avoid adding a "During handling of above..." + # for each nesting level. + raise BaseExceptionGroup( + "unhandled errors in a TaskGroup", self._exceptions + ) from None + elif exc_val: + raise exc_val + except BaseException as exc: + if self.cancel_scope.__exit__(type(exc), exc, exc.__traceback__): + return True + + raise + + return self.cancel_scope.__exit__(exc_type, exc_val, exc_tb) + finally: + del exc_val, exc_tb, self._exceptions + + def _spawn( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[Any]], + args: tuple[Unpack[PosArgsT]], + name: object, + task_status_future: asyncio.Future | None = None, + ) -> asyncio.Task: + def task_done(_task: asyncio.Task) -> None: + if sys.version_info >= (3, 14) and self.cancel_scope._host_task is not None: + asyncio.future_discard_from_awaited_by( + _task, self.cancel_scope._host_task + ) + + task_state = _task_states[_task] + assert task_state.cancel_scope is not None + assert _task in task_state.cancel_scope._tasks + task_state.cancel_scope._tasks.remove(_task) + self._tasks.remove(task) + del _task_states[_task] + + if self._on_completed_fut is not None and not self._tasks: + try: + self._on_completed_fut.set_result(None) + except asyncio.InvalidStateError: + pass + + try: + exc = _task.exception() + except CancelledError as e: + while isinstance(e.__context__, CancelledError): + e = e.__context__ + + exc = e + + if exc is not None: + # The future can only be in the cancelled state if the host task was + # cancelled, so return immediately instead of adding one more + # CancelledError to the exceptions list + if task_status_future is not None and task_status_future.cancelled(): + return + + if task_status_future is None or task_status_future.done(): + if not isinstance(exc, CancelledError): + self._exceptions.append(exc) + + if not self.cancel_scope._effectively_cancelled: + self.cancel_scope.cancel() + else: + task_status_future.set_exception(exc) + elif task_status_future is not None and not task_status_future.done(): + task_status_future.set_exception( + RuntimeError("Child exited without calling task_status.started()") + ) + + if not self._active: + raise RuntimeError( + "This task group is not active; no new tasks can be started." + ) + + kwargs = {} + if task_status_future: + parent_id = id(current_task()) + kwargs["task_status"] = _AsyncioTaskStatus( + task_status_future, id(self.cancel_scope._host_task) + ) + else: + parent_id = id(self.cancel_scope._host_task) + + coro = func(*args, **kwargs) + if not iscoroutine(coro): + prefix = f"{func.__module__}." if hasattr(func, "__module__") else "" + raise TypeError( + f"Expected {prefix}{func.__qualname__}() to return a coroutine, but " + f"the return value ({coro!r}) is not a coroutine object" + ) + + name = get_callable_name(func) if name is None else str(name) + loop = asyncio.get_running_loop() + if ( + (factory := loop.get_task_factory()) + and getattr(factory, "__code__", None) is _eager_task_factory_code + and (closure := getattr(factory, "__closure__", None)) + ): + custom_task_constructor = closure[0].cell_contents + task = custom_task_constructor(coro, loop=loop, name=name) + else: + task = create_task(coro, name=name) + + # Make the spawned task inherit the task group's cancel scope + _task_states[task] = TaskState( + parent_id=parent_id, cancel_scope=self.cancel_scope + ) + self.cancel_scope._tasks.add(task) + self._tasks.add(task) + if sys.version_info >= (3, 14) and self.cancel_scope._host_task is not None: + asyncio.future_add_to_awaited_by(task, self.cancel_scope._host_task) + + task.add_done_callback(task_done) + return task + + def start_soon( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[Any]], + *args: Unpack[PosArgsT], + name: object = None, + ) -> None: + self._spawn(func, args, name) + + async def start( + self, func: Callable[..., Awaitable[Any]], *args: object, name: object = None + ) -> Any: + future: asyncio.Future = asyncio.Future() + task = self._spawn(func, args, name, future) + + # If the task raises an exception after sending a start value without a switch + # point between, the task group is cancelled and this method never proceeds to + # process the completed future. That's why we have to have a shielded cancel + # scope here. + try: + return await future + except CancelledError: + # Cancel the task and wait for it to exit before returning + task.cancel() + with CancelScope(shield=True), suppress(CancelledError): + await task + + raise + + +# +# Threads +# + +_Retval_Queue_Type = tuple[Optional[T_Retval], Optional[BaseException]] + + +class WorkerThread(Thread): + MAX_IDLE_TIME = 10 # seconds + + def __init__( + self, + root_task: asyncio.Task, + workers: set[WorkerThread], + idle_workers: deque[WorkerThread], + ): + super().__init__(name="AnyIO worker thread") + self.root_task = root_task + self.workers = workers + self.idle_workers = idle_workers + self.loop = root_task._loop + self.queue: Queue[ + tuple[Context, Callable, tuple, asyncio.Future, CancelScope] | None + ] = Queue(2) + self.idle_since = AsyncIOBackend.current_time() + self.stopping = False + + def _report_result( + self, future: asyncio.Future, result: Any, exc: BaseException | None + ) -> None: + self.idle_since = AsyncIOBackend.current_time() + if not self.stopping: + self.idle_workers.append(self) + + if not future.cancelled(): + if exc is not None: + if isinstance(exc, StopIteration): + new_exc = RuntimeError("coroutine raised StopIteration") + new_exc.__cause__ = exc + exc = new_exc + + future.set_exception(exc) + else: + future.set_result(result) + + def run(self) -> None: + with claim_worker_thread(AsyncIOBackend, self.loop): + while True: + item = self.queue.get() + if item is None: + # Shutdown command received + return + + context, func, args, future, cancel_scope = item + if not future.cancelled(): + result = None + exception: BaseException | None = None + threadlocals.current_cancel_scope = cancel_scope + try: + result = context.run(func, *args) + except BaseException as exc: + exception = exc + finally: + del threadlocals.current_cancel_scope + + if not self.loop.is_closed(): + self.loop.call_soon_threadsafe( + self._report_result, future, result, exception + ) + + del result, exception + + self.queue.task_done() + del item, context, func, args, future, cancel_scope + + def stop(self, f: asyncio.Task | None = None) -> None: + self.stopping = True + self.queue.put_nowait(None) + self.workers.discard(self) + try: + self.idle_workers.remove(self) + except ValueError: + pass + + +_threadpool_idle_workers: RunVar[deque[WorkerThread]] = RunVar( + "_threadpool_idle_workers" +) +_threadpool_workers: RunVar[set[WorkerThread]] = RunVar("_threadpool_workers") + + +# +# Subprocesses +# + + +@dataclass(eq=False) +class StreamReaderWrapper(abc.ByteReceiveStream): + _stream: asyncio.StreamReader + + async def receive(self, max_bytes: int = 65536) -> bytes: + data = await self._stream.read(max_bytes) + if data: + return data + else: + raise EndOfStream + + async def aclose(self) -> None: + self._stream.set_exception(ClosedResourceError()) + await AsyncIOBackend.checkpoint() + + +@dataclass(eq=False) +class StreamWriterWrapper(abc.ByteSendStream): + _stream: asyncio.StreamWriter + _closed: bool = field(init=False, default=False) + + async def send(self, item: bytes) -> None: + await AsyncIOBackend.checkpoint_if_cancelled() + stream_paused = self._stream._protocol._paused # type: ignore[attr-defined] + try: + self._stream.write(item) + await self._stream.drain() + except (ConnectionResetError, BrokenPipeError, RuntimeError) as exc: + # If closed by us and/or the peer: + # * on stdlib, drain() raises ConnectionResetError or BrokenPipeError + # * on uvloop and Winloop, write() eventually starts raising RuntimeError + if self._closed: + raise ClosedResourceError from exc + elif self._stream.is_closing(): + raise BrokenResourceError from exc + + raise + + if not stream_paused: + await AsyncIOBackend.cancel_shielded_checkpoint() + + async def aclose(self) -> None: + self._closed = True + self._stream.close() + await AsyncIOBackend.checkpoint() + + +@dataclass(eq=False) +class Process(abc.Process): + _process: asyncio.subprocess.Process + _stdin: StreamWriterWrapper | None + _stdout: StreamReaderWrapper | None + _stderr: StreamReaderWrapper | None + + async def aclose(self) -> None: + with CancelScope(shield=True) as scope: + if self._stdin: + await self._stdin.aclose() + if self._stdout: + await self._stdout.aclose() + if self._stderr: + await self._stderr.aclose() + + scope.shield = False + try: + await self.wait() + except BaseException: + scope.shield = True + self.kill() + await self.wait() + raise + + async def wait(self) -> int: + return await self._process.wait() + + def terminate(self) -> None: + self._process.terminate() + + def kill(self) -> None: + self._process.kill() + + def send_signal(self, signal: int) -> None: + self._process.send_signal(signal) + + @property + def pid(self) -> int: + return self._process.pid + + @property + def returncode(self) -> int | None: + return self._process.returncode + + @property + def stdin(self) -> abc.ByteSendStream | None: + return self._stdin + + @property + def stdout(self) -> abc.ByteReceiveStream | None: + return self._stdout + + @property + def stderr(self) -> abc.ByteReceiveStream | None: + return self._stderr + + +def _forcibly_shutdown_process_pool_on_exit( + workers: set[Process], _task: object +) -> None: + """ + Forcibly shuts down worker processes belonging to this event loop.""" + child_watcher: asyncio.AbstractChildWatcher | None = None # type: ignore[name-defined] + if sys.version_info < (3, 12): + try: + child_watcher = asyncio.get_event_loop_policy().get_child_watcher() + except NotImplementedError: + pass + + # Close as much as possible (w/o async/await) to avoid warnings + for process in workers.copy(): + if process.returncode is None: + continue + + process._stdin._stream._transport.close() # type: ignore[union-attr] + process._stdout._stream._transport.close() # type: ignore[union-attr] + process._stderr._stream._transport.close() # type: ignore[union-attr] + process.kill() + if child_watcher: + child_watcher.remove_child_handler(process.pid) + + +async def _shutdown_process_pool_on_exit(workers: set[abc.Process]) -> None: + """ + Shuts down worker processes belonging to this event loop. + + NOTE: this only works when the event loop was started using asyncio.run() or + anyio.run(). + + """ + process: abc.Process + try: + await sleep(math.inf) + except asyncio.CancelledError: + workers = workers.copy() + for process in workers: + if process.returncode is None: + process.kill() + + for process in workers: + await process.aclose() + + +# +# Sockets and networking +# + + +class StreamProtocol(asyncio.Protocol): + read_queue: deque[bytes] + read_event: asyncio.Event + write_event: asyncio.Event + exception: Exception | None = None + is_at_eof: bool = False + + def connection_made(self, transport: asyncio.BaseTransport) -> None: + self.read_queue = deque() + self.read_event = asyncio.Event() + self.write_event = asyncio.Event() + self.write_event.set() + cast(asyncio.Transport, transport).set_write_buffer_limits(0) + + def connection_lost(self, exc: Exception | None) -> None: + if exc: + self.exception = BrokenResourceError() + self.exception.__cause__ = exc + + self.read_event.set() + self.write_event.set() + + def data_received(self, data: bytes) -> None: + # ProactorEventloop sometimes sends bytearray instead of bytes + self.read_queue.append(bytes(data)) + self.read_event.set() + + def eof_received(self) -> bool | None: + self.is_at_eof = True + self.read_event.set() + return True + + def pause_writing(self) -> None: + self.write_event = asyncio.Event() + + def resume_writing(self) -> None: + self.write_event.set() + + +class DatagramProtocol(asyncio.DatagramProtocol): + read_queue: deque[tuple[bytes, IPSockAddrType]] + read_event: asyncio.Event + write_event: asyncio.Event + exception: Exception | None = None + + def connection_made(self, transport: asyncio.BaseTransport) -> None: + self.read_queue = deque(maxlen=100) # arbitrary value + self.read_event = asyncio.Event() + self.write_event = asyncio.Event() + self.write_event.set() + + def connection_lost(self, exc: Exception | None) -> None: + self.read_event.set() + self.write_event.set() + + def datagram_received(self, data: bytes, addr: IPSockAddrType) -> None: + addr = convert_ipv6_sockaddr(addr) + self.read_queue.append((data, addr)) + self.read_event.set() + + def error_received(self, exc: Exception) -> None: + self.exception = exc + + def pause_writing(self) -> None: + self.write_event.clear() + + def resume_writing(self) -> None: + self.write_event.set() + + +class SocketStream(abc.SocketStream): + def __init__(self, transport: asyncio.Transport, protocol: StreamProtocol): + self._transport = transport + self._protocol = protocol + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + self._closed = False + + @property + def _raw_socket(self) -> socket.socket: + return self._transport.get_extra_info("socket") + + async def receive(self, max_bytes: int = 65536) -> bytes: + with self._receive_guard: + if ( + not self._protocol.read_event.is_set() + and not self._transport.is_closing() + and not self._protocol.is_at_eof + ): + self._transport.resume_reading() + await self._protocol.read_event.wait() + self._transport.pause_reading() + else: + await AsyncIOBackend.checkpoint() + + try: + chunk = self._protocol.read_queue.popleft() + except IndexError: + if self._closed: + raise ClosedResourceError from None + elif self._protocol.exception: + raise self._protocol.exception from None + else: + raise EndOfStream from None + + if len(chunk) > max_bytes: + # Split the oversized chunk + chunk, leftover = chunk[:max_bytes], chunk[max_bytes:] + self._protocol.read_queue.appendleft(leftover) + + # If the read queue is empty, clear the flag so that the next call will + # block until data is available + if not self._protocol.read_queue: + self._protocol.read_event.clear() + + return chunk + + async def send(self, item: bytes) -> None: + with self._send_guard: + await AsyncIOBackend.checkpoint() + + if self._closed: + raise ClosedResourceError + elif self._protocol.exception is not None: + raise self._protocol.exception + + try: + self._transport.write(item) + except RuntimeError as exc: + if self._transport.is_closing(): + raise BrokenResourceError from exc + else: + raise + + await self._protocol.write_event.wait() + + async def send_eof(self) -> None: + try: + self._transport.write_eof() + except OSError: + pass + + async def aclose(self) -> None: + self._closed = True + if not self._transport.is_closing(): + try: + self._transport.write_eof() + except OSError: + pass + + self._transport.close() + await sleep(0) + self._transport.abort() + + +class _RawSocketMixin: + _receive_future: asyncio.Future | None = None + _send_future: asyncio.Future | None = None + _closing = False + + def __init__(self, raw_socket: socket.socket): + self.__raw_socket = raw_socket + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + @property + def _raw_socket(self) -> socket.socket: + return self.__raw_socket + + def _wait_until_readable(self, loop: asyncio.AbstractEventLoop) -> asyncio.Future: + def callback(f: object) -> None: + del self._receive_future + loop.remove_reader(self.__raw_socket) + + f = self._receive_future = asyncio.Future() + loop.add_reader(self.__raw_socket, f.set_result, None) + f.add_done_callback(callback) + return f + + def _wait_until_writable(self, loop: asyncio.AbstractEventLoop) -> asyncio.Future: + def callback(f: object) -> None: + del self._send_future + loop.remove_writer(self.__raw_socket) + + f = self._send_future = asyncio.Future() + loop.add_writer(self.__raw_socket, f.set_result, None) + f.add_done_callback(callback) + return f + + async def aclose(self) -> None: + if not self._closing: + self._closing = True + if self.__raw_socket.fileno() != -1: + self.__raw_socket.close() + + if self._receive_future: + self._receive_future.set_result(None) + if self._send_future: + self._send_future.set_result(None) + + +class UNIXSocketStream(_RawSocketMixin, abc.UNIXSocketStream): + async def send_eof(self) -> None: + with self._send_guard: + self._raw_socket.shutdown(socket.SHUT_WR) + + async def receive(self, max_bytes: int = 65536) -> bytes: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._receive_guard: + while True: + try: + data = self._raw_socket.recv(max_bytes) + except BlockingIOError: + await self._wait_until_readable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + if not data: + raise EndOfStream + + return data + + async def send(self, item: bytes) -> None: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._send_guard: + view = memoryview(item) + while view: + try: + bytes_sent = self._raw_socket.send(view) + except BlockingIOError: + await self._wait_until_writable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + view = view[bytes_sent:] + + async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]: + if not isinstance(msglen, int) or msglen < 0: + raise ValueError("msglen must be a non-negative integer") + if not isinstance(maxfds, int) or maxfds < 1: + raise ValueError("maxfds must be a positive integer") + + loop = get_running_loop() + fds = array.array("i") + await AsyncIOBackend.checkpoint() + with self._receive_guard: + while True: + try: + message, ancdata, flags, addr = self._raw_socket.recvmsg( + msglen, socket.CMSG_LEN(maxfds * fds.itemsize) + ) + except BlockingIOError: + await self._wait_until_readable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + if not message and not ancdata: + raise EndOfStream + + break + + for cmsg_level, cmsg_type, cmsg_data in ancdata: + if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS: + raise RuntimeError( + f"Received unexpected ancillary data; message = {message!r}, " + f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}" + ) + + fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)]) + + return message, list(fds) + + async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None: + if not message: + raise ValueError("message must not be empty") + if not fds: + raise ValueError("fds must not be empty") + + loop = get_running_loop() + filenos: list[int] = [] + for fd in fds: + if isinstance(fd, int): + filenos.append(fd) + elif isinstance(fd, IOBase): + filenos.append(fd.fileno()) + + fdarray = array.array("i", filenos) + await AsyncIOBackend.checkpoint() + with self._send_guard: + while True: + try: + # The ignore can be removed after mypy picks up + # https://github.com/python/typeshed/pull/5545 + self._raw_socket.sendmsg( + [message], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fdarray)] + ) + break + except BlockingIOError: + await self._wait_until_writable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + + +class TCPSocketListener(abc.SocketListener): + _accept_scope: CancelScope | None = None + _closed = False + + def __init__(self, raw_socket: socket.socket): + self.__raw_socket = raw_socket + self._loop = cast(asyncio.BaseEventLoop, get_running_loop()) + self._accept_guard = ResourceGuard("accepting connections from") + + @property + def _raw_socket(self) -> socket.socket: + return self.__raw_socket + + async def accept(self) -> abc.SocketStream: + if self._closed: + raise ClosedResourceError + + with self._accept_guard: + await AsyncIOBackend.checkpoint() + with CancelScope() as self._accept_scope: + try: + client_sock, _addr = await self._loop.sock_accept(self._raw_socket) + except asyncio.CancelledError: + # Workaround for https://bugs.python.org/issue41317 + try: + self._loop.remove_reader(self._raw_socket) + except (ValueError, NotImplementedError): + pass + + if self._closed: + raise ClosedResourceError from None + + raise + finally: + self._accept_scope = None + + client_sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + transport, protocol = await self._loop.connect_accepted_socket( + StreamProtocol, client_sock + ) + return SocketStream(transport, protocol) + + async def aclose(self) -> None: + if self._closed: + return + + self._closed = True + if self._accept_scope: + # Workaround for https://bugs.python.org/issue41317 + try: + self._loop.remove_reader(self._raw_socket) + except (ValueError, NotImplementedError): + pass + + self._accept_scope.cancel() + await sleep(0) + + self._raw_socket.close() + + +class UNIXSocketListener(abc.SocketListener): + def __init__(self, raw_socket: socket.socket): + self.__raw_socket = raw_socket + self._loop = get_running_loop() + self._accept_guard = ResourceGuard("accepting connections from") + self._closed = False + + async def accept(self) -> abc.SocketStream: + await AsyncIOBackend.checkpoint() + with self._accept_guard: + while True: + try: + client_sock, _ = self.__raw_socket.accept() + client_sock.setblocking(False) + return UNIXSocketStream(client_sock) + except BlockingIOError: + f: asyncio.Future = asyncio.Future() + self._loop.add_reader(self.__raw_socket, f.set_result, None) + f.add_done_callback( + lambda _: self._loop.remove_reader(self.__raw_socket) + ) + await f + except OSError as exc: + if self._closed: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + + async def aclose(self) -> None: + self._closed = True + self.__raw_socket.close() + + @property + def _raw_socket(self) -> socket.socket: + return self.__raw_socket + + +class UDPSocket(abc.UDPSocket): + def __init__( + self, transport: asyncio.DatagramTransport, protocol: DatagramProtocol + ): + self._transport = transport + self._protocol = protocol + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + self._closed = False + + @property + def _raw_socket(self) -> socket.socket: + return self._transport.get_extra_info("socket") + + async def aclose(self) -> None: + self._closed = True + if not self._transport.is_closing(): + self._transport.close() + + async def receive(self) -> tuple[bytes, IPSockAddrType]: + with self._receive_guard: + await AsyncIOBackend.checkpoint() + + # If the buffer is empty, ask for more data + if not self._protocol.read_queue and not self._transport.is_closing(): + self._protocol.read_event.clear() + await self._protocol.read_event.wait() + + try: + return self._protocol.read_queue.popleft() + except IndexError: + if self._closed: + raise ClosedResourceError from None + else: + raise BrokenResourceError from None + + async def send(self, item: UDPPacketType) -> None: + with self._send_guard: + await AsyncIOBackend.checkpoint() + await self._protocol.write_event.wait() + if self._closed: + raise ClosedResourceError + elif self._transport.is_closing(): + raise BrokenResourceError + else: + self._transport.sendto(*item) + + +class ConnectedUDPSocket(abc.ConnectedUDPSocket): + def __init__( + self, transport: asyncio.DatagramTransport, protocol: DatagramProtocol + ): + self._transport = transport + self._protocol = protocol + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + self._closed = False + + @property + def _raw_socket(self) -> socket.socket: + return self._transport.get_extra_info("socket") + + async def aclose(self) -> None: + self._closed = True + if not self._transport.is_closing(): + self._transport.close() + + async def receive(self) -> bytes: + with self._receive_guard: + await AsyncIOBackend.checkpoint() + + # If the buffer is empty, ask for more data + if not self._protocol.read_queue and not self._transport.is_closing(): + self._protocol.read_event.clear() + await self._protocol.read_event.wait() + + try: + packet = self._protocol.read_queue.popleft() + except IndexError: + if self._closed: + raise ClosedResourceError from None + else: + raise BrokenResourceError from None + + return packet[0] + + async def send(self, item: bytes) -> None: + with self._send_guard: + await AsyncIOBackend.checkpoint() + await self._protocol.write_event.wait() + if self._closed: + raise ClosedResourceError + elif self._transport.is_closing(): + raise BrokenResourceError + else: + self._transport.sendto(item) + + +class UNIXDatagramSocket(_RawSocketMixin, abc.UNIXDatagramSocket): + async def receive(self) -> UNIXDatagramPacketType: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._receive_guard: + while True: + try: + data = self._raw_socket.recvfrom(65536) + except BlockingIOError: + await self._wait_until_readable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + return data + + async def send(self, item: UNIXDatagramPacketType) -> None: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._send_guard: + while True: + try: + self._raw_socket.sendto(*item) + except BlockingIOError: + await self._wait_until_writable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + return + + +class ConnectedUNIXDatagramSocket(_RawSocketMixin, abc.ConnectedUNIXDatagramSocket): + async def receive(self) -> bytes: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._receive_guard: + while True: + try: + data = self._raw_socket.recv(65536) + except BlockingIOError: + await self._wait_until_readable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + return data + + async def send(self, item: bytes) -> None: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._send_guard: + while True: + try: + self._raw_socket.send(item) + except BlockingIOError: + await self._wait_until_writable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + return + + +_read_events: RunVar[dict[int, asyncio.Future[bool]]] = RunVar("read_events") +_write_events: RunVar[dict[int, asyncio.Future[bool]]] = RunVar("write_events") + + +# +# Synchronization +# + + +class Event(BaseEvent): + def __new__(cls) -> Event: + return object.__new__(cls) + + def __init__(self) -> None: + self._event = asyncio.Event() + + def set(self) -> None: + self._event.set() + + def is_set(self) -> bool: + return self._event.is_set() + + async def wait(self) -> None: + if self.is_set(): + await AsyncIOBackend.checkpoint() + else: + await self._event.wait() + + def statistics(self) -> EventStatistics: + return EventStatistics(len(self._event._waiters)) + + +class Lock(BaseLock): + def __new__(cls, *, fast_acquire: bool = False) -> Lock: + return object.__new__(cls) + + def __init__(self, *, fast_acquire: bool = False) -> None: + self._fast_acquire = fast_acquire + self._owner_task: asyncio.Task | None = None + self._waiters: deque[tuple[asyncio.Task, asyncio.Future]] = deque() + + async def acquire(self) -> None: + task = cast(asyncio.Task, current_task()) + if self._owner_task is None and not self._waiters: + await AsyncIOBackend.checkpoint_if_cancelled() + self._owner_task = task + + # Unless on the "fast path", yield control of the event loop so that other + # tasks can run too + if not self._fast_acquire: + try: + await AsyncIOBackend.cancel_shielded_checkpoint() + except CancelledError: + self.release() + raise + + return + + if self._owner_task == task: + raise RuntimeError("Attempted to acquire an already held Lock") + + fut: asyncio.Future[None] = asyncio.Future() + item = task, fut + self._waiters.append(item) + try: + await fut + except CancelledError: + self._waiters.remove(item) + if self._owner_task is task: + self.release() + + raise + + self._waiters.remove(item) + + def acquire_nowait(self) -> None: + task = cast(asyncio.Task, current_task()) + if self._owner_task is None and not self._waiters: + self._owner_task = task + return + + if self._owner_task is task: + raise RuntimeError("Attempted to acquire an already held Lock") + + raise WouldBlock + + def locked(self) -> bool: + return self._owner_task is not None + + def release(self) -> None: + if self._owner_task != current_task(): + raise RuntimeError("The current task is not holding this lock") + + for task, fut in self._waiters: + if not fut.cancelled(): + self._owner_task = task + fut.set_result(None) + return + + self._owner_task = None + + def statistics(self) -> LockStatistics: + task_info = AsyncIOTaskInfo(self._owner_task) if self._owner_task else None + return LockStatistics(self.locked(), task_info, len(self._waiters)) + + +class Semaphore(BaseSemaphore): + def __new__( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> Semaphore: + return object.__new__(cls) + + def __init__( + self, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ): + super().__init__(initial_value, max_value=max_value) + self._value = initial_value + self._max_value = max_value + self._fast_acquire = fast_acquire + self._waiters: deque[asyncio.Future[None]] = deque() + + async def acquire(self) -> None: + if self._value > 0 and not self._waiters: + await AsyncIOBackend.checkpoint_if_cancelled() + self._value -= 1 + + # Unless on the "fast path", yield control of the event loop so that other + # tasks can run too + if not self._fast_acquire: + try: + await AsyncIOBackend.cancel_shielded_checkpoint() + except CancelledError: + self.release() + raise + + return + + fut: asyncio.Future[None] = asyncio.Future() + self._waiters.append(fut) + try: + await fut + except CancelledError: + try: + self._waiters.remove(fut) + except ValueError: + self.release() + + raise + + def acquire_nowait(self) -> None: + if self._value == 0: + raise WouldBlock + + self._value -= 1 + + def release(self) -> None: + if self._max_value is not None and self._value == self._max_value: + raise ValueError("semaphore released too many times") + + for fut in self._waiters: + if not fut.cancelled(): + fut.set_result(None) + self._waiters.remove(fut) + return + + self._value += 1 + + @property + def value(self) -> int: + return self._value + + @property + def max_value(self) -> int | None: + return self._max_value + + def statistics(self) -> SemaphoreStatistics: + return SemaphoreStatistics(len(self._waiters)) + + +class CapacityLimiter(BaseCapacityLimiter): + _total_tokens: float = 0 + + def __new__(cls, total_tokens: float) -> CapacityLimiter: + return object.__new__(cls) + + def __init__(self, total_tokens: float): + self._borrowers: set[Any] = set() + self._wait_queue: OrderedDict[Any, asyncio.Event] = OrderedDict() + self.total_tokens = total_tokens + + async def __aenter__(self) -> None: + await self.acquire() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.release() + + @property + def total_tokens(self) -> float: + return self._total_tokens + + @total_tokens.setter + def total_tokens(self, value: float) -> None: + if not isinstance(value, int) and not math.isinf(value): + raise TypeError("total_tokens must be an int or math.inf") + + if value < 0: + raise ValueError("total_tokens must be >= 0") + + waiters_to_notify = max(value - self._total_tokens, 0) + self._total_tokens = value + + # Notify waiting tasks that they have acquired the limiter + while self._wait_queue and waiters_to_notify: + event = self._wait_queue.popitem(last=False)[1] + event.set() + waiters_to_notify -= 1 + + @property + def borrowed_tokens(self) -> int: + return len(self._borrowers) + + @property + def available_tokens(self) -> float: + return self._total_tokens - len(self._borrowers) + + def _notify_next_waiter(self) -> None: + """Notify the next task in line if this limiter has free capacity now.""" + if self._wait_queue and len(self._borrowers) < self._total_tokens: + event = self._wait_queue.popitem(last=False)[1] + event.set() + + def acquire_nowait(self) -> None: + self.acquire_on_behalf_of_nowait(current_task()) + + def acquire_on_behalf_of_nowait(self, borrower: object) -> None: + if borrower in self._borrowers: + raise RuntimeError( + "this borrower is already holding one of this CapacityLimiter's tokens" + ) + + if self._wait_queue or len(self._borrowers) >= self._total_tokens: + raise WouldBlock + + self._borrowers.add(borrower) + + async def acquire(self) -> None: + return await self.acquire_on_behalf_of(current_task()) + + async def acquire_on_behalf_of(self, borrower: object) -> None: + await AsyncIOBackend.checkpoint_if_cancelled() + try: + self.acquire_on_behalf_of_nowait(borrower) + except WouldBlock: + event = asyncio.Event() + self._wait_queue[borrower] = event + try: + await event.wait() + except BaseException: + self._wait_queue.pop(borrower, None) + if event.is_set(): + self._notify_next_waiter() + + raise + + self._borrowers.add(borrower) + else: + try: + await AsyncIOBackend.cancel_shielded_checkpoint() + except BaseException: + self.release() + raise + + def release(self) -> None: + self.release_on_behalf_of(current_task()) + + def release_on_behalf_of(self, borrower: object) -> None: + try: + self._borrowers.remove(borrower) + except KeyError: + raise RuntimeError( + "this borrower isn't holding any of this CapacityLimiter's tokens" + ) from None + + self._notify_next_waiter() + + def statistics(self) -> CapacityLimiterStatistics: + return CapacityLimiterStatistics( + self.borrowed_tokens, + self.total_tokens, + tuple(self._borrowers), + len(self._wait_queue), + ) + + +_default_thread_limiter: RunVar[CapacityLimiter] = RunVar("_default_thread_limiter") + + +# +# Operating system signals +# + + +class _SignalReceiver: + def __init__(self, signals: tuple[Signals, ...]): + self._signals = signals + self._loop = get_running_loop() + self._signal_queue: deque[Signals] = deque() + self._future: asyncio.Future = asyncio.Future() + self._handled_signals: set[Signals] = set() + + def _deliver(self, signum: Signals) -> None: + self._signal_queue.append(signum) + if not self._future.done(): + self._future.set_result(None) + + def __enter__(self) -> _SignalReceiver: + for sig in set(self._signals): + self._loop.add_signal_handler(sig, self._deliver, sig) + self._handled_signals.add(sig) + + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + for sig in self._handled_signals: + self._loop.remove_signal_handler(sig) + + def __aiter__(self) -> _SignalReceiver: + return self + + async def __anext__(self) -> Signals: + await AsyncIOBackend.checkpoint() + if not self._signal_queue: + self._future = asyncio.Future() + await self._future + + return self._signal_queue.popleft() + + +# +# Testing and debugging +# + + +class AsyncIOTaskInfo(TaskInfo): + def __init__(self, task: asyncio.Task): + task_state = _task_states.get(task) + if task_state is None: + parent_id = None + else: + parent_id = task_state.parent_id + + coro = task.get_coro() + assert coro is not None, "created TaskInfo from a completed Task" + super().__init__(id(task), parent_id, task.get_name(), coro) + self._task = weakref.ref(task) + + def has_pending_cancellation(self) -> bool: + if not (task := self._task()): + # If the task isn't around anymore, it won't have a pending cancellation + return False + + if task._must_cancel: # type: ignore[attr-defined] + return True + elif ( + isinstance(task._fut_waiter, asyncio.Future) # type: ignore[attr-defined] + and task._fut_waiter.cancelled() # type: ignore[attr-defined] + ): + return True + + if task_state := _task_states.get(task): + if cancel_scope := task_state.cancel_scope: + return cancel_scope._effectively_cancelled + + return False + + +class TestRunner(abc.TestRunner): + _send_stream: MemoryObjectSendStream[tuple[Awaitable[Any], asyncio.Future[Any]]] + + def __init__( + self, + *, + debug: bool | None = None, + use_uvloop: bool = False, + loop_factory: Callable[[], AbstractEventLoop] | None = None, + ) -> None: + if use_uvloop and loop_factory is None: + if sys.platform != "win32": + import uvloop + + loop_factory = uvloop.new_event_loop + else: + import winloop + + loop_factory = winloop.new_event_loop + + self._runner = Runner(debug=debug, loop_factory=loop_factory) + self._exceptions: list[BaseException] = [] + self._runner_task: asyncio.Task | None = None + + def __enter__(self) -> TestRunner: + self._runner.__enter__() + self.get_loop().set_exception_handler(self._exception_handler) + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self._runner.__exit__(exc_type, exc_val, exc_tb) + + def get_loop(self) -> AbstractEventLoop: + return self._runner.get_loop() + + def _exception_handler( + self, loop: asyncio.AbstractEventLoop, context: dict[str, Any] + ) -> None: + if isinstance(context.get("exception"), Exception): + self._exceptions.append(context["exception"]) + else: + loop.default_exception_handler(context) + + def _raise_async_exceptions(self) -> None: + # Re-raise any exceptions raised in asynchronous callbacks + if self._exceptions: + exceptions, self._exceptions = self._exceptions, [] + if len(exceptions) == 1: + raise exceptions[0] + elif exceptions: + raise BaseExceptionGroup( + "Multiple exceptions occurred in asynchronous callbacks", exceptions + ) + + async def _run_tests_and_fixtures( + self, + receive_stream: MemoryObjectReceiveStream[ + tuple[Awaitable[T_Retval], asyncio.Future[T_Retval]] + ], + ) -> None: + from _pytest.outcomes import OutcomeException + + with receive_stream, self._send_stream: + async for coro, future in receive_stream: + try: + retval = await coro + except CancelledError as exc: + if not future.cancelled(): + future.cancel(*exc.args) + + raise + except BaseException as exc: + if not future.cancelled(): + future.set_exception(exc) + + if not isinstance(exc, (Exception, OutcomeException)): + raise + else: + if not future.cancelled(): + future.set_result(retval) + + async def _call_in_runner_task( + self, + func: Callable[P, Awaitable[T_Retval]], + *args: P.args, + **kwargs: P.kwargs, + ) -> T_Retval: + if not self._runner_task: + self._send_stream, receive_stream = create_memory_object_stream[ + tuple[Awaitable[Any], asyncio.Future] + ](1) + self._runner_task = self.get_loop().create_task( + self._run_tests_and_fixtures(receive_stream) + ) + + coro = func(*args, **kwargs) + future: asyncio.Future[T_Retval] = self.get_loop().create_future() + self._send_stream.send_nowait((coro, future)) + return await future + + def run_asyncgen_fixture( + self, + fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]], + kwargs: dict[str, Any], + ) -> Iterable[T_Retval]: + asyncgen = fixture_func(**kwargs) + fixturevalue: T_Retval = self.get_loop().run_until_complete( + self._call_in_runner_task(asyncgen.asend, None) + ) + self._raise_async_exceptions() + + yield fixturevalue + + try: + self.get_loop().run_until_complete( + self._call_in_runner_task(asyncgen.asend, None) + ) + except StopAsyncIteration: + self._raise_async_exceptions() + else: + self.get_loop().run_until_complete(asyncgen.aclose()) + raise RuntimeError("Async generator fixture did not stop") + + def run_fixture( + self, + fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]], + kwargs: dict[str, Any], + ) -> T_Retval: + retval = self.get_loop().run_until_complete( + self._call_in_runner_task(fixture_func, **kwargs) + ) + self._raise_async_exceptions() + return retval + + def run_test( + self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any] + ) -> None: + try: + self.get_loop().run_until_complete( + self._call_in_runner_task(test_func, **kwargs) + ) + except Exception as exc: + self._exceptions.append(exc) + + self._raise_async_exceptions() + + +class AsyncIOBackend(AsyncBackend): + @classmethod + def run( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + kwargs: dict[str, Any], + options: dict[str, Any], + ) -> T_Retval: + @wraps(func) + async def wrapper() -> T_Retval: + task = cast(asyncio.Task, current_task()) + task.set_name(get_callable_name(func)) + _task_states[task] = TaskState(None, None) + + try: + return await func(*args) + finally: + del _task_states[task] + + debug = options.get("debug", None) + loop_factory = options.get("loop_factory", None) + if loop_factory is None and options.get("use_uvloop", False): + if sys.platform != "win32": + import uvloop + + loop_factory = uvloop.new_event_loop + else: + import winloop + + loop_factory = winloop.new_event_loop + + with Runner(debug=debug, loop_factory=loop_factory) as runner: + return runner.run(wrapper()) + + @classmethod + def current_token(cls) -> object: + return get_running_loop() + + @classmethod + def current_time(cls) -> float: + return get_running_loop().time() + + @classmethod + def cancelled_exception_class(cls) -> type[BaseException]: + return CancelledError + + @classmethod + async def checkpoint(cls) -> None: + await sleep(0) + + @classmethod + async def checkpoint_if_cancelled(cls) -> None: + task = current_task() + if task is None: + return + + try: + cancel_scope = _task_states[task].cancel_scope + except KeyError: + return + + while cancel_scope: + if cancel_scope.cancel_called: + await sleep(0) + elif cancel_scope.shield: + break + else: + cancel_scope = cancel_scope._parent_scope + + @classmethod + async def cancel_shielded_checkpoint(cls) -> None: + with CancelScope(shield=True): + await sleep(0) + + @classmethod + async def sleep(cls, delay: float) -> None: + await sleep(delay) + + @classmethod + def create_cancel_scope( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> CancelScope: + return CancelScope(deadline=deadline, shield=shield) + + @classmethod + def current_effective_deadline(cls) -> float: + if (task := current_task()) is None: + return math.inf + + try: + cancel_scope = _task_states[task].cancel_scope + except KeyError: + return math.inf + + deadline = math.inf + while cancel_scope: + deadline = min(deadline, cancel_scope.deadline) + if cancel_scope._cancel_called: + deadline = -math.inf + break + elif cancel_scope.shield: + break + else: + cancel_scope = cancel_scope._parent_scope + + return deadline + + @classmethod + def create_task_group(cls) -> abc.TaskGroup: + return TaskGroup() + + @classmethod + def create_event(cls) -> abc.Event: + return Event() + + @classmethod + def create_lock(cls, *, fast_acquire: bool) -> abc.Lock: + return Lock(fast_acquire=fast_acquire) + + @classmethod + def create_semaphore( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> abc.Semaphore: + return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire) + + @classmethod + def create_capacity_limiter(cls, total_tokens: float) -> abc.CapacityLimiter: + return CapacityLimiter(total_tokens) + + @classmethod + async def run_sync_in_worker_thread( # type: ignore[return] + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + abandon_on_cancel: bool = False, + limiter: abc.CapacityLimiter | None = None, + ) -> T_Retval: + await cls.checkpoint() + + # If this is the first run in this event loop thread, set up the necessary + # variables + try: + idle_workers = _threadpool_idle_workers.get() + workers = _threadpool_workers.get() + except LookupError: + idle_workers = deque() + workers = set() + _threadpool_idle_workers.set(idle_workers) + _threadpool_workers.set(workers) + + async with limiter or cls.current_default_thread_limiter(): + with CancelScope(shield=not abandon_on_cancel) as scope: + future = asyncio.Future[T_Retval]() + root_task = find_root_task() + if not idle_workers: + worker = WorkerThread(root_task, workers, idle_workers) + worker.start() + workers.add(worker) + root_task.add_done_callback( + worker.stop, context=contextvars.Context() + ) + else: + worker = idle_workers.pop() + + # Prune any other workers that have been idle for MAX_IDLE_TIME + # seconds or longer + now = cls.current_time() + while idle_workers: + if ( + now - idle_workers[0].idle_since + < WorkerThread.MAX_IDLE_TIME + ): + break + + expired_worker = idle_workers.popleft() + expired_worker.root_task.remove_done_callback( + expired_worker.stop + ) + expired_worker.stop() + + context = copy_context() + context.run(set_current_async_library, None) + if abandon_on_cancel or scope._parent_scope is None: + worker_scope = scope + else: + worker_scope = scope._parent_scope + + worker.queue.put_nowait((context, func, args, future, worker_scope)) + return await future + + @classmethod + def check_cancelled(cls) -> None: + scope: CancelScope | None = threadlocals.current_cancel_scope + while scope is not None: + if scope.cancel_called: + raise CancelledError(f"Cancelled by cancel scope {id(scope):x}") + + if scope.shield: + return + + scope = scope._parent_scope + + @classmethod + def run_async_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + async def task_wrapper() -> T_Retval: + __tracebackhide__ = True + if scope is not None: + task = cast(asyncio.Task, current_task()) + _task_states[task] = TaskState(None, scope) + scope._tasks.add(task) + try: + return await func(*args) + except CancelledError as exc: + raise concurrent.futures.CancelledError(str(exc)) from None + finally: + if scope is not None: + scope._tasks.discard(task) + + loop = cast( + "AbstractEventLoop", token or threadlocals.current_token.native_token + ) + if loop.is_closed(): + raise RunFinishedError + + context = copy_context() + context.run(set_current_async_library, "asyncio") + scope = getattr(threadlocals, "current_cancel_scope", None) + f: concurrent.futures.Future[T_Retval] = context.run( + asyncio.run_coroutine_threadsafe, task_wrapper(), loop=loop + ) + return f.result() + + @classmethod + def run_sync_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + @wraps(func) + def wrapper() -> None: + try: + set_current_async_library("asyncio") + f.set_result(func(*args)) + except BaseException as exc: + f.set_exception(exc) + if not isinstance(exc, Exception): + raise + + loop = cast( + "AbstractEventLoop", token or threadlocals.current_token.native_token + ) + if loop.is_closed(): + raise RunFinishedError + + f: concurrent.futures.Future[T_Retval] = Future() + loop.call_soon_threadsafe(wrapper) + return f.result() + + @classmethod + async def open_process( + cls, + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + stdin: int | IO[Any] | None, + stdout: int | IO[Any] | None, + stderr: int | IO[Any] | None, + **kwargs: Any, + ) -> Process: + await cls.checkpoint() + if isinstance(command, PathLike): + command = os.fspath(command) + + if isinstance(command, (str, bytes)): + process = await asyncio.create_subprocess_shell( + command, + stdin=stdin, + stdout=stdout, + stderr=stderr, + **kwargs, + ) + else: + process = await asyncio.create_subprocess_exec( + *command, + stdin=stdin, + stdout=stdout, + stderr=stderr, + **kwargs, + ) + + stdin_stream = StreamWriterWrapper(process.stdin) if process.stdin else None + stdout_stream = StreamReaderWrapper(process.stdout) if process.stdout else None + stderr_stream = StreamReaderWrapper(process.stderr) if process.stderr else None + return Process(process, stdin_stream, stdout_stream, stderr_stream) + + @classmethod + def setup_process_pool_exit_at_shutdown(cls, workers: set[abc.Process]) -> None: + create_task( + _shutdown_process_pool_on_exit(workers), + name="AnyIO process pool shutdown task", + ) + find_root_task().add_done_callback( + partial(_forcibly_shutdown_process_pool_on_exit, workers) # type:ignore[arg-type] + ) + + @classmethod + async def connect_tcp( + cls, host: str, port: int, local_address: IPSockAddrType | None = None + ) -> abc.SocketStream: + transport, protocol = cast( + tuple[asyncio.Transport, StreamProtocol], + await get_running_loop().create_connection( + StreamProtocol, host, port, local_addr=local_address + ), + ) + transport.pause_reading() + return SocketStream(transport, protocol) + + @classmethod + async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream: + await cls.checkpoint() + loop = get_running_loop() + raw_socket = socket.socket(socket.AF_UNIX) + raw_socket.setblocking(False) + while True: + try: + raw_socket.connect(path) + except BlockingIOError: + f: asyncio.Future = asyncio.Future() + loop.add_writer(raw_socket, f.set_result, None) + f.add_done_callback(lambda _: loop.remove_writer(raw_socket)) + await f + except BaseException: + raw_socket.close() + raise + else: + return UNIXSocketStream(raw_socket) + + @classmethod + def create_tcp_listener(cls, sock: socket.socket) -> SocketListener: + return TCPSocketListener(sock) + + @classmethod + def create_unix_listener(cls, sock: socket.socket) -> SocketListener: + return UNIXSocketListener(sock) + + @classmethod + async def create_udp_socket( + cls, + family: AddressFamily, + local_address: IPSockAddrType | None, + remote_address: IPSockAddrType | None, + reuse_port: bool, + ) -> UDPSocket | ConnectedUDPSocket: + transport, protocol = await get_running_loop().create_datagram_endpoint( + DatagramProtocol, + local_addr=local_address, + remote_addr=remote_address, + family=family, + reuse_port=reuse_port, + ) + if protocol.exception: + transport.close() + raise protocol.exception + + if not remote_address: + return UDPSocket(transport, protocol) + else: + return ConnectedUDPSocket(transport, protocol) + + @classmethod + async def create_unix_datagram_socket( # type: ignore[override] + cls, raw_socket: socket.socket, remote_path: str | bytes | None + ) -> abc.UNIXDatagramSocket | abc.ConnectedUNIXDatagramSocket: + await cls.checkpoint() + loop = get_running_loop() + + if remote_path: + while True: + try: + raw_socket.connect(remote_path) + except BlockingIOError: + f: asyncio.Future = asyncio.Future() + loop.add_writer(raw_socket, f.set_result, None) + f.add_done_callback(lambda _: loop.remove_writer(raw_socket)) + await f + except BaseException: + raw_socket.close() + raise + else: + return ConnectedUNIXDatagramSocket(raw_socket) + else: + return UNIXDatagramSocket(raw_socket) + + @classmethod + async def getaddrinfo( + cls, + host: bytes | str | None, + port: str | int | None, + *, + family: int | AddressFamily = 0, + type: int | SocketKind = 0, + proto: int = 0, + flags: int = 0, + ) -> Sequence[ + tuple[ + AddressFamily, + SocketKind, + int, + str, + tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes], + ] + ]: + return await get_running_loop().getaddrinfo( + host, port, family=family, type=type, proto=proto, flags=flags + ) + + @classmethod + async def getnameinfo( + cls, sockaddr: IPSockAddrType, flags: int = 0 + ) -> tuple[str, str]: + return await get_running_loop().getnameinfo(sockaddr, flags) + + @classmethod + async def wait_readable(cls, obj: FileDescriptorLike) -> None: + try: + read_events = _read_events.get() + except LookupError: + read_events = {} + _read_events.set(read_events) + + fd = obj if isinstance(obj, int) else obj.fileno() + if read_events.get(fd): + raise BusyResourceError("reading from") + + loop = get_running_loop() + fut: asyncio.Future[bool] = loop.create_future() + + def cb() -> None: + try: + del read_events[fd] + except KeyError: + pass + else: + remove_reader(fd) + + try: + fut.set_result(True) + except asyncio.InvalidStateError: + pass + + try: + loop.add_reader(fd, cb) + except NotImplementedError: + from anyio._core._asyncio_selector_thread import get_selector + + selector = get_selector() + selector.add_reader(fd, cb) + remove_reader = selector.remove_reader + else: + remove_reader = loop.remove_reader + + read_events[fd] = fut + try: + success = await fut + finally: + try: + del read_events[fd] + except KeyError: + pass + else: + remove_reader(fd) + + if not success: + raise ClosedResourceError + + @classmethod + async def wait_writable(cls, obj: FileDescriptorLike) -> None: + try: + write_events = _write_events.get() + except LookupError: + write_events = {} + _write_events.set(write_events) + + fd = obj if isinstance(obj, int) else obj.fileno() + if write_events.get(fd): + raise BusyResourceError("writing to") + + loop = get_running_loop() + fut: asyncio.Future[bool] = loop.create_future() + + def cb() -> None: + try: + del write_events[fd] + except KeyError: + pass + else: + remove_writer(fd) + + try: + fut.set_result(True) + except asyncio.InvalidStateError: + pass + + try: + loop.add_writer(fd, cb) + except NotImplementedError: + from anyio._core._asyncio_selector_thread import get_selector + + selector = get_selector() + selector.add_writer(fd, cb) + remove_writer = selector.remove_writer + else: + remove_writer = loop.remove_writer + + write_events[fd] = fut + try: + success = await fut + finally: + try: + del write_events[fd] + except KeyError: + pass + else: + remove_writer(fd) + + if not success: + raise ClosedResourceError + + @classmethod + def notify_closing(cls, obj: FileDescriptorLike) -> None: + fd = obj if isinstance(obj, int) else obj.fileno() + loop = get_running_loop() + + try: + write_events = _write_events.get() + except LookupError: + pass + else: + try: + fut = write_events.pop(fd) + except KeyError: + pass + else: + try: + fut.set_result(False) + except asyncio.InvalidStateError: + pass + + try: + loop.remove_writer(fd) + except NotImplementedError: + from anyio._core._asyncio_selector_thread import get_selector + + get_selector().remove_writer(fd) + + try: + read_events = _read_events.get() + except LookupError: + pass + else: + try: + fut = read_events.pop(fd) + except KeyError: + pass + else: + try: + fut.set_result(False) + except asyncio.InvalidStateError: + pass + + try: + loop.remove_reader(fd) + except NotImplementedError: + from anyio._core._asyncio_selector_thread import get_selector + + get_selector().remove_reader(fd) + + @classmethod + async def wrap_listener_socket(cls, sock: socket.socket) -> SocketListener: + return TCPSocketListener(sock) + + @classmethod + async def wrap_stream_socket(cls, sock: socket.socket) -> SocketStream: + transport, protocol = await get_running_loop().create_connection( + StreamProtocol, sock=sock + ) + return SocketStream(transport, protocol) + + @classmethod + async def wrap_unix_stream_socket(cls, sock: socket.socket) -> UNIXSocketStream: + return UNIXSocketStream(sock) + + @classmethod + async def wrap_udp_socket(cls, sock: socket.socket) -> UDPSocket: + transport, protocol = await get_running_loop().create_datagram_endpoint( + DatagramProtocol, sock=sock + ) + return UDPSocket(transport, protocol) + + @classmethod + async def wrap_connected_udp_socket(cls, sock: socket.socket) -> ConnectedUDPSocket: + transport, protocol = await get_running_loop().create_datagram_endpoint( + DatagramProtocol, sock=sock + ) + return ConnectedUDPSocket(transport, protocol) + + @classmethod + async def wrap_unix_datagram_socket(cls, sock: socket.socket) -> UNIXDatagramSocket: + return UNIXDatagramSocket(sock) + + @classmethod + async def wrap_connected_unix_datagram_socket( + cls, sock: socket.socket + ) -> ConnectedUNIXDatagramSocket: + return ConnectedUNIXDatagramSocket(sock) + + @classmethod + def current_default_thread_limiter(cls) -> CapacityLimiter: + try: + return _default_thread_limiter.get() + except LookupError: + limiter = CapacityLimiter(40) + _default_thread_limiter.set(limiter) + return limiter + + @classmethod + def open_signal_receiver( + cls, *signals: Signals + ) -> AbstractContextManager[AsyncIterator[Signals]]: + return _SignalReceiver(signals) + + @classmethod + def get_current_task(cls) -> TaskInfo: + return AsyncIOTaskInfo(current_task()) # type: ignore[arg-type] + + @classmethod + def get_running_tasks(cls) -> Sequence[TaskInfo]: + return [AsyncIOTaskInfo(task) for task in all_tasks() if not task.done()] + + @classmethod + async def wait_all_tasks_blocked(cls) -> None: + await cls.checkpoint() + this_task = current_task() + while True: + for task in all_tasks(): + if task is this_task: + continue + + waiter = task._fut_waiter # type: ignore[attr-defined] + if waiter is None or waiter.done(): + await sleep(0.1) + break + else: + return + + @classmethod + def create_test_runner(cls, options: dict[str, Any]) -> TestRunner: + return TestRunner(**options) + + +backend_class = AsyncIOBackend diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/_trio.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/_trio.py new file mode 100644 index 0000000000000000000000000000000000000000..f460a7f5e0072a8cec103dfb8f4887d15fa666d0 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_backends/_trio.py @@ -0,0 +1,1346 @@ +from __future__ import annotations + +import array +import math +import os +import socket +import sys +import types +import weakref +from collections.abc import ( + AsyncGenerator, + AsyncIterator, + Awaitable, + Callable, + Collection, + Coroutine, + Iterable, + Sequence, +) +from contextlib import AbstractContextManager +from dataclasses import dataclass +from io import IOBase +from os import PathLike +from signal import Signals +from socket import AddressFamily, SocketKind +from types import TracebackType +from typing import ( + IO, + TYPE_CHECKING, + Any, + Generic, + NoReturn, + TypeVar, + cast, + overload, +) + +import trio.from_thread +import trio.lowlevel +from outcome import Error, Outcome, Value +from trio.lowlevel import ( + current_root_task, + current_task, + notify_closing, + wait_readable, + wait_writable, +) +from trio.socket import SocketType as TrioSocketType +from trio.to_thread import run_sync + +from .. import ( + CapacityLimiterStatistics, + EventStatistics, + LockStatistics, + RunFinishedError, + TaskInfo, + WouldBlock, + abc, +) +from .._core._eventloop import claim_worker_thread +from .._core._exceptions import ( + BrokenResourceError, + BusyResourceError, + ClosedResourceError, + EndOfStream, +) +from .._core._sockets import convert_ipv6_sockaddr +from .._core._streams import create_memory_object_stream +from .._core._synchronization import ( + CapacityLimiter as BaseCapacityLimiter, +) +from .._core._synchronization import Event as BaseEvent +from .._core._synchronization import Lock as BaseLock +from .._core._synchronization import ( + ResourceGuard, + SemaphoreStatistics, +) +from .._core._synchronization import Semaphore as BaseSemaphore +from .._core._tasks import CancelScope as BaseCancelScope +from ..abc import IPSockAddrType, UDPPacketType, UNIXDatagramPacketType +from ..abc._eventloop import AsyncBackend, StrOrBytesPath +from ..streams.memory import MemoryObjectSendStream + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike + +if sys.version_info >= (3, 10): + from typing import ParamSpec +else: + from typing_extensions import ParamSpec + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from exceptiongroup import BaseExceptionGroup + from typing_extensions import TypeVarTuple, Unpack + +T = TypeVar("T") +T_Retval = TypeVar("T_Retval") +T_SockAddr = TypeVar("T_SockAddr", str, IPSockAddrType) +PosArgsT = TypeVarTuple("PosArgsT") +P = ParamSpec("P") + + +# +# Event loop +# + +RunVar = trio.lowlevel.RunVar + + +# +# Timeouts and cancellation +# + + +class CancelScope(BaseCancelScope): + def __new__( + cls, original: trio.CancelScope | None = None, **kwargs: object + ) -> CancelScope: + return object.__new__(cls) + + def __init__(self, original: trio.CancelScope | None = None, **kwargs: Any) -> None: + self.__original = original or trio.CancelScope(**kwargs) + + def __enter__(self) -> CancelScope: + self.__original.__enter__() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + return self.__original.__exit__(exc_type, exc_val, exc_tb) + + def cancel(self, reason: str | None = None) -> None: + self.__original.cancel(reason) + + @property + def deadline(self) -> float: + return self.__original.deadline + + @deadline.setter + def deadline(self, value: float) -> None: + self.__original.deadline = value + + @property + def cancel_called(self) -> bool: + return self.__original.cancel_called + + @property + def cancelled_caught(self) -> bool: + return self.__original.cancelled_caught + + @property + def shield(self) -> bool: + return self.__original.shield + + @shield.setter + def shield(self, value: bool) -> None: + self.__original.shield = value + + +# +# Task groups +# + + +class TaskGroup(abc.TaskGroup): + def __init__(self) -> None: + self._active = False + self._nursery_manager = trio.open_nursery(strict_exception_groups=True) + self.cancel_scope = None # type: ignore[assignment] + + async def __aenter__(self) -> TaskGroup: + self._active = True + self._nursery = await self._nursery_manager.__aenter__() + self.cancel_scope = CancelScope(self._nursery.cancel_scope) + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + try: + # trio.Nursery.__exit__ returns bool; .open_nursery has wrong type + return await self._nursery_manager.__aexit__(exc_type, exc_val, exc_tb) # type: ignore[return-value] + except BaseExceptionGroup as exc: + if not exc.split(trio.Cancelled)[1]: + raise trio.Cancelled._create() from exc + + raise + finally: + del exc_val, exc_tb + self._active = False + + def start_soon( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[Any]], + *args: Unpack[PosArgsT], + name: object = None, + ) -> None: + if not self._active: + raise RuntimeError( + "This task group is not active; no new tasks can be started." + ) + + self._nursery.start_soon(func, *args, name=name) + + async def start( + self, func: Callable[..., Awaitable[Any]], *args: object, name: object = None + ) -> Any: + if not self._active: + raise RuntimeError( + "This task group is not active; no new tasks can be started." + ) + + return await self._nursery.start(func, *args, name=name) + + +# +# Subprocesses +# + + +@dataclass(eq=False) +class ReceiveStreamWrapper(abc.ByteReceiveStream): + _stream: trio.abc.ReceiveStream + + async def receive(self, max_bytes: int | None = None) -> bytes: + try: + data = await self._stream.receive_some(max_bytes) + except trio.ClosedResourceError as exc: + raise ClosedResourceError from exc.__cause__ + except trio.BrokenResourceError as exc: + raise BrokenResourceError from exc.__cause__ + + if data: + return bytes(data) + else: + raise EndOfStream + + async def aclose(self) -> None: + await self._stream.aclose() + + +@dataclass(eq=False) +class SendStreamWrapper(abc.ByteSendStream): + _stream: trio.abc.SendStream + + async def send(self, item: bytes) -> None: + try: + await self._stream.send_all(item) + except trio.ClosedResourceError as exc: + raise ClosedResourceError from exc.__cause__ + except trio.BrokenResourceError as exc: + raise BrokenResourceError from exc.__cause__ + + async def aclose(self) -> None: + await self._stream.aclose() + + +@dataclass(eq=False) +class Process(abc.Process): + _process: trio.Process + _stdin: abc.ByteSendStream | None + _stdout: abc.ByteReceiveStream | None + _stderr: abc.ByteReceiveStream | None + + async def aclose(self) -> None: + with CancelScope(shield=True): + if self._stdin: + await self._stdin.aclose() + if self._stdout: + await self._stdout.aclose() + if self._stderr: + await self._stderr.aclose() + + try: + await self.wait() + except BaseException: + self.kill() + with CancelScope(shield=True): + await self.wait() + raise + + async def wait(self) -> int: + return await self._process.wait() + + def terminate(self) -> None: + self._process.terminate() + + def kill(self) -> None: + self._process.kill() + + def send_signal(self, signal: Signals) -> None: + self._process.send_signal(signal) + + @property + def pid(self) -> int: + return self._process.pid + + @property + def returncode(self) -> int | None: + return self._process.returncode + + @property + def stdin(self) -> abc.ByteSendStream | None: + return self._stdin + + @property + def stdout(self) -> abc.ByteReceiveStream | None: + return self._stdout + + @property + def stderr(self) -> abc.ByteReceiveStream | None: + return self._stderr + + +class _ProcessPoolShutdownInstrument(trio.abc.Instrument): + def after_run(self) -> None: + super().after_run() + + +current_default_worker_process_limiter: trio.lowlevel.RunVar = RunVar( + "current_default_worker_process_limiter" +) + + +async def _shutdown_process_pool(workers: set[abc.Process]) -> None: + try: + await trio.sleep(math.inf) + except trio.Cancelled: + for process in workers: + if process.returncode is None: + process.kill() + + with CancelScope(shield=True): + for process in workers: + await process.aclose() + + +# +# Sockets and networking +# + + +class _TrioSocketMixin(Generic[T_SockAddr]): + def __init__(self, trio_socket: TrioSocketType) -> None: + self._trio_socket = trio_socket + self._closed = False + + def _check_closed(self) -> None: + if self._closed: + raise ClosedResourceError + if self._trio_socket.fileno() < 0: + raise BrokenResourceError + + @property + def _raw_socket(self) -> socket.socket: + return self._trio_socket._sock # type: ignore[attr-defined] + + async def aclose(self) -> None: + if self._trio_socket.fileno() >= 0: + self._closed = True + self._trio_socket.close() + + def _convert_socket_error(self, exc: BaseException) -> NoReturn: + if isinstance(exc, trio.ClosedResourceError): + raise ClosedResourceError from exc + elif self._trio_socket.fileno() < 0 and self._closed: + raise ClosedResourceError from None + elif isinstance(exc, OSError): + raise BrokenResourceError from exc + else: + raise exc + + +class SocketStream(_TrioSocketMixin, abc.SocketStream): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self, max_bytes: int = 65536) -> bytes: + with self._receive_guard: + try: + data = await self._trio_socket.recv(max_bytes) + except BaseException as exc: + self._convert_socket_error(exc) + + if data: + return data + else: + raise EndOfStream + + async def send(self, item: bytes) -> None: + with self._send_guard: + view = memoryview(item) + while view: + try: + bytes_sent = await self._trio_socket.send(view) + except BaseException as exc: + self._convert_socket_error(exc) + + view = view[bytes_sent:] + + async def send_eof(self) -> None: + self._trio_socket.shutdown(socket.SHUT_WR) + + +class UNIXSocketStream(SocketStream, abc.UNIXSocketStream): + async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]: + if not isinstance(msglen, int) or msglen < 0: + raise ValueError("msglen must be a non-negative integer") + if not isinstance(maxfds, int) or maxfds < 1: + raise ValueError("maxfds must be a positive integer") + + fds = array.array("i") + await trio.lowlevel.checkpoint() + with self._receive_guard: + while True: + try: + message, ancdata, flags, addr = await self._trio_socket.recvmsg( + msglen, socket.CMSG_LEN(maxfds * fds.itemsize) + ) + except BaseException as exc: + self._convert_socket_error(exc) + else: + if not message and not ancdata: + raise EndOfStream + + break + + for cmsg_level, cmsg_type, cmsg_data in ancdata: + if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS: + raise RuntimeError( + f"Received unexpected ancillary data; message = {message!r}, " + f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}" + ) + + fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)]) + + return message, list(fds) + + async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None: + if not message: + raise ValueError("message must not be empty") + if not fds: + raise ValueError("fds must not be empty") + + filenos: list[int] = [] + for fd in fds: + if isinstance(fd, int): + filenos.append(fd) + elif isinstance(fd, IOBase): + filenos.append(fd.fileno()) + + fdarray = array.array("i", filenos) + await trio.lowlevel.checkpoint() + with self._send_guard: + while True: + try: + await self._trio_socket.sendmsg( + [message], + [ + ( + socket.SOL_SOCKET, + socket.SCM_RIGHTS, + fdarray, + ) + ], + ) + break + except BaseException as exc: + self._convert_socket_error(exc) + + +class TCPSocketListener(_TrioSocketMixin, abc.SocketListener): + def __init__(self, raw_socket: socket.socket): + super().__init__(trio.socket.from_stdlib_socket(raw_socket)) + self._accept_guard = ResourceGuard("accepting connections from") + + async def accept(self) -> SocketStream: + with self._accept_guard: + try: + trio_socket, _addr = await self._trio_socket.accept() + except BaseException as exc: + self._convert_socket_error(exc) + + trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + return SocketStream(trio_socket) + + +class UNIXSocketListener(_TrioSocketMixin, abc.SocketListener): + def __init__(self, raw_socket: socket.socket): + super().__init__(trio.socket.from_stdlib_socket(raw_socket)) + self._accept_guard = ResourceGuard("accepting connections from") + + async def accept(self) -> UNIXSocketStream: + with self._accept_guard: + try: + trio_socket, _addr = await self._trio_socket.accept() + except BaseException as exc: + self._convert_socket_error(exc) + + return UNIXSocketStream(trio_socket) + + +class UDPSocket(_TrioSocketMixin[IPSockAddrType], abc.UDPSocket): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self) -> tuple[bytes, IPSockAddrType]: + with self._receive_guard: + try: + data, addr = await self._trio_socket.recvfrom(65536) + return data, convert_ipv6_sockaddr(addr) + except BaseException as exc: + self._convert_socket_error(exc) + + async def send(self, item: UDPPacketType) -> None: + with self._send_guard: + try: + await self._trio_socket.sendto(*item) + except BaseException as exc: + self._convert_socket_error(exc) + + +class ConnectedUDPSocket(_TrioSocketMixin[IPSockAddrType], abc.ConnectedUDPSocket): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self) -> bytes: + with self._receive_guard: + try: + return await self._trio_socket.recv(65536) + except BaseException as exc: + self._convert_socket_error(exc) + + async def send(self, item: bytes) -> None: + with self._send_guard: + try: + await self._trio_socket.send(item) + except BaseException as exc: + self._convert_socket_error(exc) + + +class UNIXDatagramSocket(_TrioSocketMixin[str], abc.UNIXDatagramSocket): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self) -> UNIXDatagramPacketType: + with self._receive_guard: + try: + data, addr = await self._trio_socket.recvfrom(65536) + return data, addr + except BaseException as exc: + self._convert_socket_error(exc) + + async def send(self, item: UNIXDatagramPacketType) -> None: + with self._send_guard: + try: + await self._trio_socket.sendto(*item) + except BaseException as exc: + self._convert_socket_error(exc) + + +class ConnectedUNIXDatagramSocket( + _TrioSocketMixin[str], abc.ConnectedUNIXDatagramSocket +): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self) -> bytes: + with self._receive_guard: + try: + return await self._trio_socket.recv(65536) + except BaseException as exc: + self._convert_socket_error(exc) + + async def send(self, item: bytes) -> None: + with self._send_guard: + try: + await self._trio_socket.send(item) + except BaseException as exc: + self._convert_socket_error(exc) + + +# +# Synchronization +# + + +class Event(BaseEvent): + def __new__(cls) -> Event: + return object.__new__(cls) + + def __init__(self) -> None: + self.__original = trio.Event() + + def is_set(self) -> bool: + return self.__original.is_set() + + async def wait(self) -> None: + return await self.__original.wait() + + def statistics(self) -> EventStatistics: + orig_statistics = self.__original.statistics() + return EventStatistics(tasks_waiting=orig_statistics.tasks_waiting) + + def set(self) -> None: + self.__original.set() + + +class Lock(BaseLock): + def __new__(cls, *, fast_acquire: bool = False) -> Lock: + return object.__new__(cls) + + def __init__(self, *, fast_acquire: bool = False) -> None: + self._fast_acquire = fast_acquire + self.__original = trio.Lock() + + @staticmethod + def _convert_runtime_error_msg(exc: RuntimeError) -> None: + if exc.args == ("attempt to re-acquire an already held Lock",): + exc.args = ("Attempted to acquire an already held Lock",) + + async def acquire(self) -> None: + if not self._fast_acquire: + try: + await self.__original.acquire() + except RuntimeError as exc: + self._convert_runtime_error_msg(exc) + raise + + return + + # This is the "fast path" where we don't let other tasks run + await trio.lowlevel.checkpoint_if_cancelled() + try: + self.__original.acquire_nowait() + except trio.WouldBlock: + await self.__original._lot.park() + except RuntimeError as exc: + self._convert_runtime_error_msg(exc) + raise + + def acquire_nowait(self) -> None: + try: + self.__original.acquire_nowait() + except trio.WouldBlock: + raise WouldBlock from None + except RuntimeError as exc: + self._convert_runtime_error_msg(exc) + raise + + def locked(self) -> bool: + return self.__original.locked() + + def release(self) -> None: + self.__original.release() + + def statistics(self) -> LockStatistics: + orig_statistics = self.__original.statistics() + owner = TrioTaskInfo(orig_statistics.owner) if orig_statistics.owner else None + return LockStatistics( + orig_statistics.locked, owner, orig_statistics.tasks_waiting + ) + + +class Semaphore(BaseSemaphore): + def __new__( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> Semaphore: + return object.__new__(cls) + + def __init__( + self, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> None: + super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire) + self.__original = trio.Semaphore(initial_value, max_value=max_value) + + async def acquire(self) -> None: + if not self._fast_acquire: + await self.__original.acquire() + return + + # This is the "fast path" where we don't let other tasks run + await trio.lowlevel.checkpoint_if_cancelled() + try: + self.__original.acquire_nowait() + except trio.WouldBlock: + await self.__original._lot.park() + + def acquire_nowait(self) -> None: + try: + self.__original.acquire_nowait() + except trio.WouldBlock: + raise WouldBlock from None + + @property + def max_value(self) -> int | None: + return self.__original.max_value + + @property + def value(self) -> int: + return self.__original.value + + def release(self) -> None: + self.__original.release() + + def statistics(self) -> SemaphoreStatistics: + orig_statistics = self.__original.statistics() + return SemaphoreStatistics(orig_statistics.tasks_waiting) + + +class CapacityLimiter(BaseCapacityLimiter): + def __new__( + cls, + total_tokens: float | None = None, + *, + original: trio.CapacityLimiter | None = None, + ) -> CapacityLimiter: + return object.__new__(cls) + + def __init__( + self, + total_tokens: float | None = None, + *, + original: trio.CapacityLimiter | None = None, + ) -> None: + if original is not None: + self.__original = original + else: + assert total_tokens is not None + self.__original = trio.CapacityLimiter(total_tokens) + + async def __aenter__(self) -> None: + return await self.__original.__aenter__() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + await self.__original.__aexit__(exc_type, exc_val, exc_tb) + + @property + def total_tokens(self) -> float: + return self.__original.total_tokens + + @total_tokens.setter + def total_tokens(self, value: float) -> None: + self.__original.total_tokens = value + + @property + def borrowed_tokens(self) -> int: + return self.__original.borrowed_tokens + + @property + def available_tokens(self) -> float: + return self.__original.available_tokens + + def acquire_nowait(self) -> None: + self.__original.acquire_nowait() + + def acquire_on_behalf_of_nowait(self, borrower: object) -> None: + self.__original.acquire_on_behalf_of_nowait(borrower) + + async def acquire(self) -> None: + await self.__original.acquire() + + async def acquire_on_behalf_of(self, borrower: object) -> None: + await self.__original.acquire_on_behalf_of(borrower) + + def release(self) -> None: + return self.__original.release() + + def release_on_behalf_of(self, borrower: object) -> None: + return self.__original.release_on_behalf_of(borrower) + + def statistics(self) -> CapacityLimiterStatistics: + orig = self.__original.statistics() + return CapacityLimiterStatistics( + borrowed_tokens=orig.borrowed_tokens, + total_tokens=orig.total_tokens, + borrowers=tuple(orig.borrowers), + tasks_waiting=orig.tasks_waiting, + ) + + +_capacity_limiter_wrapper: trio.lowlevel.RunVar = RunVar("_capacity_limiter_wrapper") + + +# +# Signal handling +# + + +class _SignalReceiver: + _iterator: AsyncIterator[int] + + def __init__(self, signals: tuple[Signals, ...]): + self._signals = signals + + def __enter__(self) -> _SignalReceiver: + self._cm = trio.open_signal_receiver(*self._signals) + self._iterator = self._cm.__enter__() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool | None: + return self._cm.__exit__(exc_type, exc_val, exc_tb) + + def __aiter__(self) -> _SignalReceiver: + return self + + async def __anext__(self) -> Signals: + signum = await self._iterator.__anext__() + return Signals(signum) + + +# +# Testing and debugging +# + + +class TestRunner(abc.TestRunner): + def __init__(self, **options: Any) -> None: + from queue import Queue + + self._call_queue: Queue[Callable[[], object]] = Queue() + self._send_stream: MemoryObjectSendStream | None = None + self._options = options + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: types.TracebackType | None, + ) -> None: + if self._send_stream: + self._send_stream.close() + while self._send_stream is not None: + self._call_queue.get()() + + async def _run_tests_and_fixtures(self) -> None: + self._send_stream, receive_stream = create_memory_object_stream(1) + with receive_stream: + async for coro, outcome_holder in receive_stream: + try: + retval = await coro + except BaseException as exc: + outcome_holder.append(Error(exc)) + else: + outcome_holder.append(Value(retval)) + + def _main_task_finished(self, outcome: object) -> None: + self._send_stream = None + + def _call_in_runner_task( + self, + func: Callable[P, Awaitable[T_Retval]], + *args: P.args, + **kwargs: P.kwargs, + ) -> T_Retval: + if self._send_stream is None: + trio.lowlevel.start_guest_run( + self._run_tests_and_fixtures, + run_sync_soon_threadsafe=self._call_queue.put, + done_callback=self._main_task_finished, + **self._options, + ) + while self._send_stream is None: + self._call_queue.get()() + + outcome_holder: list[Outcome] = [] + self._send_stream.send_nowait((func(*args, **kwargs), outcome_holder)) + while not outcome_holder: + self._call_queue.get()() + + return outcome_holder[0].unwrap() + + def run_asyncgen_fixture( + self, + fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]], + kwargs: dict[str, Any], + ) -> Iterable[T_Retval]: + asyncgen = fixture_func(**kwargs) + fixturevalue: T_Retval = self._call_in_runner_task(asyncgen.asend, None) + + yield fixturevalue + + try: + self._call_in_runner_task(asyncgen.asend, None) + except StopAsyncIteration: + pass + else: + self._call_in_runner_task(asyncgen.aclose) + raise RuntimeError("Async generator fixture did not stop") + + def run_fixture( + self, + fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]], + kwargs: dict[str, Any], + ) -> T_Retval: + return self._call_in_runner_task(fixture_func, **kwargs) + + def run_test( + self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any] + ) -> None: + self._call_in_runner_task(test_func, **kwargs) + + +class TrioTaskInfo(TaskInfo): + def __init__(self, task: trio.lowlevel.Task): + parent_id = None + if task.parent_nursery and task.parent_nursery.parent_task: + parent_id = id(task.parent_nursery.parent_task) + + super().__init__(id(task), parent_id, task.name, task.coro) + self._task = weakref.proxy(task) + + def has_pending_cancellation(self) -> bool: + try: + return self._task._cancel_status.effectively_cancelled + except ReferenceError: + # If the task is no longer around, it surely doesn't have a cancellation + # pending + return False + + +class TrioBackend(AsyncBackend): + @classmethod + def run( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + kwargs: dict[str, Any], + options: dict[str, Any], + ) -> T_Retval: + return trio.run(func, *args) + + @classmethod + def current_token(cls) -> object: + return trio.lowlevel.current_trio_token() + + @classmethod + def current_time(cls) -> float: + return trio.current_time() + + @classmethod + def cancelled_exception_class(cls) -> type[BaseException]: + return trio.Cancelled + + @classmethod + async def checkpoint(cls) -> None: + await trio.lowlevel.checkpoint() + + @classmethod + async def checkpoint_if_cancelled(cls) -> None: + await trio.lowlevel.checkpoint_if_cancelled() + + @classmethod + async def cancel_shielded_checkpoint(cls) -> None: + await trio.lowlevel.cancel_shielded_checkpoint() + + @classmethod + async def sleep(cls, delay: float) -> None: + await trio.sleep(delay) + + @classmethod + def create_cancel_scope( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> abc.CancelScope: + return CancelScope(deadline=deadline, shield=shield) + + @classmethod + def current_effective_deadline(cls) -> float: + return trio.current_effective_deadline() + + @classmethod + def create_task_group(cls) -> abc.TaskGroup: + return TaskGroup() + + @classmethod + def create_event(cls) -> abc.Event: + return Event() + + @classmethod + def create_lock(cls, *, fast_acquire: bool) -> Lock: + return Lock(fast_acquire=fast_acquire) + + @classmethod + def create_semaphore( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> abc.Semaphore: + return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire) + + @classmethod + def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter: + return CapacityLimiter(total_tokens) + + @classmethod + async def run_sync_in_worker_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + abandon_on_cancel: bool = False, + limiter: abc.CapacityLimiter | None = None, + ) -> T_Retval: + def wrapper() -> T_Retval: + with claim_worker_thread(TrioBackend, token): + return func(*args) + + token = TrioBackend.current_token() + return await run_sync( + wrapper, + abandon_on_cancel=abandon_on_cancel, + limiter=cast(trio.CapacityLimiter, limiter), + ) + + @classmethod + def check_cancelled(cls) -> None: + trio.from_thread.check_cancelled() + + @classmethod + def run_async_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + trio_token = cast("trio.lowlevel.TrioToken | None", token) + try: + return trio.from_thread.run(func, *args, trio_token=trio_token) + except trio.RunFinishedError: + raise RunFinishedError from None + + @classmethod + def run_sync_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + trio_token = cast("trio.lowlevel.TrioToken | None", token) + try: + return trio.from_thread.run_sync(func, *args, trio_token=trio_token) + except trio.RunFinishedError: + raise RunFinishedError from None + + @classmethod + async def open_process( + cls, + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + stdin: int | IO[Any] | None, + stdout: int | IO[Any] | None, + stderr: int | IO[Any] | None, + **kwargs: Any, + ) -> Process: + def convert_item(item: StrOrBytesPath) -> str: + str_or_bytes = os.fspath(item) + if isinstance(str_or_bytes, str): + return str_or_bytes + else: + return os.fsdecode(str_or_bytes) + + if isinstance(command, (str, bytes, PathLike)): + process = await trio.lowlevel.open_process( + convert_item(command), + stdin=stdin, + stdout=stdout, + stderr=stderr, + shell=True, + **kwargs, + ) + else: + process = await trio.lowlevel.open_process( + [convert_item(item) for item in command], + stdin=stdin, + stdout=stdout, + stderr=stderr, + shell=False, + **kwargs, + ) + + stdin_stream = SendStreamWrapper(process.stdin) if process.stdin else None + stdout_stream = ReceiveStreamWrapper(process.stdout) if process.stdout else None + stderr_stream = ReceiveStreamWrapper(process.stderr) if process.stderr else None + return Process(process, stdin_stream, stdout_stream, stderr_stream) + + @classmethod + def setup_process_pool_exit_at_shutdown(cls, workers: set[abc.Process]) -> None: + trio.lowlevel.spawn_system_task(_shutdown_process_pool, workers) + + @classmethod + async def connect_tcp( + cls, host: str, port: int, local_address: IPSockAddrType | None = None + ) -> SocketStream: + family = socket.AF_INET6 if ":" in host else socket.AF_INET + trio_socket = trio.socket.socket(family) + trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + if local_address: + await trio_socket.bind(local_address) + + try: + await trio_socket.connect((host, port)) + except BaseException: + trio_socket.close() + raise + + return SocketStream(trio_socket) + + @classmethod + async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream: + trio_socket = trio.socket.socket(socket.AF_UNIX) + try: + await trio_socket.connect(path) + except BaseException: + trio_socket.close() + raise + + return UNIXSocketStream(trio_socket) + + @classmethod + def create_tcp_listener(cls, sock: socket.socket) -> abc.SocketListener: + return TCPSocketListener(sock) + + @classmethod + def create_unix_listener(cls, sock: socket.socket) -> abc.SocketListener: + return UNIXSocketListener(sock) + + @classmethod + async def create_udp_socket( + cls, + family: socket.AddressFamily, + local_address: IPSockAddrType | None, + remote_address: IPSockAddrType | None, + reuse_port: bool, + ) -> UDPSocket | ConnectedUDPSocket: + trio_socket = trio.socket.socket(family=family, type=socket.SOCK_DGRAM) + + if reuse_port: + trio_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) + + if local_address: + await trio_socket.bind(local_address) + + if remote_address: + await trio_socket.connect(remote_address) + return ConnectedUDPSocket(trio_socket) + else: + return UDPSocket(trio_socket) + + @classmethod + @overload + async def create_unix_datagram_socket( + cls, raw_socket: socket.socket, remote_path: None + ) -> abc.UNIXDatagramSocket: ... + + @classmethod + @overload + async def create_unix_datagram_socket( + cls, raw_socket: socket.socket, remote_path: str | bytes + ) -> abc.ConnectedUNIXDatagramSocket: ... + + @classmethod + async def create_unix_datagram_socket( + cls, raw_socket: socket.socket, remote_path: str | bytes | None + ) -> abc.UNIXDatagramSocket | abc.ConnectedUNIXDatagramSocket: + trio_socket = trio.socket.from_stdlib_socket(raw_socket) + + if remote_path: + await trio_socket.connect(remote_path) + return ConnectedUNIXDatagramSocket(trio_socket) + else: + return UNIXDatagramSocket(trio_socket) + + @classmethod + async def getaddrinfo( + cls, + host: bytes | str | None, + port: str | int | None, + *, + family: int | AddressFamily = 0, + type: int | SocketKind = 0, + proto: int = 0, + flags: int = 0, + ) -> Sequence[ + tuple[ + AddressFamily, + SocketKind, + int, + str, + tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes], + ] + ]: + return await trio.socket.getaddrinfo(host, port, family, type, proto, flags) + + @classmethod + async def getnameinfo( + cls, sockaddr: IPSockAddrType, flags: int = 0 + ) -> tuple[str, str]: + return await trio.socket.getnameinfo(sockaddr, flags) + + @classmethod + async def wait_readable(cls, obj: FileDescriptorLike) -> None: + try: + await wait_readable(obj) + except trio.ClosedResourceError as exc: + raise ClosedResourceError().with_traceback(exc.__traceback__) from None + except trio.BusyResourceError: + raise BusyResourceError("reading from") from None + + @classmethod + async def wait_writable(cls, obj: FileDescriptorLike) -> None: + try: + await wait_writable(obj) + except trio.ClosedResourceError as exc: + raise ClosedResourceError().with_traceback(exc.__traceback__) from None + except trio.BusyResourceError: + raise BusyResourceError("writing to") from None + + @classmethod + def notify_closing(cls, obj: FileDescriptorLike) -> None: + notify_closing(obj) + + @classmethod + async def wrap_listener_socket(cls, sock: socket.socket) -> abc.SocketListener: + return TCPSocketListener(sock) + + @classmethod + async def wrap_stream_socket(cls, sock: socket.socket) -> SocketStream: + trio_sock = trio.socket.from_stdlib_socket(sock) + return SocketStream(trio_sock) + + @classmethod + async def wrap_unix_stream_socket(cls, sock: socket.socket) -> UNIXSocketStream: + trio_sock = trio.socket.from_stdlib_socket(sock) + return UNIXSocketStream(trio_sock) + + @classmethod + async def wrap_udp_socket(cls, sock: socket.socket) -> UDPSocket: + trio_sock = trio.socket.from_stdlib_socket(sock) + return UDPSocket(trio_sock) + + @classmethod + async def wrap_connected_udp_socket(cls, sock: socket.socket) -> ConnectedUDPSocket: + trio_sock = trio.socket.from_stdlib_socket(sock) + return ConnectedUDPSocket(trio_sock) + + @classmethod + async def wrap_unix_datagram_socket(cls, sock: socket.socket) -> UNIXDatagramSocket: + trio_sock = trio.socket.from_stdlib_socket(sock) + return UNIXDatagramSocket(trio_sock) + + @classmethod + async def wrap_connected_unix_datagram_socket( + cls, sock: socket.socket + ) -> ConnectedUNIXDatagramSocket: + trio_sock = trio.socket.from_stdlib_socket(sock) + return ConnectedUNIXDatagramSocket(trio_sock) + + @classmethod + def current_default_thread_limiter(cls) -> CapacityLimiter: + try: + return _capacity_limiter_wrapper.get() + except LookupError: + limiter = CapacityLimiter( + original=trio.to_thread.current_default_thread_limiter() + ) + _capacity_limiter_wrapper.set(limiter) + return limiter + + @classmethod + def open_signal_receiver( + cls, *signals: Signals + ) -> AbstractContextManager[AsyncIterator[Signals]]: + return _SignalReceiver(signals) + + @classmethod + def get_current_task(cls) -> TaskInfo: + task = current_task() + return TrioTaskInfo(task) + + @classmethod + def get_running_tasks(cls) -> Sequence[TaskInfo]: + root_task = current_root_task() + assert root_task + task_infos = [TrioTaskInfo(root_task)] + nurseries = root_task.child_nurseries + while nurseries: + new_nurseries: list[trio.Nursery] = [] + for nursery in nurseries: + for task in nursery.child_tasks: + task_infos.append(TrioTaskInfo(task)) + new_nurseries.extend(task.child_nurseries) + + nurseries = new_nurseries + + return task_infos + + @classmethod + async def wait_all_tasks_blocked(cls) -> None: + from trio.testing import wait_all_tasks_blocked + + await wait_all_tasks_blocked() + + @classmethod + def create_test_runner(cls, options: dict[str, Any]) -> TestRunner: + return TestRunner(**options) + + +backend_class = TrioBackend diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__init__.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/__init__.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f580314586e814b7b8b6940503dd8329e46a2077 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/__init__.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_asyncio_selector_thread.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_asyncio_selector_thread.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7dc1c7dade2f4a25e78d59d9e9760b6af3a9be0c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_asyncio_selector_thread.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_contextmanagers.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_contextmanagers.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb3a5dacc7a6a5667f46805cc2c83da78b9269cf Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_contextmanagers.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_eventloop.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_eventloop.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..619aa0d60eb12e01d369fe7e4371702fef301548 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_eventloop.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_exceptions.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_exceptions.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aebb4dd26449dd9506649d2955c8811ce6acbe3f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_exceptions.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_fileio.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_fileio.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69232bf202e1adee9e13b8311d837cc38be57233 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_fileio.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_resources.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_resources.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce750f9e18d557eef54a7ed2ce2b432ec758df0d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_resources.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_signals.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_signals.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82174bc41ca6332505c8a374b64b7c8b00aa94b9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_signals.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_sockets.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_sockets.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..097146590be056d8fdab19970b632886c0cc7c5c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_sockets.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_streams.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_streams.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a3a5c74f5688ab1f5dc98991c2e3c71861cbe11f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_streams.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_subprocesses.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_subprocesses.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c89f2c9b9876ee57480261ffb9cdd5b157e869cd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_subprocesses.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_synchronization.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_synchronization.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8669a05dd4e9af252a05de9909a2a336c906807 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_synchronization.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_tasks.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_tasks.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..936072b21cd61c05b0fa349cda5660dd887b9496 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_tasks.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_tempfile.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_tempfile.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c3c653cf59c9e8e6a68c9c7169c5d3364e2b0f7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_tempfile.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_testing.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_testing.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bee34d7f5c72d4c6a3ab198fb42341303b4639b5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_testing.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_typedattr.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_typedattr.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24bb2b18b8f3dec4f29eca44136cb04ede374611 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/__pycache__/_typedattr.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_asyncio_selector_thread.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_asyncio_selector_thread.py new file mode 100644 index 0000000000000000000000000000000000000000..9f35bae568e33e6a9e1219761c83cc8350fa0532 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_asyncio_selector_thread.py @@ -0,0 +1,167 @@ +from __future__ import annotations + +import asyncio +import socket +import threading +from collections.abc import Callable +from selectors import EVENT_READ, EVENT_WRITE, DefaultSelector +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike + +_selector_lock = threading.Lock() +_selector: Selector | None = None + + +class Selector: + def __init__(self) -> None: + self._thread = threading.Thread(target=self.run, name="AnyIO socket selector") + self._selector = DefaultSelector() + self._send, self._receive = socket.socketpair() + self._send.setblocking(False) + self._receive.setblocking(False) + # This somewhat reduces the amount of memory wasted queueing up data + # for wakeups. With these settings, maximum number of 1-byte sends + # before getting BlockingIOError: + # Linux 4.8: 6 + # macOS (darwin 15.5): 1 + # Windows 10: 525347 + # Windows you're weird. (And on Windows setting SNDBUF to 0 makes send + # blocking, even on non-blocking sockets, so don't do that.) + self._receive.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1) + self._send.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1) + # On Windows this is a TCP socket so this might matter. On other + # platforms this fails b/c AF_UNIX sockets aren't actually TCP. + try: + self._send.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + except OSError: + pass + + self._selector.register(self._receive, EVENT_READ) + self._closed = False + + def start(self) -> None: + self._thread.start() + threading._register_atexit(self._stop) # type: ignore[attr-defined] + + def _stop(self) -> None: + global _selector + self._closed = True + self._notify_self() + self._send.close() + self._thread.join() + self._selector.unregister(self._receive) + self._receive.close() + self._selector.close() + _selector = None + assert not self._selector.get_map(), ( + "selector still has registered file descriptors after shutdown" + ) + + def _notify_self(self) -> None: + try: + self._send.send(b"\x00") + except BlockingIOError: + pass + + def add_reader(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None: + loop = asyncio.get_running_loop() + try: + key = self._selector.get_key(fd) + except KeyError: + self._selector.register(fd, EVENT_READ, {EVENT_READ: (loop, callback)}) + else: + if EVENT_READ in key.data: + raise ValueError( + "this file descriptor is already registered for reading" + ) + + key.data[EVENT_READ] = loop, callback + self._selector.modify(fd, key.events | EVENT_READ, key.data) + + self._notify_self() + + def add_writer(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None: + loop = asyncio.get_running_loop() + try: + key = self._selector.get_key(fd) + except KeyError: + self._selector.register(fd, EVENT_WRITE, {EVENT_WRITE: (loop, callback)}) + else: + if EVENT_WRITE in key.data: + raise ValueError( + "this file descriptor is already registered for writing" + ) + + key.data[EVENT_WRITE] = loop, callback + self._selector.modify(fd, key.events | EVENT_WRITE, key.data) + + self._notify_self() + + def remove_reader(self, fd: FileDescriptorLike) -> bool: + try: + key = self._selector.get_key(fd) + except KeyError: + return False + + if new_events := key.events ^ EVENT_READ: + del key.data[EVENT_READ] + self._selector.modify(fd, new_events, key.data) + else: + self._selector.unregister(fd) + + return True + + def remove_writer(self, fd: FileDescriptorLike) -> bool: + try: + key = self._selector.get_key(fd) + except KeyError: + return False + + if new_events := key.events ^ EVENT_WRITE: + del key.data[EVENT_WRITE] + self._selector.modify(fd, new_events, key.data) + else: + self._selector.unregister(fd) + + return True + + def run(self) -> None: + while not self._closed: + for key, events in self._selector.select(): + if key.fileobj is self._receive: + try: + while self._receive.recv(4096): + pass + except BlockingIOError: + pass + + continue + + if events & EVENT_READ: + loop, callback = key.data[EVENT_READ] + self.remove_reader(key.fd) + try: + loop.call_soon_threadsafe(callback) + except RuntimeError: + pass # the loop was already closed + + if events & EVENT_WRITE: + loop, callback = key.data[EVENT_WRITE] + self.remove_writer(key.fd) + try: + loop.call_soon_threadsafe(callback) + except RuntimeError: + pass # the loop was already closed + + +def get_selector() -> Selector: + global _selector + + with _selector_lock: + if _selector is None: + _selector = Selector() + _selector.start() + + return _selector diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_contextmanagers.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_contextmanagers.py new file mode 100644 index 0000000000000000000000000000000000000000..302f32b0c78a7071605b195c55054cfdb0b55f37 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_contextmanagers.py @@ -0,0 +1,200 @@ +from __future__ import annotations + +from abc import abstractmethod +from contextlib import AbstractAsyncContextManager, AbstractContextManager +from inspect import isasyncgen, iscoroutine, isgenerator +from types import TracebackType +from typing import Protocol, TypeVar, cast, final + +_T_co = TypeVar("_T_co", covariant=True) +_ExitT_co = TypeVar("_ExitT_co", covariant=True, bound="bool | None") + + +class _SupportsCtxMgr(Protocol[_T_co, _ExitT_co]): + def __contextmanager__(self) -> AbstractContextManager[_T_co, _ExitT_co]: ... + + +class _SupportsAsyncCtxMgr(Protocol[_T_co, _ExitT_co]): + def __asynccontextmanager__( + self, + ) -> AbstractAsyncContextManager[_T_co, _ExitT_co]: ... + + +class ContextManagerMixin: + """ + Mixin class providing context manager functionality via a generator-based + implementation. + + This class allows you to implement a context manager via :meth:`__contextmanager__` + which should return a generator. The mechanics are meant to mirror those of + :func:`@contextmanager `. + + .. note:: Classes using this mix-in are not reentrant as context managers, meaning + that once you enter it, you can't re-enter before first exiting it. + + .. seealso:: :doc:`contextmanagers` + """ + + __cm: AbstractContextManager[object, bool | None] | None = None + + @final + def __enter__(self: _SupportsCtxMgr[_T_co, bool | None]) -> _T_co: + # Needed for mypy to assume self still has the __cm member + assert isinstance(self, ContextManagerMixin) + if self.__cm is not None: + raise RuntimeError( + f"this {self.__class__.__qualname__} has already been entered" + ) + + cm = self.__contextmanager__() + if not isinstance(cm, AbstractContextManager): + if isgenerator(cm): + raise TypeError( + "__contextmanager__() returned a generator object instead of " + "a context manager. Did you forget to add the @contextmanager " + "decorator?" + ) + + raise TypeError( + f"__contextmanager__() did not return a context manager object, " + f"but {cm.__class__!r}" + ) + + if cm is self: + raise TypeError( + f"{self.__class__.__qualname__}.__contextmanager__() returned " + f"self. Did you forget to add the @contextmanager decorator and a " + f"'yield' statement?" + ) + + value = cm.__enter__() + self.__cm = cm + return value + + @final + def __exit__( + self: _SupportsCtxMgr[object, _ExitT_co], + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> _ExitT_co: + # Needed for mypy to assume self still has the __cm member + assert isinstance(self, ContextManagerMixin) + if self.__cm is None: + raise RuntimeError( + f"this {self.__class__.__qualname__} has not been entered yet" + ) + + # Prevent circular references + cm = self.__cm + del self.__cm + + return cast(_ExitT_co, cm.__exit__(exc_type, exc_val, exc_tb)) + + @abstractmethod + def __contextmanager__(self) -> AbstractContextManager[object, bool | None]: + """ + Implement your context manager logic here. + + This method **must** be decorated with + :func:`@contextmanager `. + + .. note:: Remember that the ``yield`` will raise any exception raised in the + enclosed context block, so use a ``finally:`` block to clean up resources! + + :return: a context manager object + """ + + +class AsyncContextManagerMixin: + """ + Mixin class providing async context manager functionality via a generator-based + implementation. + + This class allows you to implement a context manager via + :meth:`__asynccontextmanager__`. The mechanics are meant to mirror those of + :func:`@asynccontextmanager `. + + .. note:: Classes using this mix-in are not reentrant as context managers, meaning + that once you enter it, you can't re-enter before first exiting it. + + .. seealso:: :doc:`contextmanagers` + """ + + __cm: AbstractAsyncContextManager[object, bool | None] | None = None + + @final + async def __aenter__(self: _SupportsAsyncCtxMgr[_T_co, bool | None]) -> _T_co: + # Needed for mypy to assume self still has the __cm member + assert isinstance(self, AsyncContextManagerMixin) + if self.__cm is not None: + raise RuntimeError( + f"this {self.__class__.__qualname__} has already been entered" + ) + + cm = self.__asynccontextmanager__() + if not isinstance(cm, AbstractAsyncContextManager): + if isasyncgen(cm): + raise TypeError( + "__asynccontextmanager__() returned an async generator instead of " + "an async context manager. Did you forget to add the " + "@asynccontextmanager decorator?" + ) + elif iscoroutine(cm): + cm.close() + raise TypeError( + "__asynccontextmanager__() returned a coroutine object instead of " + "an async context manager. Did you forget to add the " + "@asynccontextmanager decorator and a 'yield' statement?" + ) + + raise TypeError( + f"__asynccontextmanager__() did not return an async context manager, " + f"but {cm.__class__!r}" + ) + + if cm is self: + raise TypeError( + f"{self.__class__.__qualname__}.__asynccontextmanager__() returned " + f"self. Did you forget to add the @asynccontextmanager decorator and a " + f"'yield' statement?" + ) + + value = await cm.__aenter__() + self.__cm = cm + return value + + @final + async def __aexit__( + self: _SupportsAsyncCtxMgr[object, _ExitT_co], + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> _ExitT_co: + assert isinstance(self, AsyncContextManagerMixin) + if self.__cm is None: + raise RuntimeError( + f"this {self.__class__.__qualname__} has not been entered yet" + ) + + # Prevent circular references + cm = self.__cm + del self.__cm + + return cast(_ExitT_co, await cm.__aexit__(exc_type, exc_val, exc_tb)) + + @abstractmethod + def __asynccontextmanager__( + self, + ) -> AbstractAsyncContextManager[object, bool | None]: + """ + Implement your async context manager logic here. + + This method **must** be decorated with + :func:`@asynccontextmanager `. + + .. note:: Remember that the ``yield`` will raise any exception raised in the + enclosed context block, so use a ``finally:`` block to clean up resources! + + :return: an async context manager object + """ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_eventloop.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_eventloop.py new file mode 100644 index 0000000000000000000000000000000000000000..59a69ccdf02c2989fb522bcc9af5a23f64e1f3e7 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_eventloop.py @@ -0,0 +1,234 @@ +from __future__ import annotations + +import math +import sys +import threading +from collections.abc import Awaitable, Callable, Generator +from contextlib import contextmanager +from contextvars import Token +from importlib import import_module +from typing import TYPE_CHECKING, Any, TypeVar + +from ._exceptions import NoEventLoopError + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +sniffio: Any +try: + import sniffio +except ModuleNotFoundError: + sniffio = None + +if TYPE_CHECKING: + from ..abc import AsyncBackend + +# This must be updated when new backends are introduced +BACKENDS = "asyncio", "trio" + +T_Retval = TypeVar("T_Retval") +PosArgsT = TypeVarTuple("PosArgsT") + +threadlocals = threading.local() +loaded_backends: dict[str, type[AsyncBackend]] = {} + + +def run( + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + *args: Unpack[PosArgsT], + backend: str = "asyncio", + backend_options: dict[str, Any] | None = None, +) -> T_Retval: + """ + Run the given coroutine function in an asynchronous event loop. + + The current thread must not be already running an event loop. + + :param func: a coroutine function + :param args: positional arguments to ``func`` + :param backend: name of the asynchronous event loop implementation – currently + either ``asyncio`` or ``trio`` + :param backend_options: keyword arguments to call the backend ``run()`` + implementation with (documented :ref:`here `) + :return: the return value of the coroutine function + :raises RuntimeError: if an asynchronous event loop is already running in this + thread + :raises LookupError: if the named backend is not found + + """ + if asynclib_name := current_async_library(): + raise RuntimeError(f"Already running {asynclib_name} in this thread") + + try: + async_backend = get_async_backend(backend) + except ImportError as exc: + raise LookupError(f"No such backend: {backend}") from exc + + token = None + if asynclib_name is None: + # Since we're in control of the event loop, we can cache the name of the async + # library + token = set_current_async_library(backend) + + try: + backend_options = backend_options or {} + return async_backend.run(func, args, {}, backend_options) + finally: + reset_current_async_library(token) + + +async def sleep(delay: float) -> None: + """ + Pause the current task for the specified duration. + + :param delay: the duration, in seconds + + """ + return await get_async_backend().sleep(delay) + + +async def sleep_forever() -> None: + """ + Pause the current task until it's cancelled. + + This is a shortcut for ``sleep(math.inf)``. + + .. versionadded:: 3.1 + + """ + await sleep(math.inf) + + +async def sleep_until(deadline: float) -> None: + """ + Pause the current task until the given time. + + :param deadline: the absolute time to wake up at (according to the internal + monotonic clock of the event loop) + + .. versionadded:: 3.1 + + """ + now = current_time() + await sleep(max(deadline - now, 0)) + + +def current_time() -> float: + """ + Return the current value of the event loop's internal clock. + + :return: the clock value (seconds) + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().current_time() + + +def get_all_backends() -> tuple[str, ...]: + """Return a tuple of the names of all built-in backends.""" + return BACKENDS + + +def get_available_backends() -> tuple[str, ...]: + """ + Test for the availability of built-in backends. + + :return a tuple of the built-in backend names that were successfully imported + + .. versionadded:: 4.12 + + """ + available_backends: list[str] = [] + for backend_name in get_all_backends(): + try: + get_async_backend(backend_name) + except ImportError: + continue + + available_backends.append(backend_name) + + return tuple(available_backends) + + +def get_cancelled_exc_class() -> type[BaseException]: + """ + Return the current async library's cancellation exception class. + + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().cancelled_exception_class() + + +# +# Private API +# + + +@contextmanager +def claim_worker_thread( + backend_class: type[AsyncBackend], token: object +) -> Generator[Any, None, None]: + from ..lowlevel import EventLoopToken + + threadlocals.current_token = EventLoopToken(backend_class, token) + try: + yield + finally: + del threadlocals.current_token + + +def get_async_backend(asynclib_name: str | None = None) -> type[AsyncBackend]: + if asynclib_name is None: + asynclib_name = current_async_library() + if not asynclib_name: + raise NoEventLoopError( + f"Not currently running on any asynchronous event loop. " + f"Available async backends: {', '.join(get_all_backends())}" + ) + + # We use our own dict instead of sys.modules to get the already imported back-end + # class because the appropriate modules in sys.modules could potentially be only + # partially initialized + try: + return loaded_backends[asynclib_name] + except KeyError: + module = import_module(f"anyio._backends._{asynclib_name}") + loaded_backends[asynclib_name] = module.backend_class + return module.backend_class + + +def current_async_library() -> str | None: + if sniffio is None: + # If sniffio is not installed, we assume we're either running asyncio or nothing + import asyncio + + try: + asyncio.get_running_loop() + return "asyncio" + except RuntimeError: + pass + else: + try: + return sniffio.current_async_library() + except sniffio.AsyncLibraryNotFoundError: + pass + + return None + + +def set_current_async_library(asynclib_name: str | None) -> Token | None: + # no-op if sniffio is not installed + if sniffio is None: + return None + + return sniffio.current_async_library_cvar.set(asynclib_name) + + +def reset_current_async_library(token: Token | None) -> None: + if token is not None: + sniffio.current_async_library_cvar.reset(token) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_exceptions.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..3776bedcd339913d609e41e2e396f3f2fd16ae9d --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_exceptions.py @@ -0,0 +1,156 @@ +from __future__ import annotations + +import sys +from collections.abc import Generator +from textwrap import dedent +from typing import Any + +if sys.version_info < (3, 11): + from exceptiongroup import BaseExceptionGroup + + +class BrokenResourceError(Exception): + """ + Raised when trying to use a resource that has been rendered unusable due to external + causes (e.g. a send stream whose peer has disconnected). + """ + + +class BrokenWorkerProcess(Exception): + """ + Raised by :meth:`~anyio.to_process.run_sync` if the worker process terminates abruptly or + otherwise misbehaves. + """ + + +class BrokenWorkerInterpreter(Exception): + """ + Raised by :meth:`~anyio.to_interpreter.run_sync` if an unexpected exception is + raised in the subinterpreter. + """ + + def __init__(self, excinfo: Any): + # This was adapted from concurrent.futures.interpreter.ExecutionFailed + msg = excinfo.formatted + if not msg: + if excinfo.type and excinfo.msg: + msg = f"{excinfo.type.__name__}: {excinfo.msg}" + else: + msg = excinfo.type.__name__ or excinfo.msg + + super().__init__(msg) + self.excinfo = excinfo + + def __str__(self) -> str: + try: + formatted = self.excinfo.errdisplay + except Exception: + return super().__str__() + else: + return dedent( + f""" + {super().__str__()} + + Uncaught in the interpreter: + + {formatted} + """.strip() + ) + + +class BusyResourceError(Exception): + """ + Raised when two tasks are trying to read from or write to the same resource + concurrently. + """ + + def __init__(self, action: str): + super().__init__(f"Another task is already {action} this resource") + + +class ClosedResourceError(Exception): + """Raised when trying to use a resource that has been closed.""" + + +class ConnectionFailed(OSError): + """ + Raised when a connection attempt fails. + + .. note:: This class inherits from :exc:`OSError` for backwards compatibility. + """ + + +def iterate_exceptions( + exception: BaseException, +) -> Generator[BaseException, None, None]: + if isinstance(exception, BaseExceptionGroup): + for exc in exception.exceptions: + yield from iterate_exceptions(exc) + else: + yield exception + + +class DelimiterNotFound(Exception): + """ + Raised during + :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the + maximum number of bytes has been read without the delimiter being found. + """ + + def __init__(self, max_bytes: int) -> None: + super().__init__( + f"The delimiter was not found among the first {max_bytes} bytes" + ) + + +class EndOfStream(Exception): + """ + Raised when trying to read from a stream that has been closed from the other end. + """ + + +class IncompleteRead(Exception): + """ + Raised during + :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or + :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the + connection is closed before the requested amount of bytes has been read. + """ + + def __init__(self) -> None: + super().__init__( + "The stream was closed before the read operation could be completed" + ) + + +class TypedAttributeLookupError(LookupError): + """ + Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute + is not found and no default value has been given. + """ + + +class WouldBlock(Exception): + """Raised by ``X_nowait`` functions if ``X()`` would block.""" + + +class NoEventLoopError(RuntimeError): + """ + Raised by several functions that require an event loop to be running in the current + thread when there is no running event loop. + + This is also raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync` + if not calling from an AnyIO worker thread, and no ``token`` was passed. + """ + + +class RunFinishedError(RuntimeError): + """ + Raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync` if the event + loop associated with the explicitly passed token has already finished. + """ + + def __init__(self) -> None: + super().__init__( + "The event loop associated with the given token has already finished" + ) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_fileio.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_fileio.py new file mode 100644 index 0000000000000000000000000000000000000000..061f0d7e100b04a338249ae592ead886fa54335e --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_fileio.py @@ -0,0 +1,797 @@ +from __future__ import annotations + +import os +import pathlib +import sys +from collections.abc import ( + AsyncIterator, + Callable, + Iterable, + Iterator, + Sequence, +) +from dataclasses import dataclass +from functools import partial +from os import PathLike +from typing import ( + IO, + TYPE_CHECKING, + Any, + AnyStr, + ClassVar, + Final, + Generic, + overload, +) + +from .. import to_thread +from ..abc import AsyncResource + +if TYPE_CHECKING: + from types import ModuleType + + from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer +else: + ReadableBuffer = OpenBinaryMode = OpenTextMode = WriteableBuffer = object + + +class AsyncFile(AsyncResource, Generic[AnyStr]): + """ + An asynchronous file object. + + This class wraps a standard file object and provides async friendly versions of the + following blocking methods (where available on the original file object): + + * read + * read1 + * readline + * readlines + * readinto + * readinto1 + * write + * writelines + * truncate + * seek + * tell + * flush + + All other methods are directly passed through. + + This class supports the asynchronous context manager protocol which closes the + underlying file at the end of the context block. + + This class also supports asynchronous iteration:: + + async with await open_file(...) as f: + async for line in f: + print(line) + """ + + def __init__(self, fp: IO[AnyStr]) -> None: + self._fp: Any = fp + + def __getattr__(self, name: str) -> object: + return getattr(self._fp, name) + + @property + def wrapped(self) -> IO[AnyStr]: + """The wrapped file object.""" + return self._fp + + async def __aiter__(self) -> AsyncIterator[AnyStr]: + while True: + line = await self.readline() + if line: + yield line + else: + break + + async def aclose(self) -> None: + return await to_thread.run_sync(self._fp.close) + + async def read(self, size: int = -1) -> AnyStr: + return await to_thread.run_sync(self._fp.read, size) + + async def read1(self: AsyncFile[bytes], size: int = -1) -> bytes: + return await to_thread.run_sync(self._fp.read1, size) + + async def readline(self) -> AnyStr: + return await to_thread.run_sync(self._fp.readline) + + async def readlines(self) -> list[AnyStr]: + return await to_thread.run_sync(self._fp.readlines) + + async def readinto(self: AsyncFile[bytes], b: WriteableBuffer) -> int: + return await to_thread.run_sync(self._fp.readinto, b) + + async def readinto1(self: AsyncFile[bytes], b: WriteableBuffer) -> int: + return await to_thread.run_sync(self._fp.readinto1, b) + + @overload + async def write(self: AsyncFile[bytes], b: ReadableBuffer) -> int: ... + + @overload + async def write(self: AsyncFile[str], b: str) -> int: ... + + async def write(self, b: ReadableBuffer | str) -> int: + return await to_thread.run_sync(self._fp.write, b) + + @overload + async def writelines( + self: AsyncFile[bytes], lines: Iterable[ReadableBuffer] + ) -> None: ... + + @overload + async def writelines(self: AsyncFile[str], lines: Iterable[str]) -> None: ... + + async def writelines(self, lines: Iterable[ReadableBuffer] | Iterable[str]) -> None: + return await to_thread.run_sync(self._fp.writelines, lines) + + async def truncate(self, size: int | None = None) -> int: + return await to_thread.run_sync(self._fp.truncate, size) + + async def seek(self, offset: int, whence: int | None = os.SEEK_SET) -> int: + return await to_thread.run_sync(self._fp.seek, offset, whence) + + async def tell(self) -> int: + return await to_thread.run_sync(self._fp.tell) + + async def flush(self) -> None: + return await to_thread.run_sync(self._fp.flush) + + +@overload +async def open_file( + file: str | PathLike[str] | int, + mode: OpenBinaryMode, + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + closefd: bool = ..., + opener: Callable[[str, int], int] | None = ..., +) -> AsyncFile[bytes]: ... + + +@overload +async def open_file( + file: str | PathLike[str] | int, + mode: OpenTextMode = ..., + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + closefd: bool = ..., + opener: Callable[[str, int], int] | None = ..., +) -> AsyncFile[str]: ... + + +async def open_file( + file: str | PathLike[str] | int, + mode: str = "r", + buffering: int = -1, + encoding: str | None = None, + errors: str | None = None, + newline: str | None = None, + closefd: bool = True, + opener: Callable[[str, int], int] | None = None, +) -> AsyncFile[Any]: + """ + Open a file asynchronously. + + The arguments are exactly the same as for the builtin :func:`open`. + + :return: an asynchronous file object + + """ + fp = await to_thread.run_sync( + open, file, mode, buffering, encoding, errors, newline, closefd, opener + ) + return AsyncFile(fp) + + +def wrap_file(file: IO[AnyStr]) -> AsyncFile[AnyStr]: + """ + Wrap an existing file as an asynchronous file. + + :param file: an existing file-like object + :return: an asynchronous file object + + """ + return AsyncFile(file) + + +@dataclass(eq=False) +class _PathIterator(AsyncIterator["Path"]): + iterator: Iterator[PathLike[str]] + + async def __anext__(self) -> Path: + nextval = await to_thread.run_sync( + next, self.iterator, None, abandon_on_cancel=True + ) + if nextval is None: + raise StopAsyncIteration from None + + return Path(nextval) + + +class Path: + """ + An asynchronous version of :class:`pathlib.Path`. + + This class cannot be substituted for :class:`pathlib.Path` or + :class:`pathlib.PurePath`, but it is compatible with the :class:`os.PathLike` + interface. + + It implements the Python 3.10 version of :class:`pathlib.Path` interface, except for + the deprecated :meth:`~pathlib.Path.link_to` method. + + Some methods may be unavailable or have limited functionality, based on the Python + version: + + * :meth:`~pathlib.Path.copy` (available on Python 3.14 or later) + * :meth:`~pathlib.Path.copy_into` (available on Python 3.14 or later) + * :meth:`~pathlib.Path.from_uri` (available on Python 3.13 or later) + * :meth:`~pathlib.PurePath.full_match` (available on Python 3.13 or later) + * :attr:`~pathlib.Path.info` (available on Python 3.14 or later) + * :meth:`~pathlib.Path.is_junction` (available on Python 3.12 or later) + * :meth:`~pathlib.PurePath.match` (the ``case_sensitive`` parameter is only + available on Python 3.13 or later) + * :meth:`~pathlib.Path.move` (available on Python 3.14 or later) + * :meth:`~pathlib.Path.move_into` (available on Python 3.14 or later) + * :meth:`~pathlib.PurePath.relative_to` (the ``walk_up`` parameter is only available + on Python 3.12 or later) + * :meth:`~pathlib.Path.walk` (available on Python 3.12 or later) + + Any methods that do disk I/O need to be awaited on. These methods are: + + * :meth:`~pathlib.Path.absolute` + * :meth:`~pathlib.Path.chmod` + * :meth:`~pathlib.Path.cwd` + * :meth:`~pathlib.Path.exists` + * :meth:`~pathlib.Path.expanduser` + * :meth:`~pathlib.Path.group` + * :meth:`~pathlib.Path.hardlink_to` + * :meth:`~pathlib.Path.home` + * :meth:`~pathlib.Path.is_block_device` + * :meth:`~pathlib.Path.is_char_device` + * :meth:`~pathlib.Path.is_dir` + * :meth:`~pathlib.Path.is_fifo` + * :meth:`~pathlib.Path.is_file` + * :meth:`~pathlib.Path.is_junction` + * :meth:`~pathlib.Path.is_mount` + * :meth:`~pathlib.Path.is_socket` + * :meth:`~pathlib.Path.is_symlink` + * :meth:`~pathlib.Path.lchmod` + * :meth:`~pathlib.Path.lstat` + * :meth:`~pathlib.Path.mkdir` + * :meth:`~pathlib.Path.open` + * :meth:`~pathlib.Path.owner` + * :meth:`~pathlib.Path.read_bytes` + * :meth:`~pathlib.Path.read_text` + * :meth:`~pathlib.Path.readlink` + * :meth:`~pathlib.Path.rename` + * :meth:`~pathlib.Path.replace` + * :meth:`~pathlib.Path.resolve` + * :meth:`~pathlib.Path.rmdir` + * :meth:`~pathlib.Path.samefile` + * :meth:`~pathlib.Path.stat` + * :meth:`~pathlib.Path.symlink_to` + * :meth:`~pathlib.Path.touch` + * :meth:`~pathlib.Path.unlink` + * :meth:`~pathlib.Path.walk` + * :meth:`~pathlib.Path.write_bytes` + * :meth:`~pathlib.Path.write_text` + + Additionally, the following methods return an async iterator yielding + :class:`~.Path` objects: + + * :meth:`~pathlib.Path.glob` + * :meth:`~pathlib.Path.iterdir` + * :meth:`~pathlib.Path.rglob` + """ + + __slots__ = "_path", "__weakref__" + + __weakref__: Any + + def __init__(self, *args: str | PathLike[str]) -> None: + self._path: Final[pathlib.Path] = pathlib.Path(*args) + + def __fspath__(self) -> str: + return self._path.__fspath__() + + def __str__(self) -> str: + return self._path.__str__() + + def __repr__(self) -> str: + return f"{self.__class__.__name__}({self.as_posix()!r})" + + def __bytes__(self) -> bytes: + return self._path.__bytes__() + + def __hash__(self) -> int: + return self._path.__hash__() + + def __eq__(self, other: object) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__eq__(target) + + def __lt__(self, other: pathlib.PurePath | Path) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__lt__(target) + + def __le__(self, other: pathlib.PurePath | Path) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__le__(target) + + def __gt__(self, other: pathlib.PurePath | Path) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__gt__(target) + + def __ge__(self, other: pathlib.PurePath | Path) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__ge__(target) + + def __truediv__(self, other: str | PathLike[str]) -> Path: + return Path(self._path / other) + + def __rtruediv__(self, other: str | PathLike[str]) -> Path: + return Path(other) / self + + @property + def parts(self) -> tuple[str, ...]: + return self._path.parts + + @property + def drive(self) -> str: + return self._path.drive + + @property + def root(self) -> str: + return self._path.root + + @property + def anchor(self) -> str: + return self._path.anchor + + @property + def parents(self) -> Sequence[Path]: + return tuple(Path(p) for p in self._path.parents) + + @property + def parent(self) -> Path: + return Path(self._path.parent) + + @property + def name(self) -> str: + return self._path.name + + @property + def suffix(self) -> str: + return self._path.suffix + + @property + def suffixes(self) -> list[str]: + return self._path.suffixes + + @property + def stem(self) -> str: + return self._path.stem + + async def absolute(self) -> Path: + path = await to_thread.run_sync(self._path.absolute) + return Path(path) + + def as_posix(self) -> str: + return self._path.as_posix() + + def as_uri(self) -> str: + return self._path.as_uri() + + if sys.version_info >= (3, 13): + parser: ClassVar[ModuleType] = pathlib.Path.parser + + @classmethod + def from_uri(cls, uri: str) -> Path: + return Path(pathlib.Path.from_uri(uri)) + + def full_match( + self, path_pattern: str, *, case_sensitive: bool | None = None + ) -> bool: + return self._path.full_match(path_pattern, case_sensitive=case_sensitive) + + def match( + self, path_pattern: str, *, case_sensitive: bool | None = None + ) -> bool: + return self._path.match(path_pattern, case_sensitive=case_sensitive) + else: + + def match(self, path_pattern: str) -> bool: + return self._path.match(path_pattern) + + if sys.version_info >= (3, 14): + + @property + def info(self) -> Any: # TODO: add return type annotation when Typeshed gets it + return self._path.info + + async def copy( + self, + target: str | os.PathLike[str], + *, + follow_symlinks: bool = True, + preserve_metadata: bool = False, + ) -> Path: + func = partial( + self._path.copy, + follow_symlinks=follow_symlinks, + preserve_metadata=preserve_metadata, + ) + return Path(await to_thread.run_sync(func, pathlib.Path(target))) + + async def copy_into( + self, + target_dir: str | os.PathLike[str], + *, + follow_symlinks: bool = True, + preserve_metadata: bool = False, + ) -> Path: + func = partial( + self._path.copy_into, + follow_symlinks=follow_symlinks, + preserve_metadata=preserve_metadata, + ) + return Path(await to_thread.run_sync(func, pathlib.Path(target_dir))) + + async def move(self, target: str | os.PathLike[str]) -> Path: + # Upstream does not handle anyio.Path properly as a PathLike + target = pathlib.Path(target) + return Path(await to_thread.run_sync(self._path.move, target)) + + async def move_into( + self, + target_dir: str | os.PathLike[str], + ) -> Path: + return Path(await to_thread.run_sync(self._path.move_into, target_dir)) + + def is_relative_to(self, other: str | PathLike[str]) -> bool: + try: + self.relative_to(other) + return True + except ValueError: + return False + + async def chmod(self, mode: int, *, follow_symlinks: bool = True) -> None: + func = partial(os.chmod, follow_symlinks=follow_symlinks) + return await to_thread.run_sync(func, self._path, mode) + + @classmethod + async def cwd(cls) -> Path: + path = await to_thread.run_sync(pathlib.Path.cwd) + return cls(path) + + async def exists(self) -> bool: + return await to_thread.run_sync(self._path.exists, abandon_on_cancel=True) + + async def expanduser(self) -> Path: + return Path( + await to_thread.run_sync(self._path.expanduser, abandon_on_cancel=True) + ) + + if sys.version_info < (3, 12): + # Python 3.11 and earlier + def glob(self, pattern: str) -> AsyncIterator[Path]: + gen = self._path.glob(pattern) + return _PathIterator(gen) + elif (3, 12) <= sys.version_info < (3, 13): + # changed in Python 3.12: + # - The case_sensitive parameter was added. + def glob( + self, + pattern: str, + *, + case_sensitive: bool | None = None, + ) -> AsyncIterator[Path]: + gen = self._path.glob(pattern, case_sensitive=case_sensitive) + return _PathIterator(gen) + elif sys.version_info >= (3, 13): + # Changed in Python 3.13: + # - The recurse_symlinks parameter was added. + # - The pattern parameter accepts a path-like object. + def glob( # type: ignore[misc] # mypy doesn't allow for differing signatures in a conditional block + self, + pattern: str | PathLike[str], + *, + case_sensitive: bool | None = None, + recurse_symlinks: bool = False, + ) -> AsyncIterator[Path]: + gen = self._path.glob( + pattern, # type: ignore[arg-type] + case_sensitive=case_sensitive, + recurse_symlinks=recurse_symlinks, + ) + return _PathIterator(gen) + + async def group(self) -> str: + return await to_thread.run_sync(self._path.group, abandon_on_cancel=True) + + async def hardlink_to( + self, target: str | bytes | PathLike[str] | PathLike[bytes] + ) -> None: + if isinstance(target, Path): + target = target._path + + await to_thread.run_sync(os.link, target, self) + + @classmethod + async def home(cls) -> Path: + home_path = await to_thread.run_sync(pathlib.Path.home) + return cls(home_path) + + def is_absolute(self) -> bool: + return self._path.is_absolute() + + async def is_block_device(self) -> bool: + return await to_thread.run_sync( + self._path.is_block_device, abandon_on_cancel=True + ) + + async def is_char_device(self) -> bool: + return await to_thread.run_sync( + self._path.is_char_device, abandon_on_cancel=True + ) + + async def is_dir(self) -> bool: + return await to_thread.run_sync(self._path.is_dir, abandon_on_cancel=True) + + async def is_fifo(self) -> bool: + return await to_thread.run_sync(self._path.is_fifo, abandon_on_cancel=True) + + async def is_file(self) -> bool: + return await to_thread.run_sync(self._path.is_file, abandon_on_cancel=True) + + if sys.version_info >= (3, 12): + + async def is_junction(self) -> bool: + return await to_thread.run_sync(self._path.is_junction) + + async def is_mount(self) -> bool: + return await to_thread.run_sync( + os.path.ismount, self._path, abandon_on_cancel=True + ) + + def is_reserved(self) -> bool: + return self._path.is_reserved() + + async def is_socket(self) -> bool: + return await to_thread.run_sync(self._path.is_socket, abandon_on_cancel=True) + + async def is_symlink(self) -> bool: + return await to_thread.run_sync(self._path.is_symlink, abandon_on_cancel=True) + + async def iterdir(self) -> AsyncIterator[Path]: + gen = ( + self._path.iterdir() + if sys.version_info < (3, 13) + else await to_thread.run_sync(self._path.iterdir, abandon_on_cancel=True) + ) + async for path in _PathIterator(gen): + yield path + + def joinpath(self, *args: str | PathLike[str]) -> Path: + return Path(self._path.joinpath(*args)) + + async def lchmod(self, mode: int) -> None: + await to_thread.run_sync(self._path.lchmod, mode) + + async def lstat(self) -> os.stat_result: + return await to_thread.run_sync(self._path.lstat, abandon_on_cancel=True) + + async def mkdir( + self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False + ) -> None: + await to_thread.run_sync(self._path.mkdir, mode, parents, exist_ok) + + @overload + async def open( + self, + mode: OpenBinaryMode, + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + ) -> AsyncFile[bytes]: ... + + @overload + async def open( + self, + mode: OpenTextMode = ..., + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + ) -> AsyncFile[str]: ... + + async def open( + self, + mode: str = "r", + buffering: int = -1, + encoding: str | None = None, + errors: str | None = None, + newline: str | None = None, + ) -> AsyncFile[Any]: + fp = await to_thread.run_sync( + self._path.open, mode, buffering, encoding, errors, newline + ) + return AsyncFile(fp) + + async def owner(self) -> str: + return await to_thread.run_sync(self._path.owner, abandon_on_cancel=True) + + async def read_bytes(self) -> bytes: + return await to_thread.run_sync(self._path.read_bytes) + + async def read_text( + self, encoding: str | None = None, errors: str | None = None + ) -> str: + return await to_thread.run_sync(self._path.read_text, encoding, errors) + + if sys.version_info >= (3, 12): + + def relative_to( + self, *other: str | PathLike[str], walk_up: bool = False + ) -> Path: + # relative_to() should work with any PathLike but it doesn't + others = [pathlib.Path(other) for other in other] + return Path(self._path.relative_to(*others, walk_up=walk_up)) + + else: + + def relative_to(self, *other: str | PathLike[str]) -> Path: + return Path(self._path.relative_to(*other)) + + async def readlink(self) -> Path: + target = await to_thread.run_sync(os.readlink, self._path) + return Path(target) + + async def rename(self, target: str | pathlib.PurePath | Path) -> Path: + if isinstance(target, Path): + target = target._path + + await to_thread.run_sync(self._path.rename, target) + return Path(target) + + async def replace(self, target: str | pathlib.PurePath | Path) -> Path: + if isinstance(target, Path): + target = target._path + + await to_thread.run_sync(self._path.replace, target) + return Path(target) + + async def resolve(self, strict: bool = False) -> Path: + func = partial(self._path.resolve, strict=strict) + return Path(await to_thread.run_sync(func, abandon_on_cancel=True)) + + if sys.version_info < (3, 12): + # Pre Python 3.12 + def rglob(self, pattern: str) -> AsyncIterator[Path]: + gen = self._path.rglob(pattern) + return _PathIterator(gen) + elif (3, 12) <= sys.version_info < (3, 13): + # Changed in Python 3.12: + # - The case_sensitive parameter was added. + def rglob( + self, pattern: str, *, case_sensitive: bool | None = None + ) -> AsyncIterator[Path]: + gen = self._path.rglob(pattern, case_sensitive=case_sensitive) + return _PathIterator(gen) + elif sys.version_info >= (3, 13): + # Changed in Python 3.13: + # - The recurse_symlinks parameter was added. + # - The pattern parameter accepts a path-like object. + def rglob( # type: ignore[misc] # mypy doesn't allow for differing signatures in a conditional block + self, + pattern: str | PathLike[str], + *, + case_sensitive: bool | None = None, + recurse_symlinks: bool = False, + ) -> AsyncIterator[Path]: + gen = self._path.rglob( + pattern, # type: ignore[arg-type] + case_sensitive=case_sensitive, + recurse_symlinks=recurse_symlinks, + ) + return _PathIterator(gen) + + async def rmdir(self) -> None: + await to_thread.run_sync(self._path.rmdir) + + async def samefile(self, other_path: str | PathLike[str]) -> bool: + if isinstance(other_path, Path): + other_path = other_path._path + + return await to_thread.run_sync( + self._path.samefile, other_path, abandon_on_cancel=True + ) + + async def stat(self, *, follow_symlinks: bool = True) -> os.stat_result: + func = partial(os.stat, follow_symlinks=follow_symlinks) + return await to_thread.run_sync(func, self._path, abandon_on_cancel=True) + + async def symlink_to( + self, + target: str | bytes | PathLike[str] | PathLike[bytes], + target_is_directory: bool = False, + ) -> None: + if isinstance(target, Path): + target = target._path + + await to_thread.run_sync(self._path.symlink_to, target, target_is_directory) + + async def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None: + await to_thread.run_sync(self._path.touch, mode, exist_ok) + + async def unlink(self, missing_ok: bool = False) -> None: + try: + await to_thread.run_sync(self._path.unlink) + except FileNotFoundError: + if not missing_ok: + raise + + if sys.version_info >= (3, 12): + + async def walk( + self, + top_down: bool = True, + on_error: Callable[[OSError], object] | None = None, + follow_symlinks: bool = False, + ) -> AsyncIterator[tuple[Path, list[str], list[str]]]: + def get_next_value() -> tuple[pathlib.Path, list[str], list[str]] | None: + try: + return next(gen) + except StopIteration: + return None + + gen = self._path.walk(top_down, on_error, follow_symlinks) + while True: + value = await to_thread.run_sync(get_next_value) + if value is None: + return + + root, dirs, paths = value + yield Path(root), dirs, paths + + def with_name(self, name: str) -> Path: + return Path(self._path.with_name(name)) + + def with_stem(self, stem: str) -> Path: + return Path(self._path.with_name(stem + self._path.suffix)) + + def with_suffix(self, suffix: str) -> Path: + return Path(self._path.with_suffix(suffix)) + + def with_segments(self, *pathsegments: str | PathLike[str]) -> Path: + return Path(*pathsegments) + + async def write_bytes(self, data: bytes) -> int: + return await to_thread.run_sync(self._path.write_bytes, data) + + async def write_text( + self, + data: str, + encoding: str | None = None, + errors: str | None = None, + newline: str | None = None, + ) -> int: + # Path.write_text() does not support the "newline" parameter before Python 3.10 + def sync_write_text() -> int: + with self._path.open( + "w", encoding=encoding, errors=errors, newline=newline + ) as fp: + return fp.write(data) + + return await to_thread.run_sync(sync_write_text) + + +PathLike.register(Path) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_resources.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_resources.py new file mode 100644 index 0000000000000000000000000000000000000000..b9a5344aef2962670f9b305a02cd0b11f2087d2f --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_resources.py @@ -0,0 +1,18 @@ +from __future__ import annotations + +from ..abc import AsyncResource +from ._tasks import CancelScope + + +async def aclose_forcefully(resource: AsyncResource) -> None: + """ + Close an asynchronous resource in a cancelled scope. + + Doing this closes the resource without waiting on anything. + + :param resource: the resource to close + + """ + with CancelScope() as scope: + scope.cancel() + await resource.aclose() diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_signals.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_signals.py new file mode 100644 index 0000000000000000000000000000000000000000..e24c79e10d4b76775679f7dd0dbe3f5860150451 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_signals.py @@ -0,0 +1,29 @@ +from __future__ import annotations + +from collections.abc import AsyncIterator +from contextlib import AbstractContextManager +from signal import Signals + +from ._eventloop import get_async_backend + + +def open_signal_receiver( + *signals: Signals, +) -> AbstractContextManager[AsyncIterator[Signals]]: + """ + Start receiving operating system signals. + + :param signals: signals to receive (e.g. ``signal.SIGINT``) + :return: an asynchronous context manager for an asynchronous iterator which yields + signal numbers + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + .. warning:: Windows does not support signals natively so it is best to avoid + relying on this in cross-platform applications. + + .. warning:: On asyncio, this permanently replaces any previous signal handler for + the given signals, as set via :meth:`~asyncio.loop.add_signal_handler`. + + """ + return get_async_backend().open_signal_receiver(*signals) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_sockets.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_sockets.py new file mode 100644 index 0000000000000000000000000000000000000000..6c99b3a1c1c7a5beee07aa5cf053149f8b5b9e2f --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_sockets.py @@ -0,0 +1,1003 @@ +from __future__ import annotations + +import errno +import os +import socket +import ssl +import stat +import sys +from collections.abc import Awaitable +from dataclasses import dataclass +from ipaddress import IPv4Address, IPv6Address, ip_address +from os import PathLike, chmod +from socket import AddressFamily, SocketKind +from typing import TYPE_CHECKING, Any, Literal, cast, overload + +from .. import ConnectionFailed, to_thread +from ..abc import ( + ByteStreamConnectable, + ConnectedUDPSocket, + ConnectedUNIXDatagramSocket, + IPAddressType, + IPSockAddrType, + SocketListener, + SocketStream, + UDPSocket, + UNIXDatagramSocket, + UNIXSocketStream, +) +from ..streams.stapled import MultiListener +from ..streams.tls import TLSConnectable, TLSStream +from ._eventloop import get_async_backend +from ._resources import aclose_forcefully +from ._synchronization import Event +from ._tasks import create_task_group, move_on_after + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike +else: + FileDescriptorLike = object + +if sys.version_info < (3, 11): + from exceptiongroup import ExceptionGroup + +if sys.version_info >= (3, 12): + from typing import override +else: + from typing_extensions import override + +if sys.version_info < (3, 13): + from typing_extensions import deprecated +else: + from warnings import deprecated + +IPPROTO_IPV6 = getattr(socket, "IPPROTO_IPV6", 41) # https://bugs.python.org/issue29515 + +AnyIPAddressFamily = Literal[ + AddressFamily.AF_UNSPEC, AddressFamily.AF_INET, AddressFamily.AF_INET6 +] +IPAddressFamily = Literal[AddressFamily.AF_INET, AddressFamily.AF_INET6] + + +# tls_hostname given +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + ssl_context: ssl.SSLContext | None = ..., + tls_standard_compatible: bool = ..., + tls_hostname: str, + happy_eyeballs_delay: float = ..., +) -> TLSStream: ... + + +# ssl_context given +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + ssl_context: ssl.SSLContext, + tls_standard_compatible: bool = ..., + tls_hostname: str | None = ..., + happy_eyeballs_delay: float = ..., +) -> TLSStream: ... + + +# tls=True +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + tls: Literal[True], + ssl_context: ssl.SSLContext | None = ..., + tls_standard_compatible: bool = ..., + tls_hostname: str | None = ..., + happy_eyeballs_delay: float = ..., +) -> TLSStream: ... + + +# tls=False +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + tls: Literal[False], + ssl_context: ssl.SSLContext | None = ..., + tls_standard_compatible: bool = ..., + tls_hostname: str | None = ..., + happy_eyeballs_delay: float = ..., +) -> SocketStream: ... + + +# No TLS arguments +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + happy_eyeballs_delay: float = ..., +) -> SocketStream: ... + + +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = None, + tls: bool = False, + ssl_context: ssl.SSLContext | None = None, + tls_standard_compatible: bool = True, + tls_hostname: str | None = None, + happy_eyeballs_delay: float = 0.25, +) -> SocketStream | TLSStream: + """ + Connect to a host using the TCP protocol. + + This function implements the stateless version of the Happy Eyeballs algorithm (RFC + 6555). If ``remote_host`` is a host name that resolves to multiple IP addresses, + each one is tried until one connection attempt succeeds. If the first attempt does + not connected within 250 milliseconds, a second attempt is started using the next + address in the list, and so on. On IPv6 enabled systems, an IPv6 address (if + available) is tried first. + + When the connection has been established, a TLS handshake will be done if either + ``ssl_context`` or ``tls_hostname`` is not ``None``, or if ``tls`` is ``True``. + + :param remote_host: the IP address or host name to connect to + :param remote_port: port on the target host to connect to + :param local_host: the interface address or name to bind the socket to before + connecting + :param tls: ``True`` to do a TLS handshake with the connected stream and return a + :class:`~anyio.streams.tls.TLSStream` instead + :param ssl_context: the SSL context object to use (if omitted, a default context is + created) + :param tls_standard_compatible: If ``True``, performs the TLS shutdown handshake + before closing the stream and requires that the server does this as well. + Otherwise, :exc:`~ssl.SSLEOFError` may be raised during reads from the stream. + Some protocols, such as HTTP, require this option to be ``False``. + See :meth:`~ssl.SSLContext.wrap_socket` for details. + :param tls_hostname: host name to check the server certificate against (defaults to + the value of ``remote_host``) + :param happy_eyeballs_delay: delay (in seconds) before starting the next connection + attempt + :return: a socket stream object if no TLS handshake was done, otherwise a TLS stream + :raises ConnectionFailed: if the connection fails + + """ + # Placed here due to https://github.com/python/mypy/issues/7057 + connected_stream: SocketStream | None = None + + async def try_connect(remote_host: str, event: Event) -> None: + nonlocal connected_stream + try: + stream = await asynclib.connect_tcp(remote_host, remote_port, local_address) + except OSError as exc: + oserrors.append(exc) + return + else: + if connected_stream is None: + connected_stream = stream + tg.cancel_scope.cancel() + else: + await stream.aclose() + finally: + event.set() + + asynclib = get_async_backend() + local_address: IPSockAddrType | None = None + family = socket.AF_UNSPEC + if local_host: + gai_res = await getaddrinfo(str(local_host), None) + family, *_, local_address = gai_res[0] + + target_host = str(remote_host) + try: + addr_obj = ip_address(remote_host) + except ValueError: + addr_obj = None + + if addr_obj is not None: + if isinstance(addr_obj, IPv6Address): + target_addrs = [(socket.AF_INET6, addr_obj.compressed)] + else: + target_addrs = [(socket.AF_INET, addr_obj.compressed)] + else: + # getaddrinfo() will raise an exception if name resolution fails + gai_res = await getaddrinfo( + target_host, remote_port, family=family, type=socket.SOCK_STREAM + ) + + # Organize the list so that the first address is an IPv6 address (if available) + # and the second one is an IPv4 addresses. The rest can be in whatever order. + v6_found = v4_found = False + target_addrs = [] + for af, *_, sa in gai_res: + if af == socket.AF_INET6 and not v6_found: + v6_found = True + target_addrs.insert(0, (af, sa[0])) + elif af == socket.AF_INET and not v4_found and v6_found: + v4_found = True + target_addrs.insert(1, (af, sa[0])) + else: + target_addrs.append((af, sa[0])) + + oserrors: list[OSError] = [] + try: + async with create_task_group() as tg: + for _af, addr in target_addrs: + event = Event() + tg.start_soon(try_connect, addr, event) + with move_on_after(happy_eyeballs_delay): + await event.wait() + + if connected_stream is None: + cause = ( + oserrors[0] + if len(oserrors) == 1 + else ExceptionGroup("multiple connection attempts failed", oserrors) + ) + raise OSError("All connection attempts failed") from cause + finally: + oserrors.clear() + + if tls or tls_hostname or ssl_context: + try: + return await TLSStream.wrap( + connected_stream, + server_side=False, + hostname=tls_hostname or str(remote_host), + ssl_context=ssl_context, + standard_compatible=tls_standard_compatible, + ) + except BaseException: + await aclose_forcefully(connected_stream) + raise + + return connected_stream + + +async def connect_unix(path: str | bytes | PathLike[Any]) -> UNIXSocketStream: + """ + Connect to the given UNIX socket. + + Not available on Windows. + + :param path: path to the socket + :return: a socket stream object + :raises ConnectionFailed: if the connection fails + + """ + path = os.fspath(path) + return await get_async_backend().connect_unix(path) + + +async def create_tcp_listener( + *, + local_host: IPAddressType | None = None, + local_port: int = 0, + family: AnyIPAddressFamily = socket.AddressFamily.AF_UNSPEC, + backlog: int = 65536, + reuse_port: bool = False, +) -> MultiListener[SocketStream]: + """ + Create a TCP socket listener. + + :param local_port: port number to listen on + :param local_host: IP address of the interface to listen on. If omitted, listen on + all IPv4 and IPv6 interfaces. To listen on all interfaces on a specific address + family, use ``0.0.0.0`` for IPv4 or ``::`` for IPv6. + :param family: address family (used if ``local_host`` was omitted) + :param backlog: maximum number of queued incoming connections (up to a maximum of + 2**16, or 65536) + :param reuse_port: ``True`` to allow multiple sockets to bind to the same + address/port (not supported on Windows) + :return: a multi-listener object containing one or more socket listeners + :raises OSError: if there's an error creating a socket, or binding to one or more + interfaces failed + + """ + asynclib = get_async_backend() + backlog = min(backlog, 65536) + local_host = str(local_host) if local_host is not None else None + + def setup_raw_socket( + fam: AddressFamily, + bind_addr: tuple[str, int] | tuple[str, int, int, int], + *, + v6only: bool = True, + ) -> socket.socket: + sock = socket.socket(fam) + try: + sock.setblocking(False) + + if fam == AddressFamily.AF_INET6: + sock.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, v6only) + + # For Windows, enable exclusive address use. For others, enable address + # reuse. + if sys.platform == "win32": + sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1) + else: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + + if reuse_port: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) + + # Workaround for #554 + if fam == socket.AF_INET6 and "%" in bind_addr[0]: + addr, scope_id = bind_addr[0].split("%", 1) + bind_addr = (addr, bind_addr[1], 0, int(scope_id)) + + sock.bind(bind_addr) + sock.listen(backlog) + except BaseException: + sock.close() + raise + + return sock + + # We passing type=0 on non-Windows platforms as a workaround for a uvloop bug + # where we don't get the correct scope ID for IPv6 link-local addresses when passing + # type=socket.SOCK_STREAM to getaddrinfo(): + # https://github.com/MagicStack/uvloop/issues/539 + gai_res = await getaddrinfo( + local_host, + local_port, + family=family, + type=socket.SOCK_STREAM if sys.platform == "win32" else 0, + flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG, + ) + + # The set comprehension is here to work around a glibc bug: + # https://sourceware.org/bugzilla/show_bug.cgi?id=14969 + sockaddrs = sorted({res for res in gai_res if res[1] == SocketKind.SOCK_STREAM}) + + # Special case for dual-stack binding on the "any" interface + if ( + local_host is None + and family == AddressFamily.AF_UNSPEC + and socket.has_dualstack_ipv6() + and any(fam == AddressFamily.AF_INET6 for fam, *_ in gai_res) + ): + raw_socket = setup_raw_socket( + AddressFamily.AF_INET6, ("::", local_port), v6only=False + ) + listener = asynclib.create_tcp_listener(raw_socket) + return MultiListener([listener]) + + errors: list[OSError] = [] + try: + for _ in range(len(sockaddrs)): + listeners: list[SocketListener] = [] + bound_ephemeral_port = local_port + try: + for fam, *_, sockaddr in sockaddrs: + sockaddr = sockaddr[0], bound_ephemeral_port, *sockaddr[2:] + raw_socket = setup_raw_socket(fam, sockaddr) + + # Store the assigned port if an ephemeral port was requested, so + # we'll bind to the same port on all interfaces + if local_port == 0 and len(gai_res) > 1: + bound_ephemeral_port = raw_socket.getsockname()[1] + + listeners.append(asynclib.create_tcp_listener(raw_socket)) + except BaseException as exc: + for listener in listeners: + await listener.aclose() + + # If an ephemeral port was requested but binding the assigned port + # failed for another interface, rotate the address list and try again + if ( + isinstance(exc, OSError) + and exc.errno == errno.EADDRINUSE + and local_port == 0 + and bound_ephemeral_port + ): + errors.append(exc) + sockaddrs.append(sockaddrs.pop(0)) + continue + + raise + + return MultiListener(listeners) + + raise OSError( + f"Could not create {len(sockaddrs)} listeners with a consistent port" + ) from ExceptionGroup("Several bind attempts failed", errors) + finally: + del errors # Prevent reference cycles + + +async def create_unix_listener( + path: str | bytes | PathLike[Any], + *, + mode: int | None = None, + backlog: int = 65536, +) -> SocketListener: + """ + Create a UNIX socket listener. + + Not available on Windows. + + :param path: path of the socket + :param mode: permissions to set on the socket + :param backlog: maximum number of queued incoming connections (up to a maximum of + 2**16, or 65536) + :return: a listener object + + .. versionchanged:: 3.0 + If a socket already exists on the file system in the given path, it will be + removed first. + + """ + backlog = min(backlog, 65536) + raw_socket = await setup_unix_local_socket(path, mode, socket.SOCK_STREAM) + try: + raw_socket.listen(backlog) + return get_async_backend().create_unix_listener(raw_socket) + except BaseException: + raw_socket.close() + raise + + +async def create_udp_socket( + family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC, + *, + local_host: IPAddressType | None = None, + local_port: int = 0, + reuse_port: bool = False, +) -> UDPSocket: + """ + Create a UDP socket. + + If ``port`` has been given, the socket will be bound to this port on the local + machine, making this socket suitable for providing UDP based services. + + :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically + determined from ``local_host`` if omitted + :param local_host: IP address or host name of the local interface to bind to + :param local_port: local port to bind to + :param reuse_port: ``True`` to allow multiple sockets to bind to the same + address/port (not supported on Windows) + :return: a UDP socket + + """ + if family is AddressFamily.AF_UNSPEC and not local_host: + raise ValueError('Either "family" or "local_host" must be given') + + if local_host: + gai_res = await getaddrinfo( + str(local_host), + local_port, + family=family, + type=socket.SOCK_DGRAM, + flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG, + ) + family = cast(AnyIPAddressFamily, gai_res[0][0]) + local_address = gai_res[0][-1] + elif family is AddressFamily.AF_INET6: + local_address = ("::", 0) + else: + local_address = ("0.0.0.0", 0) + + sock = await get_async_backend().create_udp_socket( + family, local_address, None, reuse_port + ) + return cast(UDPSocket, sock) + + +async def create_connected_udp_socket( + remote_host: IPAddressType, + remote_port: int, + *, + family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC, + local_host: IPAddressType | None = None, + local_port: int = 0, + reuse_port: bool = False, +) -> ConnectedUDPSocket: + """ + Create a connected UDP socket. + + Connected UDP sockets can only communicate with the specified remote host/port, an + any packets sent from other sources are dropped. + + :param remote_host: remote host to set as the default target + :param remote_port: port on the remote host to set as the default target + :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically + determined from ``local_host`` or ``remote_host`` if omitted + :param local_host: IP address or host name of the local interface to bind to + :param local_port: local port to bind to + :param reuse_port: ``True`` to allow multiple sockets to bind to the same + address/port (not supported on Windows) + :return: a connected UDP socket + + """ + local_address = None + if local_host: + gai_res = await getaddrinfo( + str(local_host), + local_port, + family=family, + type=socket.SOCK_DGRAM, + flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG, + ) + family = cast(AnyIPAddressFamily, gai_res[0][0]) + local_address = gai_res[0][-1] + + gai_res = await getaddrinfo( + str(remote_host), remote_port, family=family, type=socket.SOCK_DGRAM + ) + family = cast(AnyIPAddressFamily, gai_res[0][0]) + remote_address = gai_res[0][-1] + + sock = await get_async_backend().create_udp_socket( + family, local_address, remote_address, reuse_port + ) + return cast(ConnectedUDPSocket, sock) + + +async def create_unix_datagram_socket( + *, + local_path: None | str | bytes | PathLike[Any] = None, + local_mode: int | None = None, +) -> UNIXDatagramSocket: + """ + Create a UNIX datagram socket. + + Not available on Windows. + + If ``local_path`` has been given, the socket will be bound to this path, making this + socket suitable for receiving datagrams from other processes. Other processes can + send datagrams to this socket only if ``local_path`` is set. + + If a socket already exists on the file system in the ``local_path``, it will be + removed first. + + :param local_path: the path on which to bind to + :param local_mode: permissions to set on the local socket + :return: a UNIX datagram socket + + """ + raw_socket = await setup_unix_local_socket( + local_path, local_mode, socket.SOCK_DGRAM + ) + return await get_async_backend().create_unix_datagram_socket(raw_socket, None) + + +async def create_connected_unix_datagram_socket( + remote_path: str | bytes | PathLike[Any], + *, + local_path: None | str | bytes | PathLike[Any] = None, + local_mode: int | None = None, +) -> ConnectedUNIXDatagramSocket: + """ + Create a connected UNIX datagram socket. + + Connected datagram sockets can only communicate with the specified remote path. + + If ``local_path`` has been given, the socket will be bound to this path, making + this socket suitable for receiving datagrams from other processes. Other processes + can send datagrams to this socket only if ``local_path`` is set. + + If a socket already exists on the file system in the ``local_path``, it will be + removed first. + + :param remote_path: the path to set as the default target + :param local_path: the path on which to bind to + :param local_mode: permissions to set on the local socket + :return: a connected UNIX datagram socket + + """ + remote_path = os.fspath(remote_path) + raw_socket = await setup_unix_local_socket( + local_path, local_mode, socket.SOCK_DGRAM + ) + return await get_async_backend().create_unix_datagram_socket( + raw_socket, remote_path + ) + + +async def getaddrinfo( + host: bytes | str | None, + port: str | int | None, + *, + family: int | AddressFamily = 0, + type: int | SocketKind = 0, + proto: int = 0, + flags: int = 0, +) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int]]]: + """ + Look up a numeric IP address given a host name. + + Internationalized domain names are translated according to the (non-transitional) + IDNA 2008 standard. + + .. note:: 4-tuple IPv6 socket addresses are automatically converted to 2-tuples of + (host, port), unlike what :func:`socket.getaddrinfo` does. + + :param host: host name + :param port: port number + :param family: socket family (`'AF_INET``, ...) + :param type: socket type (``SOCK_STREAM``, ...) + :param proto: protocol number + :param flags: flags to pass to upstream ``getaddrinfo()`` + :return: list of tuples containing (family, type, proto, canonname, sockaddr) + + .. seealso:: :func:`socket.getaddrinfo` + + """ + # Handle unicode hostnames + if isinstance(host, str): + try: + encoded_host: bytes | None = host.encode("ascii") + except UnicodeEncodeError: + import idna + + encoded_host = idna.encode(host, uts46=True) + else: + encoded_host = host + + gai_res = await get_async_backend().getaddrinfo( + encoded_host, port, family=family, type=type, proto=proto, flags=flags + ) + return [ + (family, type, proto, canonname, convert_ipv6_sockaddr(sockaddr)) + for family, type, proto, canonname, sockaddr in gai_res + # filter out IPv6 results when IPv6 is disabled + if not isinstance(sockaddr[0], int) + ] + + +def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Awaitable[tuple[str, str]]: + """ + Look up the host name of an IP address. + + :param sockaddr: socket address (e.g. (ipaddress, port) for IPv4) + :param flags: flags to pass to upstream ``getnameinfo()`` + :return: a tuple of (host name, service name) + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + .. seealso:: :func:`socket.getnameinfo` + + """ + return get_async_backend().getnameinfo(sockaddr, flags) + + +@deprecated("This function is deprecated; use `wait_readable` instead") +def wait_socket_readable(sock: socket.socket) -> Awaitable[None]: + """ + .. deprecated:: 4.7.0 + Use :func:`wait_readable` instead. + + Wait until the given socket has data to be read. + + .. warning:: Only use this on raw sockets that have not been wrapped by any higher + level constructs like socket streams! + + :param sock: a socket object + :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the + socket to become readable + :raises ~anyio.BusyResourceError: if another task is already waiting for the socket + to become readable + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().wait_readable(sock.fileno()) + + +@deprecated("This function is deprecated; use `wait_writable` instead") +def wait_socket_writable(sock: socket.socket) -> Awaitable[None]: + """ + .. deprecated:: 4.7.0 + Use :func:`wait_writable` instead. + + Wait until the given socket can be written to. + + This does **NOT** work on Windows when using the asyncio backend with a proactor + event loop (default on py3.8+). + + .. warning:: Only use this on raw sockets that have not been wrapped by any higher + level constructs like socket streams! + + :param sock: a socket object + :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the + socket to become writable + :raises ~anyio.BusyResourceError: if another task is already waiting for the socket + to become writable + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().wait_writable(sock.fileno()) + + +def wait_readable(obj: FileDescriptorLike) -> Awaitable[None]: + """ + Wait until the given object has data to be read. + + On Unix systems, ``obj`` must either be an integer file descriptor, or else an + object with a ``.fileno()`` method which returns an integer file descriptor. Any + kind of file descriptor can be passed, though the exact semantics will depend on + your kernel. For example, this probably won't do anything useful for on-disk files. + + On Windows systems, ``obj`` must either be an integer ``SOCKET`` handle, or else an + object with a ``.fileno()`` method which returns an integer ``SOCKET`` handle. File + descriptors aren't supported, and neither are handles that refer to anything besides + a ``SOCKET``. + + On backends where this functionality is not natively provided (asyncio + ``ProactorEventLoop`` on Windows), it is provided using a separate selector thread + which is set to shut down when the interpreter shuts down. + + .. warning:: Don't use this on raw sockets that have been wrapped by any higher + level constructs like socket streams! + + :param obj: an object with a ``.fileno()`` method or an integer handle + :raises ~anyio.ClosedResourceError: if the object was closed while waiting for the + object to become readable + :raises ~anyio.BusyResourceError: if another task is already waiting for the object + to become readable + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().wait_readable(obj) + + +def wait_writable(obj: FileDescriptorLike) -> Awaitable[None]: + """ + Wait until the given object can be written to. + + :param obj: an object with a ``.fileno()`` method or an integer handle + :raises ~anyio.ClosedResourceError: if the object was closed while waiting for the + object to become writable + :raises ~anyio.BusyResourceError: if another task is already waiting for the object + to become writable + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + .. seealso:: See the documentation of :func:`wait_readable` for the definition of + ``obj`` and notes on backend compatibility. + + .. warning:: Don't use this on raw sockets that have been wrapped by any higher + level constructs like socket streams! + + """ + return get_async_backend().wait_writable(obj) + + +def notify_closing(obj: FileDescriptorLike) -> None: + """ + Call this before closing a file descriptor (on Unix) or socket (on + Windows). This will cause any `wait_readable` or `wait_writable` + calls on the given object to immediately wake up and raise + `~anyio.ClosedResourceError`. + + This doesn't actually close the object – you still have to do that + yourself afterwards. Also, you want to be careful to make sure no + new tasks start waiting on the object in between when you call this + and when it's actually closed. So to close something properly, you + usually want to do these steps in order: + + 1. Explicitly mark the object as closed, so that any new attempts + to use it will abort before they start. + 2. Call `notify_closing` to wake up any already-existing users. + 3. Actually close the object. + + It's also possible to do them in a different order if that's more + convenient, *but only if* you make sure not to have any checkpoints in + between the steps. This way they all happen in a single atomic + step, so other tasks won't be able to tell what order they happened + in anyway. + + :param obj: an object with a ``.fileno()`` method or an integer handle + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + get_async_backend().notify_closing(obj) + + +# +# Private API +# + + +def convert_ipv6_sockaddr( + sockaddr: tuple[str, int, int, int] | tuple[str, int], +) -> tuple[str, int]: + """ + Convert a 4-tuple IPv6 socket address to a 2-tuple (address, port) format. + + If the scope ID is nonzero, it is added to the address, separated with ``%``. + Otherwise the flow id and scope id are simply cut off from the tuple. + Any other kinds of socket addresses are returned as-is. + + :param sockaddr: the result of :meth:`~socket.socket.getsockname` + :return: the converted socket address + + """ + # This is more complicated than it should be because of MyPy + if isinstance(sockaddr, tuple) and len(sockaddr) == 4: + host, port, flowinfo, scope_id = sockaddr + if scope_id: + # PyPy (as of v7.3.11) leaves the interface name in the result, so + # we discard it and only get the scope ID from the end + # (https://foss.heptapod.net/pypy/pypy/-/issues/3938) + host = host.split("%")[0] + + # Add scope_id to the address + return f"{host}%{scope_id}", port + else: + return host, port + else: + return sockaddr + + +async def setup_unix_local_socket( + path: None | str | bytes | PathLike[Any], + mode: int | None, + socktype: int, +) -> socket.socket: + """ + Create a UNIX local socket object, deleting the socket at the given path if it + exists. + + Not available on Windows. + + :param path: path of the socket + :param mode: permissions to set on the socket + :param socktype: socket.SOCK_STREAM or socket.SOCK_DGRAM + + """ + path_str: str | None + if path is not None: + path_str = os.fsdecode(path) + + # Linux abstract namespace sockets aren't backed by a concrete file so skip stat call + if not path_str.startswith("\0"): + # Copied from pathlib... + try: + stat_result = os.stat(path) + except OSError as e: + if e.errno not in ( + errno.ENOENT, + errno.ENOTDIR, + errno.EBADF, + errno.ELOOP, + ): + raise + else: + if stat.S_ISSOCK(stat_result.st_mode): + os.unlink(path) + else: + path_str = None + + raw_socket = socket.socket(socket.AF_UNIX, socktype) + raw_socket.setblocking(False) + + if path_str is not None: + try: + await to_thread.run_sync(raw_socket.bind, path_str, abandon_on_cancel=True) + if mode is not None: + await to_thread.run_sync(chmod, path_str, mode, abandon_on_cancel=True) + except BaseException: + raw_socket.close() + raise + + return raw_socket + + +@dataclass +class TCPConnectable(ByteStreamConnectable): + """ + Connects to a TCP server at the given host and port. + + :param host: host name or IP address of the server + :param port: TCP port number of the server + """ + + host: str | IPv4Address | IPv6Address + port: int + + def __post_init__(self) -> None: + if self.port < 1 or self.port > 65535: + raise ValueError("TCP port number out of range") + + @override + async def connect(self) -> SocketStream: + try: + return await connect_tcp(self.host, self.port) + except OSError as exc: + raise ConnectionFailed( + f"error connecting to {self.host}:{self.port}: {exc}" + ) from exc + + +@dataclass +class UNIXConnectable(ByteStreamConnectable): + """ + Connects to a UNIX domain socket at the given path. + + :param path: the file system path of the socket + """ + + path: str | bytes | PathLike[str] | PathLike[bytes] + + @override + async def connect(self) -> UNIXSocketStream: + try: + return await connect_unix(self.path) + except OSError as exc: + raise ConnectionFailed(f"error connecting to {self.path!r}: {exc}") from exc + + +def as_connectable( + remote: ByteStreamConnectable + | tuple[str | IPv4Address | IPv6Address, int] + | str + | bytes + | PathLike[str], + /, + *, + tls: bool = False, + ssl_context: ssl.SSLContext | None = None, + tls_hostname: str | None = None, + tls_standard_compatible: bool = True, +) -> ByteStreamConnectable: + """ + Return a byte stream connectable from the given object. + + If a bytestream connectable is given, it is returned unchanged. + If a tuple of (host, port) is given, a TCP connectable is returned. + If a string or bytes path is given, a UNIX connectable is returned. + + If ``tls=True``, the connectable will be wrapped in a + :class:`~.streams.tls.TLSConnectable`. + + :param remote: a connectable, a tuple of (host, port) or a path to a UNIX socket + :param tls: if ``True``, wrap the plaintext connectable in a + :class:`~.streams.tls.TLSConnectable`, using the provided TLS settings) + :param ssl_context: if ``tls=True``, the SSLContext object to use (if not provided, + a secure default will be created) + :param tls_hostname: if ``tls=True``, host name of the server to use for checking + the server certificate (defaults to the host portion of the address for TCP + connectables) + :param tls_standard_compatible: if ``False`` and ``tls=True``, makes the TLS stream + skip the closing handshake when closing the connection, so it won't raise an + exception if the server does the same + + """ + connectable: TCPConnectable | UNIXConnectable | TLSConnectable + if isinstance(remote, ByteStreamConnectable): + return remote + elif isinstance(remote, tuple) and len(remote) == 2: + connectable = TCPConnectable(*remote) + elif isinstance(remote, (str, bytes, PathLike)): + connectable = UNIXConnectable(remote) + else: + raise TypeError(f"cannot convert {remote!r} to a connectable") + + if tls: + if not tls_hostname and isinstance(connectable, TCPConnectable): + tls_hostname = str(connectable.host) + + connectable = TLSConnectable( + connectable, + ssl_context=ssl_context, + hostname=tls_hostname, + standard_compatible=tls_standard_compatible, + ) + + return connectable diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_streams.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_streams.py new file mode 100644 index 0000000000000000000000000000000000000000..2b9c7df200f9520357503c754bcdea1c047bdda3 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_streams.py @@ -0,0 +1,52 @@ +from __future__ import annotations + +import math +from typing import TypeVar +from warnings import warn + +from ..streams.memory import ( + MemoryObjectReceiveStream, + MemoryObjectSendStream, + _MemoryObjectStreamState, +) + +T_Item = TypeVar("T_Item") + + +class create_memory_object_stream( + tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]], +): + """ + Create a memory object stream. + + The stream's item type can be annotated like + :func:`create_memory_object_stream[T_Item]`. + + :param max_buffer_size: number of items held in the buffer until ``send()`` starts + blocking + :param item_type: old way of marking the streams with the right generic type for + static typing (does nothing on AnyIO 4) + + .. deprecated:: 4.0 + Use ``create_memory_object_stream[YourItemType](...)`` instead. + :return: a tuple of (send stream, receive stream) + + """ + + def __new__( # type: ignore[misc] + cls, max_buffer_size: float = 0, item_type: object = None + ) -> tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]]: + if max_buffer_size != math.inf and not isinstance(max_buffer_size, int): + raise ValueError("max_buffer_size must be either an integer or math.inf") + if max_buffer_size < 0: + raise ValueError("max_buffer_size cannot be negative") + if item_type is not None: + warn( + "The item_type argument has been deprecated in AnyIO 4.0. " + "Use create_memory_object_stream[YourItemType](...) instead.", + DeprecationWarning, + stacklevel=2, + ) + + state = _MemoryObjectStreamState[T_Item](max_buffer_size) + return (MemoryObjectSendStream(state), MemoryObjectReceiveStream(state)) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_subprocesses.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_subprocesses.py new file mode 100644 index 0000000000000000000000000000000000000000..36d9b306c992b83a8033c0ee66daa141d23d010c --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_subprocesses.py @@ -0,0 +1,202 @@ +from __future__ import annotations + +import sys +from collections.abc import AsyncIterable, Iterable, Mapping, Sequence +from io import BytesIO +from os import PathLike +from subprocess import PIPE, CalledProcessError, CompletedProcess +from typing import IO, Any, Union, cast + +from ..abc import Process +from ._eventloop import get_async_backend +from ._tasks import create_task_group + +if sys.version_info >= (3, 10): + from typing import TypeAlias +else: + from typing_extensions import TypeAlias + +StrOrBytesPath: TypeAlias = Union[str, bytes, "PathLike[str]", "PathLike[bytes]"] + + +async def run_process( + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + input: bytes | None = None, + stdin: int | IO[Any] | None = None, + stdout: int | IO[Any] | None = PIPE, + stderr: int | IO[Any] | None = PIPE, + check: bool = True, + cwd: StrOrBytesPath | None = None, + env: Mapping[str, str] | None = None, + startupinfo: Any = None, + creationflags: int = 0, + start_new_session: bool = False, + pass_fds: Sequence[int] = (), + user: str | int | None = None, + group: str | int | None = None, + extra_groups: Iterable[str | int] | None = None, + umask: int = -1, +) -> CompletedProcess[bytes]: + """ + Run an external command in a subprocess and wait until it completes. + + .. seealso:: :func:`subprocess.run` + + :param command: either a string to pass to the shell, or an iterable of strings + containing the executable name or path and its arguments + :param input: bytes passed to the standard input of the subprocess + :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + a file-like object, or `None`; ``input`` overrides this + :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + a file-like object, or `None` + :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + :data:`subprocess.STDOUT`, a file-like object, or `None` + :param check: if ``True``, raise :exc:`~subprocess.CalledProcessError` if the + process terminates with a return code other than 0 + :param cwd: If not ``None``, change the working directory to this before running the + command + :param env: if not ``None``, this mapping replaces the inherited environment + variables from the parent process + :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used + to specify process startup parameters (Windows only) + :param creationflags: flags that can be used to control the creation of the + subprocess (see :class:`subprocess.Popen` for the specifics) + :param start_new_session: if ``true`` the setsid() system call will be made in the + child process prior to the execution of the subprocess. (POSIX only) + :param pass_fds: sequence of file descriptors to keep open between the parent and + child processes. (POSIX only) + :param user: effective user to run the process as (Python >= 3.9, POSIX only) + :param group: effective group to run the process as (Python >= 3.9, POSIX only) + :param extra_groups: supplementary groups to set in the subprocess (Python >= 3.9, + POSIX only) + :param umask: if not negative, this umask is applied in the child process before + running the given command (Python >= 3.9, POSIX only) + :return: an object representing the completed process + :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process + exits with a nonzero return code + + """ + + async def drain_stream(stream: AsyncIterable[bytes], index: int) -> None: + buffer = BytesIO() + async for chunk in stream: + buffer.write(chunk) + + stream_contents[index] = buffer.getvalue() + + if stdin is not None and input is not None: + raise ValueError("only one of stdin and input is allowed") + + async with await open_process( + command, + stdin=PIPE if input else stdin, + stdout=stdout, + stderr=stderr, + cwd=cwd, + env=env, + startupinfo=startupinfo, + creationflags=creationflags, + start_new_session=start_new_session, + pass_fds=pass_fds, + user=user, + group=group, + extra_groups=extra_groups, + umask=umask, + ) as process: + stream_contents: list[bytes | None] = [None, None] + async with create_task_group() as tg: + if process.stdout: + tg.start_soon(drain_stream, process.stdout, 0) + + if process.stderr: + tg.start_soon(drain_stream, process.stderr, 1) + + if process.stdin and input: + await process.stdin.send(input) + await process.stdin.aclose() + + await process.wait() + + output, errors = stream_contents + if check and process.returncode != 0: + raise CalledProcessError(cast(int, process.returncode), command, output, errors) + + return CompletedProcess(command, cast(int, process.returncode), output, errors) + + +async def open_process( + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + stdin: int | IO[Any] | None = PIPE, + stdout: int | IO[Any] | None = PIPE, + stderr: int | IO[Any] | None = PIPE, + cwd: StrOrBytesPath | None = None, + env: Mapping[str, str] | None = None, + startupinfo: Any = None, + creationflags: int = 0, + start_new_session: bool = False, + pass_fds: Sequence[int] = (), + user: str | int | None = None, + group: str | int | None = None, + extra_groups: Iterable[str | int] | None = None, + umask: int = -1, +) -> Process: + """ + Start an external command in a subprocess. + + .. seealso:: :class:`subprocess.Popen` + + :param command: either a string to pass to the shell, or an iterable of strings + containing the executable name or path and its arguments + :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, a + file-like object, or ``None`` + :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + a file-like object, or ``None`` + :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + :data:`subprocess.STDOUT`, a file-like object, or ``None`` + :param cwd: If not ``None``, the working directory is changed before executing + :param env: If env is not ``None``, it must be a mapping that defines the + environment variables for the new process + :param creationflags: flags that can be used to control the creation of the + subprocess (see :class:`subprocess.Popen` for the specifics) + :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used + to specify process startup parameters (Windows only) + :param start_new_session: if ``true`` the setsid() system call will be made in the + child process prior to the execution of the subprocess. (POSIX only) + :param pass_fds: sequence of file descriptors to keep open between the parent and + child processes. (POSIX only) + :param user: effective user to run the process as (POSIX only) + :param group: effective group to run the process as (POSIX only) + :param extra_groups: supplementary groups to set in the subprocess (POSIX only) + :param umask: if not negative, this umask is applied in the child process before + running the given command (POSIX only) + :return: an asynchronous process object + + """ + kwargs: dict[str, Any] = {} + if user is not None: + kwargs["user"] = user + + if group is not None: + kwargs["group"] = group + + if extra_groups is not None: + kwargs["extra_groups"] = group + + if umask >= 0: + kwargs["umask"] = umask + + return await get_async_backend().open_process( + command, + stdin=stdin, + stdout=stdout, + stderr=stderr, + cwd=cwd, + env=env, + startupinfo=startupinfo, + creationflags=creationflags, + start_new_session=start_new_session, + pass_fds=pass_fds, + **kwargs, + ) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_synchronization.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_synchronization.py new file mode 100644 index 0000000000000000000000000000000000000000..c0ef27a686f22f77d5ec3f404005e2805fa46a64 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_synchronization.py @@ -0,0 +1,753 @@ +from __future__ import annotations + +import math +from collections import deque +from collections.abc import Callable +from dataclasses import dataclass +from types import TracebackType +from typing import TypeVar + +from ..lowlevel import checkpoint_if_cancelled +from ._eventloop import get_async_backend +from ._exceptions import BusyResourceError, NoEventLoopError +from ._tasks import CancelScope +from ._testing import TaskInfo, get_current_task + +T = TypeVar("T") + + +@dataclass(frozen=True) +class EventStatistics: + """ + :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Event.wait` + """ + + tasks_waiting: int + + +@dataclass(frozen=True) +class CapacityLimiterStatistics: + """ + :ivar int borrowed_tokens: number of tokens currently borrowed by tasks + :ivar float total_tokens: total number of available tokens + :ivar tuple borrowers: tasks or other objects currently holding tokens borrowed from + this limiter + :ivar int tasks_waiting: number of tasks waiting on + :meth:`~.CapacityLimiter.acquire` or + :meth:`~.CapacityLimiter.acquire_on_behalf_of` + """ + + borrowed_tokens: int + total_tokens: float + borrowers: tuple[object, ...] + tasks_waiting: int + + +@dataclass(frozen=True) +class LockStatistics: + """ + :ivar bool locked: flag indicating if this lock is locked or not + :ivar ~anyio.TaskInfo owner: task currently holding the lock (or ``None`` if the + lock is not held by any task) + :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Lock.acquire` + """ + + locked: bool + owner: TaskInfo | None + tasks_waiting: int + + +@dataclass(frozen=True) +class ConditionStatistics: + """ + :ivar int tasks_waiting: number of tasks blocked on :meth:`~.Condition.wait` + :ivar ~anyio.LockStatistics lock_statistics: statistics of the underlying + :class:`~.Lock` + """ + + tasks_waiting: int + lock_statistics: LockStatistics + + +@dataclass(frozen=True) +class SemaphoreStatistics: + """ + :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Semaphore.acquire` + + """ + + tasks_waiting: int + + +class Event: + def __new__(cls) -> Event: + try: + return get_async_backend().create_event() + except NoEventLoopError: + return EventAdapter() + + def set(self) -> None: + """Set the flag, notifying all listeners.""" + raise NotImplementedError + + def is_set(self) -> bool: + """Return ``True`` if the flag is set, ``False`` if not.""" + raise NotImplementedError + + async def wait(self) -> None: + """ + Wait until the flag has been set. + + If the flag has already been set when this method is called, it returns + immediately. + + """ + raise NotImplementedError + + def statistics(self) -> EventStatistics: + """Return statistics about the current state of this event.""" + raise NotImplementedError + + +class EventAdapter(Event): + _internal_event: Event | None = None + _is_set: bool = False + + def __new__(cls) -> EventAdapter: + return object.__new__(cls) + + @property + def _event(self) -> Event: + if self._internal_event is None: + self._internal_event = get_async_backend().create_event() + if self._is_set: + self._internal_event.set() + + return self._internal_event + + def set(self) -> None: + if self._internal_event is None: + self._is_set = True + else: + self._event.set() + + def is_set(self) -> bool: + if self._internal_event is None: + return self._is_set + + return self._internal_event.is_set() + + async def wait(self) -> None: + await self._event.wait() + + def statistics(self) -> EventStatistics: + if self._internal_event is None: + return EventStatistics(tasks_waiting=0) + + return self._internal_event.statistics() + + +class Lock: + def __new__(cls, *, fast_acquire: bool = False) -> Lock: + try: + return get_async_backend().create_lock(fast_acquire=fast_acquire) + except NoEventLoopError: + return LockAdapter(fast_acquire=fast_acquire) + + async def __aenter__(self) -> None: + await self.acquire() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.release() + + async def acquire(self) -> None: + """Acquire the lock.""" + raise NotImplementedError + + def acquire_nowait(self) -> None: + """ + Acquire the lock, without blocking. + + :raises ~anyio.WouldBlock: if the operation would block + + """ + raise NotImplementedError + + def release(self) -> None: + """Release the lock.""" + raise NotImplementedError + + def locked(self) -> bool: + """Return True if the lock is currently held.""" + raise NotImplementedError + + def statistics(self) -> LockStatistics: + """ + Return statistics about the current state of this lock. + + .. versionadded:: 3.0 + """ + raise NotImplementedError + + +class LockAdapter(Lock): + _internal_lock: Lock | None = None + + def __new__(cls, *, fast_acquire: bool = False) -> LockAdapter: + return object.__new__(cls) + + def __init__(self, *, fast_acquire: bool = False): + self._fast_acquire = fast_acquire + + @property + def _lock(self) -> Lock: + if self._internal_lock is None: + self._internal_lock = get_async_backend().create_lock( + fast_acquire=self._fast_acquire + ) + + return self._internal_lock + + async def __aenter__(self) -> None: + await self._lock.acquire() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + if self._internal_lock is not None: + self._internal_lock.release() + + async def acquire(self) -> None: + """Acquire the lock.""" + await self._lock.acquire() + + def acquire_nowait(self) -> None: + """ + Acquire the lock, without blocking. + + :raises ~anyio.WouldBlock: if the operation would block + + """ + self._lock.acquire_nowait() + + def release(self) -> None: + """Release the lock.""" + self._lock.release() + + def locked(self) -> bool: + """Return True if the lock is currently held.""" + return self._lock.locked() + + def statistics(self) -> LockStatistics: + """ + Return statistics about the current state of this lock. + + .. versionadded:: 3.0 + + """ + if self._internal_lock is None: + return LockStatistics(False, None, 0) + + return self._internal_lock.statistics() + + +class Condition: + _owner_task: TaskInfo | None = None + + def __init__(self, lock: Lock | None = None): + self._lock = lock or Lock() + self._waiters: deque[Event] = deque() + + async def __aenter__(self) -> None: + await self.acquire() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.release() + + def _check_acquired(self) -> None: + if self._owner_task != get_current_task(): + raise RuntimeError("The current task is not holding the underlying lock") + + async def acquire(self) -> None: + """Acquire the underlying lock.""" + await self._lock.acquire() + self._owner_task = get_current_task() + + def acquire_nowait(self) -> None: + """ + Acquire the underlying lock, without blocking. + + :raises ~anyio.WouldBlock: if the operation would block + + """ + self._lock.acquire_nowait() + self._owner_task = get_current_task() + + def release(self) -> None: + """Release the underlying lock.""" + self._lock.release() + + def locked(self) -> bool: + """Return True if the lock is set.""" + return self._lock.locked() + + def notify(self, n: int = 1) -> None: + """Notify exactly n listeners.""" + self._check_acquired() + for _ in range(n): + try: + event = self._waiters.popleft() + except IndexError: + break + + event.set() + + def notify_all(self) -> None: + """Notify all the listeners.""" + self._check_acquired() + for event in self._waiters: + event.set() + + self._waiters.clear() + + async def wait(self) -> None: + """Wait for a notification.""" + await checkpoint_if_cancelled() + self._check_acquired() + event = Event() + self._waiters.append(event) + self.release() + try: + await event.wait() + except BaseException: + if not event.is_set(): + self._waiters.remove(event) + + raise + finally: + with CancelScope(shield=True): + await self.acquire() + + async def wait_for(self, predicate: Callable[[], T]) -> T: + """ + Wait until a predicate becomes true. + + :param predicate: a callable that returns a truthy value when the condition is + met + :return: the result of the predicate + + .. versionadded:: 4.11.0 + + """ + while not (result := predicate()): + await self.wait() + + return result + + def statistics(self) -> ConditionStatistics: + """ + Return statistics about the current state of this condition. + + .. versionadded:: 3.0 + """ + return ConditionStatistics(len(self._waiters), self._lock.statistics()) + + +class Semaphore: + def __new__( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> Semaphore: + try: + return get_async_backend().create_semaphore( + initial_value, max_value=max_value, fast_acquire=fast_acquire + ) + except NoEventLoopError: + return SemaphoreAdapter(initial_value, max_value=max_value) + + def __init__( + self, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ): + if not isinstance(initial_value, int): + raise TypeError("initial_value must be an integer") + if initial_value < 0: + raise ValueError("initial_value must be >= 0") + if max_value is not None: + if not isinstance(max_value, int): + raise TypeError("max_value must be an integer or None") + if max_value < initial_value: + raise ValueError( + "max_value must be equal to or higher than initial_value" + ) + + self._fast_acquire = fast_acquire + + async def __aenter__(self) -> Semaphore: + await self.acquire() + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.release() + + async def acquire(self) -> None: + """Decrement the semaphore value, blocking if necessary.""" + raise NotImplementedError + + def acquire_nowait(self) -> None: + """ + Acquire the underlying lock, without blocking. + + :raises ~anyio.WouldBlock: if the operation would block + + """ + raise NotImplementedError + + def release(self) -> None: + """Increment the semaphore value.""" + raise NotImplementedError + + @property + def value(self) -> int: + """The current value of the semaphore.""" + raise NotImplementedError + + @property + def max_value(self) -> int | None: + """The maximum value of the semaphore.""" + raise NotImplementedError + + def statistics(self) -> SemaphoreStatistics: + """ + Return statistics about the current state of this semaphore. + + .. versionadded:: 3.0 + """ + raise NotImplementedError + + +class SemaphoreAdapter(Semaphore): + _internal_semaphore: Semaphore | None = None + + def __new__( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> SemaphoreAdapter: + return object.__new__(cls) + + def __init__( + self, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> None: + super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire) + self._initial_value = initial_value + self._max_value = max_value + + @property + def _semaphore(self) -> Semaphore: + if self._internal_semaphore is None: + self._internal_semaphore = get_async_backend().create_semaphore( + self._initial_value, max_value=self._max_value + ) + + return self._internal_semaphore + + async def acquire(self) -> None: + await self._semaphore.acquire() + + def acquire_nowait(self) -> None: + self._semaphore.acquire_nowait() + + def release(self) -> None: + self._semaphore.release() + + @property + def value(self) -> int: + if self._internal_semaphore is None: + return self._initial_value + + return self._semaphore.value + + @property + def max_value(self) -> int | None: + return self._max_value + + def statistics(self) -> SemaphoreStatistics: + if self._internal_semaphore is None: + return SemaphoreStatistics(tasks_waiting=0) + + return self._semaphore.statistics() + + +class CapacityLimiter: + def __new__(cls, total_tokens: float) -> CapacityLimiter: + try: + return get_async_backend().create_capacity_limiter(total_tokens) + except NoEventLoopError: + return CapacityLimiterAdapter(total_tokens) + + async def __aenter__(self) -> None: + raise NotImplementedError + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + raise NotImplementedError + + @property + def total_tokens(self) -> float: + """ + The total number of tokens available for borrowing. + + This is a read-write property. If the total number of tokens is increased, the + proportionate number of tasks waiting on this limiter will be granted their + tokens. + + .. versionchanged:: 3.0 + The property is now writable. + .. versionchanged:: 4.12 + The value can now be set to 0. + + """ + raise NotImplementedError + + @total_tokens.setter + def total_tokens(self, value: float) -> None: + raise NotImplementedError + + @property + def borrowed_tokens(self) -> int: + """The number of tokens that have currently been borrowed.""" + raise NotImplementedError + + @property + def available_tokens(self) -> float: + """The number of tokens currently available to be borrowed""" + raise NotImplementedError + + def acquire_nowait(self) -> None: + """ + Acquire a token for the current task without waiting for one to become + available. + + :raises ~anyio.WouldBlock: if there are no tokens available for borrowing + + """ + raise NotImplementedError + + def acquire_on_behalf_of_nowait(self, borrower: object) -> None: + """ + Acquire a token without waiting for one to become available. + + :param borrower: the entity borrowing a token + :raises ~anyio.WouldBlock: if there are no tokens available for borrowing + + """ + raise NotImplementedError + + async def acquire(self) -> None: + """ + Acquire a token for the current task, waiting if necessary for one to become + available. + + """ + raise NotImplementedError + + async def acquire_on_behalf_of(self, borrower: object) -> None: + """ + Acquire a token, waiting if necessary for one to become available. + + :param borrower: the entity borrowing a token + + """ + raise NotImplementedError + + def release(self) -> None: + """ + Release the token held by the current task. + + :raises RuntimeError: if the current task has not borrowed a token from this + limiter. + + """ + raise NotImplementedError + + def release_on_behalf_of(self, borrower: object) -> None: + """ + Release the token held by the given borrower. + + :raises RuntimeError: if the borrower has not borrowed a token from this + limiter. + + """ + raise NotImplementedError + + def statistics(self) -> CapacityLimiterStatistics: + """ + Return statistics about the current state of this limiter. + + .. versionadded:: 3.0 + + """ + raise NotImplementedError + + +class CapacityLimiterAdapter(CapacityLimiter): + _internal_limiter: CapacityLimiter | None = None + + def __new__(cls, total_tokens: float) -> CapacityLimiterAdapter: + return object.__new__(cls) + + def __init__(self, total_tokens: float) -> None: + self.total_tokens = total_tokens + + @property + def _limiter(self) -> CapacityLimiter: + if self._internal_limiter is None: + self._internal_limiter = get_async_backend().create_capacity_limiter( + self._total_tokens + ) + + return self._internal_limiter + + async def __aenter__(self) -> None: + await self._limiter.__aenter__() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + return await self._limiter.__aexit__(exc_type, exc_val, exc_tb) + + @property + def total_tokens(self) -> float: + if self._internal_limiter is None: + return self._total_tokens + + return self._internal_limiter.total_tokens + + @total_tokens.setter + def total_tokens(self, value: float) -> None: + if not isinstance(value, int) and value is not math.inf: + raise TypeError("total_tokens must be an int or math.inf") + elif value < 1: + raise ValueError("total_tokens must be >= 1") + + if self._internal_limiter is None: + self._total_tokens = value + return + + self._limiter.total_tokens = value + + @property + def borrowed_tokens(self) -> int: + if self._internal_limiter is None: + return 0 + + return self._internal_limiter.borrowed_tokens + + @property + def available_tokens(self) -> float: + if self._internal_limiter is None: + return self._total_tokens + + return self._internal_limiter.available_tokens + + def acquire_nowait(self) -> None: + self._limiter.acquire_nowait() + + def acquire_on_behalf_of_nowait(self, borrower: object) -> None: + self._limiter.acquire_on_behalf_of_nowait(borrower) + + async def acquire(self) -> None: + await self._limiter.acquire() + + async def acquire_on_behalf_of(self, borrower: object) -> None: + await self._limiter.acquire_on_behalf_of(borrower) + + def release(self) -> None: + self._limiter.release() + + def release_on_behalf_of(self, borrower: object) -> None: + self._limiter.release_on_behalf_of(borrower) + + def statistics(self) -> CapacityLimiterStatistics: + if self._internal_limiter is None: + return CapacityLimiterStatistics( + borrowed_tokens=0, + total_tokens=self.total_tokens, + borrowers=(), + tasks_waiting=0, + ) + + return self._internal_limiter.statistics() + + +class ResourceGuard: + """ + A context manager for ensuring that a resource is only used by a single task at a + time. + + Entering this context manager while the previous has not exited it yet will trigger + :exc:`BusyResourceError`. + + :param action: the action to guard against (visible in the :exc:`BusyResourceError` + when triggered, e.g. "Another task is already {action} this resource") + + .. versionadded:: 4.1 + """ + + __slots__ = "action", "_guarded" + + def __init__(self, action: str = "using"): + self.action: str = action + self._guarded = False + + def __enter__(self) -> None: + if self._guarded: + raise BusyResourceError(self.action) + + self._guarded = True + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self._guarded = False diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_tasks.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_tasks.py new file mode 100644 index 0000000000000000000000000000000000000000..0688bfe960cf9747373c93e482a64d1369befa11 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_tasks.py @@ -0,0 +1,173 @@ +from __future__ import annotations + +import math +from collections.abc import Generator +from contextlib import contextmanager +from types import TracebackType + +from ..abc._tasks import TaskGroup, TaskStatus +from ._eventloop import get_async_backend + + +class _IgnoredTaskStatus(TaskStatus[object]): + def started(self, value: object = None) -> None: + pass + + +TASK_STATUS_IGNORED = _IgnoredTaskStatus() + + +class CancelScope: + """ + Wraps a unit of work that can be made separately cancellable. + + :param deadline: The time (clock value) when this scope is cancelled automatically + :param shield: ``True`` to shield the cancel scope from external cancellation + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + """ + + def __new__( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> CancelScope: + return get_async_backend().create_cancel_scope(shield=shield, deadline=deadline) + + def cancel(self, reason: str | None = None) -> None: + """ + Cancel this scope immediately. + + :param reason: a message describing the reason for the cancellation + + """ + raise NotImplementedError + + @property + def deadline(self) -> float: + """ + The time (clock value) when this scope is cancelled automatically. + + Will be ``float('inf')`` if no timeout has been set. + + """ + raise NotImplementedError + + @deadline.setter + def deadline(self, value: float) -> None: + raise NotImplementedError + + @property + def cancel_called(self) -> bool: + """``True`` if :meth:`cancel` has been called.""" + raise NotImplementedError + + @property + def cancelled_caught(self) -> bool: + """ + ``True`` if this scope suppressed a cancellation exception it itself raised. + + This is typically used to check if any work was interrupted, or to see if the + scope was cancelled due to its deadline being reached. The value will, however, + only be ``True`` if the cancellation was triggered by the scope itself (and not + an outer scope). + + """ + raise NotImplementedError + + @property + def shield(self) -> bool: + """ + ``True`` if this scope is shielded from external cancellation. + + While a scope is shielded, it will not receive cancellations from outside. + + """ + raise NotImplementedError + + @shield.setter + def shield(self, value: bool) -> None: + raise NotImplementedError + + def __enter__(self) -> CancelScope: + raise NotImplementedError + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + raise NotImplementedError + + +@contextmanager +def fail_after( + delay: float | None, shield: bool = False +) -> Generator[CancelScope, None, None]: + """ + Create a context manager which raises a :class:`TimeoutError` if does not finish in + time. + + :param delay: maximum allowed time (in seconds) before raising the exception, or + ``None`` to disable the timeout + :param shield: ``True`` to shield the cancel scope from external cancellation + :return: a context manager that yields a cancel scope + :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.CancelScope`\\] + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + current_time = get_async_backend().current_time + deadline = (current_time() + delay) if delay is not None else math.inf + with get_async_backend().create_cancel_scope( + deadline=deadline, shield=shield + ) as cancel_scope: + yield cancel_scope + + if cancel_scope.cancelled_caught and current_time() >= cancel_scope.deadline: + raise TimeoutError + + +def move_on_after(delay: float | None, shield: bool = False) -> CancelScope: + """ + Create a cancel scope with a deadline that expires after the given delay. + + :param delay: maximum allowed time (in seconds) before exiting the context block, or + ``None`` to disable the timeout + :param shield: ``True`` to shield the cancel scope from external cancellation + :return: a cancel scope + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + deadline = ( + (get_async_backend().current_time() + delay) if delay is not None else math.inf + ) + return get_async_backend().create_cancel_scope(deadline=deadline, shield=shield) + + +def current_effective_deadline() -> float: + """ + Return the nearest deadline among all the cancel scopes effective for the current + task. + + :return: a clock value from the event loop's internal clock (or ``float('inf')`` if + there is no deadline in effect, or ``float('-inf')`` if the current scope has + been cancelled) + :rtype: float + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().current_effective_deadline() + + +def create_task_group() -> TaskGroup: + """ + Create a task group. + + :return: a task group + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().create_task_group() diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_tempfile.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_tempfile.py new file mode 100644 index 0000000000000000000000000000000000000000..fbb6b14a9a8eae9dcaa66eb68ac36d2084617877 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_tempfile.py @@ -0,0 +1,616 @@ +from __future__ import annotations + +import os +import sys +import tempfile +from collections.abc import Iterable +from io import BytesIO, TextIOWrapper +from types import TracebackType +from typing import ( + TYPE_CHECKING, + Any, + AnyStr, + Generic, + overload, +) + +from .. import to_thread +from .._core._fileio import AsyncFile +from ..lowlevel import checkpoint_if_cancelled + +if TYPE_CHECKING: + from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer + + +class TemporaryFile(Generic[AnyStr]): + """ + An asynchronous temporary file that is automatically created and cleaned up. + + This class provides an asynchronous context manager interface to a temporary file. + The file is created using Python's standard `tempfile.TemporaryFile` function in a + background thread, and is wrapped as an asynchronous file using `AsyncFile`. + + :param mode: The mode in which the file is opened. Defaults to "w+b". + :param buffering: The buffering policy (-1 means the default buffering). + :param encoding: The encoding used to decode or encode the file. Only applicable in + text mode. + :param newline: Controls how universal newlines mode works (only applicable in text + mode). + :param suffix: The suffix for the temporary file name. + :param prefix: The prefix for the temporary file name. + :param dir: The directory in which the temporary file is created. + :param errors: The error handling scheme used for encoding/decoding errors. + """ + + _async_file: AsyncFile[AnyStr] + + @overload + def __init__( + self: TemporaryFile[bytes], + mode: OpenBinaryMode = ..., + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + *, + errors: str | None = ..., + ): ... + @overload + def __init__( + self: TemporaryFile[str], + mode: OpenTextMode, + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + *, + errors: str | None = ..., + ): ... + + def __init__( + self, + mode: OpenTextMode | OpenBinaryMode = "w+b", + buffering: int = -1, + encoding: str | None = None, + newline: str | None = None, + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, + *, + errors: str | None = None, + ) -> None: + self.mode = mode + self.buffering = buffering + self.encoding = encoding + self.newline = newline + self.suffix: str | None = suffix + self.prefix: str | None = prefix + self.dir: str | None = dir + self.errors = errors + + async def __aenter__(self) -> AsyncFile[AnyStr]: + fp = await to_thread.run_sync( + lambda: tempfile.TemporaryFile( + self.mode, + self.buffering, + self.encoding, + self.newline, + self.suffix, + self.prefix, + self.dir, + errors=self.errors, + ) + ) + self._async_file = AsyncFile(fp) + return self._async_file + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + await self._async_file.aclose() + + +class NamedTemporaryFile(Generic[AnyStr]): + """ + An asynchronous named temporary file that is automatically created and cleaned up. + + This class provides an asynchronous context manager for a temporary file with a + visible name in the file system. It uses Python's standard + :func:`~tempfile.NamedTemporaryFile` function and wraps the file object with + :class:`AsyncFile` for asynchronous operations. + + :param mode: The mode in which the file is opened. Defaults to "w+b". + :param buffering: The buffering policy (-1 means the default buffering). + :param encoding: The encoding used to decode or encode the file. Only applicable in + text mode. + :param newline: Controls how universal newlines mode works (only applicable in text + mode). + :param suffix: The suffix for the temporary file name. + :param prefix: The prefix for the temporary file name. + :param dir: The directory in which the temporary file is created. + :param delete: Whether to delete the file when it is closed. + :param errors: The error handling scheme used for encoding/decoding errors. + :param delete_on_close: (Python 3.12+) Whether to delete the file on close. + """ + + _async_file: AsyncFile[AnyStr] + + @overload + def __init__( + self: NamedTemporaryFile[bytes], + mode: OpenBinaryMode = ..., + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + delete: bool = ..., + *, + errors: str | None = ..., + delete_on_close: bool = ..., + ): ... + @overload + def __init__( + self: NamedTemporaryFile[str], + mode: OpenTextMode, + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + delete: bool = ..., + *, + errors: str | None = ..., + delete_on_close: bool = ..., + ): ... + + def __init__( + self, + mode: OpenBinaryMode | OpenTextMode = "w+b", + buffering: int = -1, + encoding: str | None = None, + newline: str | None = None, + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, + delete: bool = True, + *, + errors: str | None = None, + delete_on_close: bool = True, + ) -> None: + self._params: dict[str, Any] = { + "mode": mode, + "buffering": buffering, + "encoding": encoding, + "newline": newline, + "suffix": suffix, + "prefix": prefix, + "dir": dir, + "delete": delete, + "errors": errors, + } + if sys.version_info >= (3, 12): + self._params["delete_on_close"] = delete_on_close + + async def __aenter__(self) -> AsyncFile[AnyStr]: + fp = await to_thread.run_sync( + lambda: tempfile.NamedTemporaryFile(**self._params) + ) + self._async_file = AsyncFile(fp) + return self._async_file + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + await self._async_file.aclose() + + +class SpooledTemporaryFile(AsyncFile[AnyStr]): + """ + An asynchronous spooled temporary file that starts in memory and is spooled to disk. + + This class provides an asynchronous interface to a spooled temporary file, much like + Python's standard :class:`~tempfile.SpooledTemporaryFile`. It supports asynchronous + write operations and provides a method to force a rollover to disk. + + :param max_size: Maximum size in bytes before the file is rolled over to disk. + :param mode: The mode in which the file is opened. Defaults to "w+b". + :param buffering: The buffering policy (-1 means the default buffering). + :param encoding: The encoding used to decode or encode the file (text mode only). + :param newline: Controls how universal newlines mode works (text mode only). + :param suffix: The suffix for the temporary file name. + :param prefix: The prefix for the temporary file name. + :param dir: The directory in which the temporary file is created. + :param errors: The error handling scheme used for encoding/decoding errors. + """ + + _rolled: bool = False + + @overload + def __init__( + self: SpooledTemporaryFile[bytes], + max_size: int = ..., + mode: OpenBinaryMode = ..., + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + *, + errors: str | None = ..., + ): ... + @overload + def __init__( + self: SpooledTemporaryFile[str], + max_size: int = ..., + mode: OpenTextMode = ..., + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + *, + errors: str | None = ..., + ): ... + + def __init__( + self, + max_size: int = 0, + mode: OpenBinaryMode | OpenTextMode = "w+b", + buffering: int = -1, + encoding: str | None = None, + newline: str | None = None, + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, + *, + errors: str | None = None, + ) -> None: + self._tempfile_params: dict[str, Any] = { + "mode": mode, + "buffering": buffering, + "encoding": encoding, + "newline": newline, + "suffix": suffix, + "prefix": prefix, + "dir": dir, + "errors": errors, + } + self._max_size = max_size + if "b" in mode: + super().__init__(BytesIO()) # type: ignore[arg-type] + else: + super().__init__( + TextIOWrapper( # type: ignore[arg-type] + BytesIO(), + encoding=encoding, + errors=errors, + newline=newline, + write_through=True, + ) + ) + + async def aclose(self) -> None: + if not self._rolled: + self._fp.close() + return + + await super().aclose() + + async def _check(self) -> None: + if self._rolled or self._fp.tell() <= self._max_size: + return + + await self.rollover() + + async def rollover(self) -> None: + if self._rolled: + return + + self._rolled = True + buffer = self._fp + buffer.seek(0) + self._fp = await to_thread.run_sync( + lambda: tempfile.TemporaryFile(**self._tempfile_params) + ) + await self.write(buffer.read()) + buffer.close() + + @property + def closed(self) -> bool: + return self._fp.closed + + async def read(self, size: int = -1) -> AnyStr: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.read(size) + + return await super().read(size) # type: ignore[return-value] + + async def read1(self: SpooledTemporaryFile[bytes], size: int = -1) -> bytes: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.read1(size) + + return await super().read1(size) + + async def readline(self) -> AnyStr: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.readline() + + return await super().readline() # type: ignore[return-value] + + async def readlines(self) -> list[AnyStr]: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.readlines() + + return await super().readlines() # type: ignore[return-value] + + async def readinto(self: SpooledTemporaryFile[bytes], b: WriteableBuffer) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + self._fp.readinto(b) + + return await super().readinto(b) + + async def readinto1(self: SpooledTemporaryFile[bytes], b: WriteableBuffer) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + self._fp.readinto(b) + + return await super().readinto1(b) + + async def seek(self, offset: int, whence: int | None = os.SEEK_SET) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.seek(offset, whence) + + return await super().seek(offset, whence) + + async def tell(self) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.tell() + + return await super().tell() + + async def truncate(self, size: int | None = None) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.truncate(size) + + return await super().truncate(size) + + @overload + async def write(self: SpooledTemporaryFile[bytes], b: ReadableBuffer) -> int: ... + @overload + async def write(self: SpooledTemporaryFile[str], b: str) -> int: ... + + async def write(self, b: ReadableBuffer | str) -> int: + """ + Asynchronously write data to the spooled temporary file. + + If the file has not yet been rolled over, the data is written synchronously, + and a rollover is triggered if the size exceeds the maximum size. + + :param s: The data to write. + :return: The number of bytes written. + :raises RuntimeError: If the underlying file is not initialized. + + """ + if not self._rolled: + await checkpoint_if_cancelled() + result = self._fp.write(b) + await self._check() + return result + + return await super().write(b) # type: ignore[misc] + + @overload + async def writelines( + self: SpooledTemporaryFile[bytes], lines: Iterable[ReadableBuffer] + ) -> None: ... + @overload + async def writelines( + self: SpooledTemporaryFile[str], lines: Iterable[str] + ) -> None: ... + + async def writelines(self, lines: Iterable[str] | Iterable[ReadableBuffer]) -> None: + """ + Asynchronously write a list of lines to the spooled temporary file. + + If the file has not yet been rolled over, the lines are written synchronously, + and a rollover is triggered if the size exceeds the maximum size. + + :param lines: An iterable of lines to write. + :raises RuntimeError: If the underlying file is not initialized. + + """ + if not self._rolled: + await checkpoint_if_cancelled() + result = self._fp.writelines(lines) + await self._check() + return result + + return await super().writelines(lines) # type: ignore[misc] + + +class TemporaryDirectory(Generic[AnyStr]): + """ + An asynchronous temporary directory that is created and cleaned up automatically. + + This class provides an asynchronous context manager for creating a temporary + directory. It wraps Python's standard :class:`~tempfile.TemporaryDirectory` to + perform directory creation and cleanup operations in a background thread. + + :param suffix: Suffix to be added to the temporary directory name. + :param prefix: Prefix to be added to the temporary directory name. + :param dir: The parent directory where the temporary directory is created. + :param ignore_cleanup_errors: Whether to ignore errors during cleanup + (Python 3.10+). + :param delete: Whether to delete the directory upon closing (Python 3.12+). + """ + + def __init__( + self, + suffix: AnyStr | None = None, + prefix: AnyStr | None = None, + dir: AnyStr | None = None, + *, + ignore_cleanup_errors: bool = False, + delete: bool = True, + ) -> None: + self.suffix: AnyStr | None = suffix + self.prefix: AnyStr | None = prefix + self.dir: AnyStr | None = dir + self.ignore_cleanup_errors = ignore_cleanup_errors + self.delete = delete + + self._tempdir: tempfile.TemporaryDirectory | None = None + + async def __aenter__(self) -> str: + params: dict[str, Any] = { + "suffix": self.suffix, + "prefix": self.prefix, + "dir": self.dir, + } + if sys.version_info >= (3, 10): + params["ignore_cleanup_errors"] = self.ignore_cleanup_errors + + if sys.version_info >= (3, 12): + params["delete"] = self.delete + + self._tempdir = await to_thread.run_sync( + lambda: tempfile.TemporaryDirectory(**params) + ) + return await to_thread.run_sync(self._tempdir.__enter__) + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + if self._tempdir is not None: + await to_thread.run_sync( + self._tempdir.__exit__, exc_type, exc_value, traceback + ) + + async def cleanup(self) -> None: + if self._tempdir is not None: + await to_thread.run_sync(self._tempdir.cleanup) + + +@overload +async def mkstemp( + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, + text: bool = False, +) -> tuple[int, str]: ... + + +@overload +async def mkstemp( + suffix: bytes | None = None, + prefix: bytes | None = None, + dir: bytes | None = None, + text: bool = False, +) -> tuple[int, bytes]: ... + + +async def mkstemp( + suffix: AnyStr | None = None, + prefix: AnyStr | None = None, + dir: AnyStr | None = None, + text: bool = False, +) -> tuple[int, str | bytes]: + """ + Asynchronously create a temporary file and return an OS-level handle and the file + name. + + This function wraps `tempfile.mkstemp` and executes it in a background thread. + + :param suffix: Suffix to be added to the file name. + :param prefix: Prefix to be added to the file name. + :param dir: Directory in which the temporary file is created. + :param text: Whether the file is opened in text mode. + :return: A tuple containing the file descriptor and the file name. + + """ + return await to_thread.run_sync(tempfile.mkstemp, suffix, prefix, dir, text) + + +@overload +async def mkdtemp( + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, +) -> str: ... + + +@overload +async def mkdtemp( + suffix: bytes | None = None, + prefix: bytes | None = None, + dir: bytes | None = None, +) -> bytes: ... + + +async def mkdtemp( + suffix: AnyStr | None = None, + prefix: AnyStr | None = None, + dir: AnyStr | None = None, +) -> str | bytes: + """ + Asynchronously create a temporary directory and return its path. + + This function wraps `tempfile.mkdtemp` and executes it in a background thread. + + :param suffix: Suffix to be added to the directory name. + :param prefix: Prefix to be added to the directory name. + :param dir: Parent directory where the temporary directory is created. + :return: The path of the created temporary directory. + + """ + return await to_thread.run_sync(tempfile.mkdtemp, suffix, prefix, dir) + + +async def gettempdir() -> str: + """ + Asynchronously return the name of the directory used for temporary files. + + This function wraps `tempfile.gettempdir` and executes it in a background thread. + + :return: The path of the temporary directory as a string. + + """ + return await to_thread.run_sync(tempfile.gettempdir) + + +async def gettempdirb() -> bytes: + """ + Asynchronously return the name of the directory used for temporary files in bytes. + + This function wraps `tempfile.gettempdirb` and executes it in a background thread. + + :return: The path of the temporary directory as bytes. + + """ + return await to_thread.run_sync(tempfile.gettempdirb) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_testing.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_testing.py new file mode 100644 index 0000000000000000000000000000000000000000..369e65c068a426e99b7e8571209e80ce35b71f47 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_testing.py @@ -0,0 +1,82 @@ +from __future__ import annotations + +from collections.abc import Awaitable, Generator +from typing import Any, cast + +from ._eventloop import get_async_backend + + +class TaskInfo: + """ + Represents an asynchronous task. + + :ivar int id: the unique identifier of the task + :ivar parent_id: the identifier of the parent task, if any + :vartype parent_id: Optional[int] + :ivar str name: the description of the task (if any) + :ivar ~collections.abc.Coroutine coro: the coroutine object of the task + """ + + __slots__ = "_name", "id", "parent_id", "name", "coro" + + def __init__( + self, + id: int, + parent_id: int | None, + name: str | None, + coro: Generator[Any, Any, Any] | Awaitable[Any], + ): + func = get_current_task + self._name = f"{func.__module__}.{func.__qualname__}" + self.id: int = id + self.parent_id: int | None = parent_id + self.name: str | None = name + self.coro: Generator[Any, Any, Any] | Awaitable[Any] = coro + + def __eq__(self, other: object) -> bool: + if isinstance(other, TaskInfo): + return self.id == other.id + + return NotImplemented + + def __hash__(self) -> int: + return hash(self.id) + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(id={self.id!r}, name={self.name!r})" + + def has_pending_cancellation(self) -> bool: + """ + Return ``True`` if the task has a cancellation pending, ``False`` otherwise. + + """ + return False + + +def get_current_task() -> TaskInfo: + """ + Return the current task. + + :return: a representation of the current task + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().get_current_task() + + +def get_running_tasks() -> list[TaskInfo]: + """ + Return a list of running tasks in the current event loop. + + :return: a list of task info objects + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return cast("list[TaskInfo]", get_async_backend().get_running_tasks()) + + +async def wait_all_tasks_blocked() -> None: + """Wait until all other tasks are waiting for something.""" + await get_async_backend().wait_all_tasks_blocked() diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_typedattr.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_typedattr.py new file mode 100644 index 0000000000000000000000000000000000000000..f358a448cb12739fd4eda4f4859d3a24ddd1de63 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/_core/_typedattr.py @@ -0,0 +1,81 @@ +from __future__ import annotations + +from collections.abc import Callable, Mapping +from typing import Any, TypeVar, final, overload + +from ._exceptions import TypedAttributeLookupError + +T_Attr = TypeVar("T_Attr") +T_Default = TypeVar("T_Default") +undefined = object() + + +def typed_attribute() -> Any: + """Return a unique object, used to mark typed attributes.""" + return object() + + +class TypedAttributeSet: + """ + Superclass for typed attribute collections. + + Checks that every public attribute of every subclass has a type annotation. + """ + + def __init_subclass__(cls) -> None: + annotations: dict[str, Any] = getattr(cls, "__annotations__", {}) + for attrname in dir(cls): + if not attrname.startswith("_") and attrname not in annotations: + raise TypeError( + f"Attribute {attrname!r} is missing its type annotation" + ) + + super().__init_subclass__() + + +class TypedAttributeProvider: + """Base class for classes that wish to provide typed extra attributes.""" + + @property + def extra_attributes(self) -> Mapping[T_Attr, Callable[[], T_Attr]]: + """ + A mapping of the extra attributes to callables that return the corresponding + values. + + If the provider wraps another provider, the attributes from that wrapper should + also be included in the returned mapping (but the wrapper may override the + callables from the wrapped instance). + + """ + return {} + + @overload + def extra(self, attribute: T_Attr) -> T_Attr: ... + + @overload + def extra(self, attribute: T_Attr, default: T_Default) -> T_Attr | T_Default: ... + + @final + def extra(self, attribute: Any, default: object = undefined) -> object: + """ + extra(attribute, default=undefined) + + Return the value of the given typed extra attribute. + + :param attribute: the attribute (member of a :class:`~TypedAttributeSet`) to + look for + :param default: the value that should be returned if no value is found for the + attribute + :raises ~anyio.TypedAttributeLookupError: if the search failed and no default + value was given + + """ + try: + getter = self.extra_attributes[attribute] + except KeyError: + if default is undefined: + raise TypedAttributeLookupError("Attribute not found") from None + else: + return default + + return getter() diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__init__.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d560ce3f1fa45a7ee4a3bc8958aa59702caa9d0c --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__init__.py @@ -0,0 +1,58 @@ +from __future__ import annotations + +from ._eventloop import AsyncBackend as AsyncBackend +from ._resources import AsyncResource as AsyncResource +from ._sockets import ConnectedUDPSocket as ConnectedUDPSocket +from ._sockets import ConnectedUNIXDatagramSocket as ConnectedUNIXDatagramSocket +from ._sockets import IPAddressType as IPAddressType +from ._sockets import IPSockAddrType as IPSockAddrType +from ._sockets import SocketAttribute as SocketAttribute +from ._sockets import SocketListener as SocketListener +from ._sockets import SocketStream as SocketStream +from ._sockets import UDPPacketType as UDPPacketType +from ._sockets import UDPSocket as UDPSocket +from ._sockets import UNIXDatagramPacketType as UNIXDatagramPacketType +from ._sockets import UNIXDatagramSocket as UNIXDatagramSocket +from ._sockets import UNIXSocketStream as UNIXSocketStream +from ._streams import AnyByteReceiveStream as AnyByteReceiveStream +from ._streams import AnyByteSendStream as AnyByteSendStream +from ._streams import AnyByteStream as AnyByteStream +from ._streams import AnyByteStreamConnectable as AnyByteStreamConnectable +from ._streams import AnyUnreliableByteReceiveStream as AnyUnreliableByteReceiveStream +from ._streams import AnyUnreliableByteSendStream as AnyUnreliableByteSendStream +from ._streams import AnyUnreliableByteStream as AnyUnreliableByteStream +from ._streams import ByteReceiveStream as ByteReceiveStream +from ._streams import ByteSendStream as ByteSendStream +from ._streams import ByteStream as ByteStream +from ._streams import ByteStreamConnectable as ByteStreamConnectable +from ._streams import Listener as Listener +from ._streams import ObjectReceiveStream as ObjectReceiveStream +from ._streams import ObjectSendStream as ObjectSendStream +from ._streams import ObjectStream as ObjectStream +from ._streams import ObjectStreamConnectable as ObjectStreamConnectable +from ._streams import UnreliableObjectReceiveStream as UnreliableObjectReceiveStream +from ._streams import UnreliableObjectSendStream as UnreliableObjectSendStream +from ._streams import UnreliableObjectStream as UnreliableObjectStream +from ._subprocesses import Process as Process +from ._tasks import TaskGroup as TaskGroup +from ._tasks import TaskStatus as TaskStatus +from ._testing import TestRunner as TestRunner + +# Re-exported here, for backwards compatibility +# isort: off +from .._core._synchronization import ( + CapacityLimiter as CapacityLimiter, + Condition as Condition, + Event as Event, + Lock as Lock, + Semaphore as Semaphore, +) +from .._core._tasks import CancelScope as CancelScope +from ..from_thread import BlockingPortal as BlockingPortal + +# Re-export imports so they look like they live directly in this package +for __value in list(locals().values()): + if getattr(__value, "__module__", "").startswith("anyio.abc."): + __value.__module__ = __name__ + +del __value diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/__init__.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be7b7d999b6f30f270f8a88f334aa5f399a9d4a9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/__init__.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_eventloop.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_eventloop.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4210c77573d24d14b4ef9d65a13348165a817b26 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_eventloop.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_resources.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_resources.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad1675252c240b495ca214a10586a54a7993403e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_resources.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_sockets.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_sockets.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..233bd799bd4e599f271131f3662168eaedd10a83 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_sockets.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_streams.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_streams.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bcb09f161b79cabdaf935edd89c15a97dc875dda Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_streams.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_subprocesses.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_subprocesses.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6dbafdaed1980a40ec3c8eb42c651546d9bef4e4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_subprocesses.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_tasks.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_tasks.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f40a9b37c36b8f38397fd48510c53692f6ed956e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_tasks.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_testing.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_testing.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aac076212df70510c32777a7c880c821309d6f75 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/__pycache__/_testing.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_eventloop.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_eventloop.py new file mode 100644 index 0000000000000000000000000000000000000000..b1bd085596d634939d9894c4725e5cb01726fcb3 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_eventloop.py @@ -0,0 +1,414 @@ +from __future__ import annotations + +import math +import sys +from abc import ABCMeta, abstractmethod +from collections.abc import AsyncIterator, Awaitable, Callable, Sequence +from contextlib import AbstractContextManager +from os import PathLike +from signal import Signals +from socket import AddressFamily, SocketKind, socket +from typing import ( + IO, + TYPE_CHECKING, + Any, + TypeVar, + Union, + overload, +) + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +if sys.version_info >= (3, 10): + from typing import TypeAlias +else: + from typing_extensions import TypeAlias + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike + + from .._core._synchronization import CapacityLimiter, Event, Lock, Semaphore + from .._core._tasks import CancelScope + from .._core._testing import TaskInfo + from ._sockets import ( + ConnectedUDPSocket, + ConnectedUNIXDatagramSocket, + IPSockAddrType, + SocketListener, + SocketStream, + UDPSocket, + UNIXDatagramSocket, + UNIXSocketStream, + ) + from ._subprocesses import Process + from ._tasks import TaskGroup + from ._testing import TestRunner + +T_Retval = TypeVar("T_Retval") +PosArgsT = TypeVarTuple("PosArgsT") +StrOrBytesPath: TypeAlias = Union[str, bytes, "PathLike[str]", "PathLike[bytes]"] + + +class AsyncBackend(metaclass=ABCMeta): + @classmethod + @abstractmethod + def run( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + kwargs: dict[str, Any], + options: dict[str, Any], + ) -> T_Retval: + """ + Run the given coroutine function in an asynchronous event loop. + + The current thread must not be already running an event loop. + + :param func: a coroutine function + :param args: positional arguments to ``func`` + :param kwargs: positional arguments to ``func`` + :param options: keyword arguments to call the backend ``run()`` implementation + with + :return: the return value of the coroutine function + """ + + @classmethod + @abstractmethod + def current_token(cls) -> object: + """ + Return an object that allows other threads to run code inside the event loop. + + :return: a token object, specific to the event loop running in the current + thread + """ + + @classmethod + @abstractmethod + def current_time(cls) -> float: + """ + Return the current value of the event loop's internal clock. + + :return: the clock value (seconds) + """ + + @classmethod + @abstractmethod + def cancelled_exception_class(cls) -> type[BaseException]: + """Return the exception class that is raised in a task if it's cancelled.""" + + @classmethod + @abstractmethod + async def checkpoint(cls) -> None: + """ + Check if the task has been cancelled, and allow rescheduling of other tasks. + + This is effectively the same as running :meth:`checkpoint_if_cancelled` and then + :meth:`cancel_shielded_checkpoint`. + """ + + @classmethod + async def checkpoint_if_cancelled(cls) -> None: + """ + Check if the current task group has been cancelled. + + This will check if the task has been cancelled, but will not allow other tasks + to be scheduled if not. + + """ + if cls.current_effective_deadline() == -math.inf: + await cls.checkpoint() + + @classmethod + async def cancel_shielded_checkpoint(cls) -> None: + """ + Allow the rescheduling of other tasks. + + This will give other tasks the opportunity to run, but without checking if the + current task group has been cancelled, unlike with :meth:`checkpoint`. + + """ + with cls.create_cancel_scope(shield=True): + await cls.sleep(0) + + @classmethod + @abstractmethod + async def sleep(cls, delay: float) -> None: + """ + Pause the current task for the specified duration. + + :param delay: the duration, in seconds + """ + + @classmethod + @abstractmethod + def create_cancel_scope( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> CancelScope: + pass + + @classmethod + @abstractmethod + def current_effective_deadline(cls) -> float: + """ + Return the nearest deadline among all the cancel scopes effective for the + current task. + + :return: + - a clock value from the event loop's internal clock + - ``inf`` if there is no deadline in effect + - ``-inf`` if the current scope has been cancelled + :rtype: float + """ + + @classmethod + @abstractmethod + def create_task_group(cls) -> TaskGroup: + pass + + @classmethod + @abstractmethod + def create_event(cls) -> Event: + pass + + @classmethod + @abstractmethod + def create_lock(cls, *, fast_acquire: bool) -> Lock: + pass + + @classmethod + @abstractmethod + def create_semaphore( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> Semaphore: + pass + + @classmethod + @abstractmethod + def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter: + pass + + @classmethod + @abstractmethod + async def run_sync_in_worker_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + abandon_on_cancel: bool = False, + limiter: CapacityLimiter | None = None, + ) -> T_Retval: + pass + + @classmethod + @abstractmethod + def check_cancelled(cls) -> None: + pass + + @classmethod + @abstractmethod + def run_async_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + pass + + @classmethod + @abstractmethod + def run_sync_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + pass + + @classmethod + @abstractmethod + async def open_process( + cls, + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + stdin: int | IO[Any] | None, + stdout: int | IO[Any] | None, + stderr: int | IO[Any] | None, + **kwargs: Any, + ) -> Process: + pass + + @classmethod + @abstractmethod + def setup_process_pool_exit_at_shutdown(cls, workers: set[Process]) -> None: + pass + + @classmethod + @abstractmethod + async def connect_tcp( + cls, host: str, port: int, local_address: IPSockAddrType | None = None + ) -> SocketStream: + pass + + @classmethod + @abstractmethod + async def connect_unix(cls, path: str | bytes) -> UNIXSocketStream: + pass + + @classmethod + @abstractmethod + def create_tcp_listener(cls, sock: socket) -> SocketListener: + pass + + @classmethod + @abstractmethod + def create_unix_listener(cls, sock: socket) -> SocketListener: + pass + + @classmethod + @abstractmethod + async def create_udp_socket( + cls, + family: AddressFamily, + local_address: IPSockAddrType | None, + remote_address: IPSockAddrType | None, + reuse_port: bool, + ) -> UDPSocket | ConnectedUDPSocket: + pass + + @classmethod + @overload + async def create_unix_datagram_socket( + cls, raw_socket: socket, remote_path: None + ) -> UNIXDatagramSocket: ... + + @classmethod + @overload + async def create_unix_datagram_socket( + cls, raw_socket: socket, remote_path: str | bytes + ) -> ConnectedUNIXDatagramSocket: ... + + @classmethod + @abstractmethod + async def create_unix_datagram_socket( + cls, raw_socket: socket, remote_path: str | bytes | None + ) -> UNIXDatagramSocket | ConnectedUNIXDatagramSocket: + pass + + @classmethod + @abstractmethod + async def getaddrinfo( + cls, + host: bytes | str | None, + port: str | int | None, + *, + family: int | AddressFamily = 0, + type: int | SocketKind = 0, + proto: int = 0, + flags: int = 0, + ) -> Sequence[ + tuple[ + AddressFamily, + SocketKind, + int, + str, + tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes], + ] + ]: + pass + + @classmethod + @abstractmethod + async def getnameinfo( + cls, sockaddr: IPSockAddrType, flags: int = 0 + ) -> tuple[str, str]: + pass + + @classmethod + @abstractmethod + async def wait_readable(cls, obj: FileDescriptorLike) -> None: + pass + + @classmethod + @abstractmethod + async def wait_writable(cls, obj: FileDescriptorLike) -> None: + pass + + @classmethod + @abstractmethod + def notify_closing(cls, obj: FileDescriptorLike) -> None: + pass + + @classmethod + @abstractmethod + async def wrap_listener_socket(cls, sock: socket) -> SocketListener: + pass + + @classmethod + @abstractmethod + async def wrap_stream_socket(cls, sock: socket) -> SocketStream: + pass + + @classmethod + @abstractmethod + async def wrap_unix_stream_socket(cls, sock: socket) -> UNIXSocketStream: + pass + + @classmethod + @abstractmethod + async def wrap_udp_socket(cls, sock: socket) -> UDPSocket: + pass + + @classmethod + @abstractmethod + async def wrap_connected_udp_socket(cls, sock: socket) -> ConnectedUDPSocket: + pass + + @classmethod + @abstractmethod + async def wrap_unix_datagram_socket(cls, sock: socket) -> UNIXDatagramSocket: + pass + + @classmethod + @abstractmethod + async def wrap_connected_unix_datagram_socket( + cls, sock: socket + ) -> ConnectedUNIXDatagramSocket: + pass + + @classmethod + @abstractmethod + def current_default_thread_limiter(cls) -> CapacityLimiter: + pass + + @classmethod + @abstractmethod + def open_signal_receiver( + cls, *signals: Signals + ) -> AbstractContextManager[AsyncIterator[Signals]]: + pass + + @classmethod + @abstractmethod + def get_current_task(cls) -> TaskInfo: + pass + + @classmethod + @abstractmethod + def get_running_tasks(cls) -> Sequence[TaskInfo]: + pass + + @classmethod + @abstractmethod + async def wait_all_tasks_blocked(cls) -> None: + pass + + @classmethod + @abstractmethod + def create_test_runner(cls, options: dict[str, Any]) -> TestRunner: + pass diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_resources.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_resources.py new file mode 100644 index 0000000000000000000000000000000000000000..10df115a7b9f975493476da763cc1e26dbd822e5 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_resources.py @@ -0,0 +1,33 @@ +from __future__ import annotations + +from abc import ABCMeta, abstractmethod +from types import TracebackType +from typing import TypeVar + +T = TypeVar("T") + + +class AsyncResource(metaclass=ABCMeta): + """ + Abstract base class for all closeable asynchronous resources. + + Works as an asynchronous context manager which returns the instance itself on enter, + and calls :meth:`aclose` on exit. + """ + + __slots__ = () + + async def __aenter__(self: T) -> T: + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + await self.aclose() + + @abstractmethod + async def aclose(self) -> None: + """Close the resource.""" diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_sockets.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_sockets.py new file mode 100644 index 0000000000000000000000000000000000000000..3ff60d4d9dfc3c15d416c9fc4a6b3b7f79a9fdb1 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_sockets.py @@ -0,0 +1,405 @@ +from __future__ import annotations + +import errno +import socket +import sys +from abc import abstractmethod +from collections.abc import Callable, Collection, Mapping +from contextlib import AsyncExitStack +from io import IOBase +from ipaddress import IPv4Address, IPv6Address +from socket import AddressFamily +from typing import Any, TypeVar, Union + +from .._core._eventloop import get_async_backend +from .._core._typedattr import ( + TypedAttributeProvider, + TypedAttributeSet, + typed_attribute, +) +from ._streams import ByteStream, Listener, UnreliableObjectStream +from ._tasks import TaskGroup + +if sys.version_info >= (3, 10): + from typing import TypeAlias +else: + from typing_extensions import TypeAlias + +IPAddressType: TypeAlias = Union[str, IPv4Address, IPv6Address] +IPSockAddrType: TypeAlias = tuple[str, int] +SockAddrType: TypeAlias = Union[IPSockAddrType, str] +UDPPacketType: TypeAlias = tuple[bytes, IPSockAddrType] +UNIXDatagramPacketType: TypeAlias = tuple[bytes, str] +T_Retval = TypeVar("T_Retval") + + +def _validate_socket( + sock_or_fd: socket.socket | int, + sock_type: socket.SocketKind, + addr_family: socket.AddressFamily = socket.AF_UNSPEC, + *, + require_connected: bool = False, + require_bound: bool = False, +) -> socket.socket: + if isinstance(sock_or_fd, int): + try: + sock = socket.socket(fileno=sock_or_fd) + except OSError as exc: + if exc.errno == errno.ENOTSOCK: + raise ValueError( + "the file descriptor does not refer to a socket" + ) from exc + elif require_connected: + raise ValueError("the socket must be connected") from exc + elif require_bound: + raise ValueError("the socket must be bound to a local address") from exc + else: + raise + elif isinstance(sock_or_fd, socket.socket): + sock = sock_or_fd + else: + raise TypeError( + f"expected an int or socket, got {type(sock_or_fd).__qualname__} instead" + ) + + try: + if require_connected: + try: + sock.getpeername() + except OSError as exc: + raise ValueError("the socket must be connected") from exc + + if require_bound: + try: + if sock.family in (socket.AF_INET, socket.AF_INET6): + bound_addr = sock.getsockname()[1] + else: + bound_addr = sock.getsockname() + except OSError: + bound_addr = None + + if not bound_addr: + raise ValueError("the socket must be bound to a local address") + + if addr_family != socket.AF_UNSPEC and sock.family != addr_family: + raise ValueError( + f"address family mismatch: expected {addr_family.name}, got " + f"{sock.family.name}" + ) + + if sock.type != sock_type: + raise ValueError( + f"socket type mismatch: expected {sock_type.name}, got {sock.type.name}" + ) + except BaseException: + # Avoid ResourceWarning from the locally constructed socket object + if isinstance(sock_or_fd, int): + sock.detach() + + raise + + sock.setblocking(False) + return sock + + +class SocketAttribute(TypedAttributeSet): + """ + .. attribute:: family + :type: socket.AddressFamily + + the address family of the underlying socket + + .. attribute:: local_address + :type: tuple[str, int] | str + + the local address the underlying socket is connected to + + .. attribute:: local_port + :type: int + + for IP based sockets, the local port the underlying socket is bound to + + .. attribute:: raw_socket + :type: socket.socket + + the underlying stdlib socket object + + .. attribute:: remote_address + :type: tuple[str, int] | str + + the remote address the underlying socket is connected to + + .. attribute:: remote_port + :type: int + + for IP based sockets, the remote port the underlying socket is connected to + """ + + family: AddressFamily = typed_attribute() + local_address: SockAddrType = typed_attribute() + local_port: int = typed_attribute() + raw_socket: socket.socket = typed_attribute() + remote_address: SockAddrType = typed_attribute() + remote_port: int = typed_attribute() + + +class _SocketProvider(TypedAttributeProvider): + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + from .._core._sockets import convert_ipv6_sockaddr as convert + + attributes: dict[Any, Callable[[], Any]] = { + SocketAttribute.family: lambda: self._raw_socket.family, + SocketAttribute.local_address: lambda: convert( + self._raw_socket.getsockname() + ), + SocketAttribute.raw_socket: lambda: self._raw_socket, + } + try: + peername: tuple[str, int] | None = convert(self._raw_socket.getpeername()) + except OSError: + peername = None + + # Provide the remote address for connected sockets + if peername is not None: + attributes[SocketAttribute.remote_address] = lambda: peername + + # Provide local and remote ports for IP based sockets + if self._raw_socket.family in (AddressFamily.AF_INET, AddressFamily.AF_INET6): + attributes[SocketAttribute.local_port] = ( + lambda: self._raw_socket.getsockname()[1] + ) + if peername is not None: + remote_port = peername[1] + attributes[SocketAttribute.remote_port] = lambda: remote_port + + return attributes + + @property + @abstractmethod + def _raw_socket(self) -> socket.socket: + pass + + +class SocketStream(ByteStream, _SocketProvider): + """ + Transports bytes over a socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket(cls, sock_or_fd: socket.socket | int) -> SocketStream: + """ + Wrap an existing socket object or file descriptor as a socket stream. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must already be connected. + + :param sock_or_fd: a socket object or file descriptor + :return: a socket stream + + """ + sock = _validate_socket(sock_or_fd, socket.SOCK_STREAM, require_connected=True) + return await get_async_backend().wrap_stream_socket(sock) + + +class UNIXSocketStream(SocketStream): + @classmethod + async def from_socket(cls, sock_or_fd: socket.socket | int) -> UNIXSocketStream: + """ + Wrap an existing socket object or file descriptor as a UNIX socket stream. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must already be connected. + + :param sock_or_fd: a socket object or file descriptor + :return: a UNIX socket stream + + """ + sock = _validate_socket( + sock_or_fd, socket.SOCK_STREAM, socket.AF_UNIX, require_connected=True + ) + return await get_async_backend().wrap_unix_stream_socket(sock) + + @abstractmethod + async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None: + """ + Send file descriptors along with a message to the peer. + + :param message: a non-empty bytestring + :param fds: a collection of files (either numeric file descriptors or open file + or socket objects) + """ + + @abstractmethod + async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]: + """ + Receive file descriptors along with a message from the peer. + + :param msglen: length of the message to expect from the peer + :param maxfds: maximum number of file descriptors to expect from the peer + :return: a tuple of (message, file descriptors) + """ + + +class SocketListener(Listener[SocketStream], _SocketProvider): + """ + Listens to incoming socket connections. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket( + cls, + sock_or_fd: socket.socket | int, + ) -> SocketListener: + """ + Wrap an existing socket object or file descriptor as a socket listener. + + The newly created listener takes ownership of the socket being passed in. + + :param sock_or_fd: a socket object or file descriptor + :return: a socket listener + + """ + sock = _validate_socket(sock_or_fd, socket.SOCK_STREAM, require_bound=True) + return await get_async_backend().wrap_listener_socket(sock) + + @abstractmethod + async def accept(self) -> SocketStream: + """Accept an incoming connection.""" + + async def serve( + self, + handler: Callable[[SocketStream], Any], + task_group: TaskGroup | None = None, + ) -> None: + from .. import create_task_group + + async with AsyncExitStack() as stack: + if task_group is None: + task_group = await stack.enter_async_context(create_task_group()) + + while True: + stream = await self.accept() + task_group.start_soon(handler, stream) + + +class UDPSocket(UnreliableObjectStream[UDPPacketType], _SocketProvider): + """ + Represents an unconnected UDP socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket(cls, sock_or_fd: socket.socket | int) -> UDPSocket: + """ + Wrap an existing socket object or file descriptor as a UDP socket. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must be bound to a local address. + + :param sock_or_fd: a socket object or file descriptor + :return: a UDP socket + + """ + sock = _validate_socket(sock_or_fd, socket.SOCK_DGRAM, require_bound=True) + return await get_async_backend().wrap_udp_socket(sock) + + async def sendto(self, data: bytes, host: str, port: int) -> None: + """ + Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, (host, port))). + + """ + return await self.send((data, (host, port))) + + +class ConnectedUDPSocket(UnreliableObjectStream[bytes], _SocketProvider): + """ + Represents an connected UDP socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket(cls, sock_or_fd: socket.socket | int) -> ConnectedUDPSocket: + """ + Wrap an existing socket object or file descriptor as a connected UDP socket. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must already be connected. + + :param sock_or_fd: a socket object or file descriptor + :return: a connected UDP socket + + """ + sock = _validate_socket( + sock_or_fd, + socket.SOCK_DGRAM, + require_connected=True, + ) + return await get_async_backend().wrap_connected_udp_socket(sock) + + +class UNIXDatagramSocket( + UnreliableObjectStream[UNIXDatagramPacketType], _SocketProvider +): + """ + Represents an unconnected Unix datagram socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket( + cls, + sock_or_fd: socket.socket | int, + ) -> UNIXDatagramSocket: + """ + Wrap an existing socket object or file descriptor as a UNIX datagram + socket. + + The newly created socket wrapper takes ownership of the socket being passed in. + + :param sock_or_fd: a socket object or file descriptor + :return: a UNIX datagram socket + + """ + sock = _validate_socket(sock_or_fd, socket.SOCK_DGRAM, socket.AF_UNIX) + return await get_async_backend().wrap_unix_datagram_socket(sock) + + async def sendto(self, data: bytes, path: str) -> None: + """Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, path)).""" + return await self.send((data, path)) + + +class ConnectedUNIXDatagramSocket(UnreliableObjectStream[bytes], _SocketProvider): + """ + Represents a connected Unix datagram socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket( + cls, + sock_or_fd: socket.socket | int, + ) -> ConnectedUNIXDatagramSocket: + """ + Wrap an existing socket object or file descriptor as a connected UNIX datagram + socket. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must already be connected. + + :param sock_or_fd: a socket object or file descriptor + :return: a connected UNIX datagram socket + + """ + sock = _validate_socket( + sock_or_fd, socket.SOCK_DGRAM, socket.AF_UNIX, require_connected=True + ) + return await get_async_backend().wrap_connected_unix_datagram_socket(sock) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_streams.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_streams.py new file mode 100644 index 0000000000000000000000000000000000000000..369df3f36cda74aa0d0893cd98bd4b29d3786faa --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_streams.py @@ -0,0 +1,239 @@ +from __future__ import annotations + +import sys +from abc import ABCMeta, abstractmethod +from collections.abc import Callable +from typing import Any, Generic, TypeVar, Union + +from .._core._exceptions import EndOfStream +from .._core._typedattr import TypedAttributeProvider +from ._resources import AsyncResource +from ._tasks import TaskGroup + +if sys.version_info >= (3, 10): + from typing import TypeAlias +else: + from typing_extensions import TypeAlias + +T_Item = TypeVar("T_Item") +T_co = TypeVar("T_co", covariant=True) +T_contra = TypeVar("T_contra", contravariant=True) + + +class UnreliableObjectReceiveStream( + Generic[T_co], AsyncResource, TypedAttributeProvider +): + """ + An interface for receiving objects. + + This interface makes no guarantees that the received messages arrive in the order in + which they were sent, or that no messages are missed. + + Asynchronously iterating over objects of this type will yield objects matching the + given type parameter. + """ + + def __aiter__(self) -> UnreliableObjectReceiveStream[T_co]: + return self + + async def __anext__(self) -> T_co: + try: + return await self.receive() + except EndOfStream: + raise StopAsyncIteration from None + + @abstractmethod + async def receive(self) -> T_co: + """ + Receive the next item. + + :raises ~anyio.ClosedResourceError: if the receive stream has been explicitly + closed + :raises ~anyio.EndOfStream: if this stream has been closed from the other end + :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable + due to external causes + """ + + +class UnreliableObjectSendStream( + Generic[T_contra], AsyncResource, TypedAttributeProvider +): + """ + An interface for sending objects. + + This interface makes no guarantees that the messages sent will reach the + recipient(s) in the same order in which they were sent, or at all. + """ + + @abstractmethod + async def send(self, item: T_contra) -> None: + """ + Send an item to the peer(s). + + :param item: the item to send + :raises ~anyio.ClosedResourceError: if the send stream has been explicitly + closed + :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable + due to external causes + """ + + +class UnreliableObjectStream( + UnreliableObjectReceiveStream[T_Item], UnreliableObjectSendStream[T_Item] +): + """ + A bidirectional message stream which does not guarantee the order or reliability of + message delivery. + """ + + +class ObjectReceiveStream(UnreliableObjectReceiveStream[T_co]): + """ + A receive message stream which guarantees that messages are received in the same + order in which they were sent, and that no messages are missed. + """ + + +class ObjectSendStream(UnreliableObjectSendStream[T_contra]): + """ + A send message stream which guarantees that messages are delivered in the same order + in which they were sent, without missing any messages in the middle. + """ + + +class ObjectStream( + ObjectReceiveStream[T_Item], + ObjectSendStream[T_Item], + UnreliableObjectStream[T_Item], +): + """ + A bidirectional message stream which guarantees the order and reliability of message + delivery. + """ + + @abstractmethod + async def send_eof(self) -> None: + """ + Send an end-of-file indication to the peer. + + You should not try to send any further data to this stream after calling this + method. This method is idempotent (does nothing on successive calls). + """ + + +class ByteReceiveStream(AsyncResource, TypedAttributeProvider): + """ + An interface for receiving bytes from a single peer. + + Iterating this byte stream will yield a byte string of arbitrary length, but no more + than 65536 bytes. + """ + + def __aiter__(self) -> ByteReceiveStream: + return self + + async def __anext__(self) -> bytes: + try: + return await self.receive() + except EndOfStream: + raise StopAsyncIteration from None + + @abstractmethod + async def receive(self, max_bytes: int = 65536) -> bytes: + """ + Receive at most ``max_bytes`` bytes from the peer. + + .. note:: Implementers of this interface should not return an empty + :class:`bytes` object, and users should ignore them. + + :param max_bytes: maximum number of bytes to receive + :return: the received bytes + :raises ~anyio.EndOfStream: if this stream has been closed from the other end + """ + + +class ByteSendStream(AsyncResource, TypedAttributeProvider): + """An interface for sending bytes to a single peer.""" + + @abstractmethod + async def send(self, item: bytes) -> None: + """ + Send the given bytes to the peer. + + :param item: the bytes to send + """ + + +class ByteStream(ByteReceiveStream, ByteSendStream): + """A bidirectional byte stream.""" + + @abstractmethod + async def send_eof(self) -> None: + """ + Send an end-of-file indication to the peer. + + You should not try to send any further data to this stream after calling this + method. This method is idempotent (does nothing on successive calls). + """ + + +#: Type alias for all unreliable bytes-oriented receive streams. +AnyUnreliableByteReceiveStream: TypeAlias = Union[ + UnreliableObjectReceiveStream[bytes], ByteReceiveStream +] +#: Type alias for all unreliable bytes-oriented send streams. +AnyUnreliableByteSendStream: TypeAlias = Union[ + UnreliableObjectSendStream[bytes], ByteSendStream +] +#: Type alias for all unreliable bytes-oriented streams. +AnyUnreliableByteStream: TypeAlias = Union[UnreliableObjectStream[bytes], ByteStream] +#: Type alias for all bytes-oriented receive streams. +AnyByteReceiveStream: TypeAlias = Union[ObjectReceiveStream[bytes], ByteReceiveStream] +#: Type alias for all bytes-oriented send streams. +AnyByteSendStream: TypeAlias = Union[ObjectSendStream[bytes], ByteSendStream] +#: Type alias for all bytes-oriented streams. +AnyByteStream: TypeAlias = Union[ObjectStream[bytes], ByteStream] + + +class Listener(Generic[T_co], AsyncResource, TypedAttributeProvider): + """An interface for objects that let you accept incoming connections.""" + + @abstractmethod + async def serve( + self, handler: Callable[[T_co], Any], task_group: TaskGroup | None = None + ) -> None: + """ + Accept incoming connections as they come in and start tasks to handle them. + + :param handler: a callable that will be used to handle each accepted connection + :param task_group: the task group that will be used to start tasks for handling + each accepted connection (if omitted, an ad-hoc task group will be created) + """ + + +class ObjectStreamConnectable(Generic[T_co], metaclass=ABCMeta): + @abstractmethod + async def connect(self) -> ObjectStream[T_co]: + """ + Connect to the remote endpoint. + + :return: an object stream connected to the remote end + :raises ConnectionFailed: if the connection fails + """ + + +class ByteStreamConnectable(metaclass=ABCMeta): + @abstractmethod + async def connect(self) -> ByteStream: + """ + Connect to the remote endpoint. + + :return: a bytestream connected to the remote end + :raises ConnectionFailed: if the connection fails + """ + + +#: Type alias for all connectables returning bytestreams or bytes-oriented object streams +AnyByteStreamConnectable: TypeAlias = Union[ + ObjectStreamConnectable[bytes], ByteStreamConnectable +] diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_subprocesses.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_subprocesses.py new file mode 100644 index 0000000000000000000000000000000000000000..ce0564ceac8aac425675b5c8f7f7205d08061fd3 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_subprocesses.py @@ -0,0 +1,79 @@ +from __future__ import annotations + +from abc import abstractmethod +from signal import Signals + +from ._resources import AsyncResource +from ._streams import ByteReceiveStream, ByteSendStream + + +class Process(AsyncResource): + """An asynchronous version of :class:`subprocess.Popen`.""" + + @abstractmethod + async def wait(self) -> int: + """ + Wait until the process exits. + + :return: the exit code of the process + """ + + @abstractmethod + def terminate(self) -> None: + """ + Terminates the process, gracefully if possible. + + On Windows, this calls ``TerminateProcess()``. + On POSIX systems, this sends ``SIGTERM`` to the process. + + .. seealso:: :meth:`subprocess.Popen.terminate` + """ + + @abstractmethod + def kill(self) -> None: + """ + Kills the process. + + On Windows, this calls ``TerminateProcess()``. + On POSIX systems, this sends ``SIGKILL`` to the process. + + .. seealso:: :meth:`subprocess.Popen.kill` + """ + + @abstractmethod + def send_signal(self, signal: Signals) -> None: + """ + Send a signal to the subprocess. + + .. seealso:: :meth:`subprocess.Popen.send_signal` + + :param signal: the signal number (e.g. :data:`signal.SIGHUP`) + """ + + @property + @abstractmethod + def pid(self) -> int: + """The process ID of the process.""" + + @property + @abstractmethod + def returncode(self) -> int | None: + """ + The return code of the process. If the process has not yet terminated, this will + be ``None``. + """ + + @property + @abstractmethod + def stdin(self) -> ByteSendStream | None: + """The stream for the standard input of the process.""" + + @property + @abstractmethod + def stdout(self) -> ByteReceiveStream | None: + """The stream for the standard output of the process.""" + + @property + @abstractmethod + def stderr(self) -> ByteReceiveStream | None: + """The stream for the standard error output of the process.""" diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_tasks.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_tasks.py new file mode 100644 index 0000000000000000000000000000000000000000..516b3ec3b38a4b140f5d607dd28da989f057b832 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_tasks.py @@ -0,0 +1,117 @@ +from __future__ import annotations + +import sys +from abc import ABCMeta, abstractmethod +from collections.abc import Awaitable, Callable +from types import TracebackType +from typing import TYPE_CHECKING, Any, Protocol, overload + +if sys.version_info >= (3, 13): + from typing import TypeVar +else: + from typing_extensions import TypeVar + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +if TYPE_CHECKING: + from .._core._tasks import CancelScope + +T_Retval = TypeVar("T_Retval") +T_contra = TypeVar("T_contra", contravariant=True, default=None) +PosArgsT = TypeVarTuple("PosArgsT") + + +class TaskStatus(Protocol[T_contra]): + @overload + def started(self: TaskStatus[None]) -> None: ... + + @overload + def started(self, value: T_contra) -> None: ... + + def started(self, value: T_contra | None = None) -> None: + """ + Signal that the task has started. + + :param value: object passed back to the starter of the task + """ + + +class TaskGroup(metaclass=ABCMeta): + """ + Groups several asynchronous tasks together. + + :ivar cancel_scope: the cancel scope inherited by all child tasks + :vartype cancel_scope: CancelScope + + .. note:: On asyncio, support for eager task factories is considered to be + **experimental**. In particular, they don't follow the usual semantics of new + tasks being scheduled on the next iteration of the event loop, and may thus + cause unexpected behavior in code that wasn't written with such semantics in + mind. + """ + + cancel_scope: CancelScope + + @abstractmethod + def start_soon( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[Any]], + *args: Unpack[PosArgsT], + name: object = None, + ) -> None: + """ + Start a new task in this task group. + + :param func: a coroutine function + :param args: positional arguments to call the function with + :param name: name of the task, for the purposes of introspection and debugging + + .. versionadded:: 3.0 + """ + + @abstractmethod + async def start( + self, + func: Callable[..., Awaitable[Any]], + *args: object, + name: object = None, + ) -> Any: + """ + Start a new task and wait until it signals for readiness. + + The target callable must accept a keyword argument ``task_status`` (of type + :class:`TaskStatus`). Awaiting on this method will return whatever was passed to + ``task_status.started()`` (``None`` by default). + + .. note:: The :class:`TaskStatus` class is generic, and the type argument should + indicate the type of the value that will be passed to + ``task_status.started()``. + + :param func: a coroutine function that accepts the ``task_status`` keyword + argument + :param args: positional arguments to call the function with + :param name: an optional name for the task, for introspection and debugging + :return: the value passed to ``task_status.started()`` + :raises RuntimeError: if the task finishes without calling + ``task_status.started()`` + + .. seealso:: :ref:`start_initialize` + + .. versionadded:: 3.0 + """ + + @abstractmethod + async def __aenter__(self) -> TaskGroup: + """Enter the task group context and allow starting new tasks.""" + + @abstractmethod + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + """Exit the task group context waiting for all tasks to finish.""" diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_testing.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_testing.py new file mode 100644 index 0000000000000000000000000000000000000000..7c50ed76dc4d8df41262973a0122295523e2a935 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/abc/_testing.py @@ -0,0 +1,65 @@ +from __future__ import annotations + +import types +from abc import ABCMeta, abstractmethod +from collections.abc import AsyncGenerator, Callable, Coroutine, Iterable +from typing import Any, TypeVar + +_T = TypeVar("_T") + + +class TestRunner(metaclass=ABCMeta): + """ + Encapsulates a running event loop. Every call made through this object will use the + same event loop. + """ + + def __enter__(self) -> TestRunner: + return self + + @abstractmethod + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: types.TracebackType | None, + ) -> bool | None: ... + + @abstractmethod + def run_asyncgen_fixture( + self, + fixture_func: Callable[..., AsyncGenerator[_T, Any]], + kwargs: dict[str, Any], + ) -> Iterable[_T]: + """ + Run an async generator fixture. + + :param fixture_func: the fixture function + :param kwargs: keyword arguments to call the fixture function with + :return: an iterator yielding the value yielded from the async generator + """ + + @abstractmethod + def run_fixture( + self, + fixture_func: Callable[..., Coroutine[Any, Any, _T]], + kwargs: dict[str, Any], + ) -> _T: + """ + Run an async fixture. + + :param fixture_func: the fixture function + :param kwargs: keyword arguments to call the fixture function with + :return: the return value of the fixture function + """ + + @abstractmethod + def run_test( + self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any] + ) -> None: + """ + Run an async test function. + + :param test_func: the test function + :param kwargs: keyword arguments to call the test function with + """ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__init__.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/__init__.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..414e7beedbfd0682348b95789b412783669402ad Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/__init__.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/buffered.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/buffered.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..719302c078f55af1365d1c62ca62050fbd3927da Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/buffered.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/file.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/file.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eb769126080a4d343bf25df6a092004c935a5863 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/file.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/memory.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/memory.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5924b25502df729c3f18475e6fc84c41893059b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/memory.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/stapled.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/stapled.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6ce0778e76d542b9b5b82f915c947d84799b7f87 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/stapled.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/text.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/text.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e83770166446176b140c6c6b9851eec8a9f129c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/text.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/tls.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/tls.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..478e8c17d1f1a79c34e136cd1418953d094cf64b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/__pycache__/tls.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/buffered.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/buffered.py new file mode 100644 index 0000000000000000000000000000000000000000..57c7cd749bfb94bbe7a992aa9a05af268a841d3d --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/buffered.py @@ -0,0 +1,188 @@ +from __future__ import annotations + +__all__ = ( + "BufferedByteReceiveStream", + "BufferedByteStream", + "BufferedConnectable", +) + +import sys +from collections.abc import Callable, Iterable, Mapping +from dataclasses import dataclass, field +from typing import Any, SupportsIndex + +from .. import ClosedResourceError, DelimiterNotFound, EndOfStream, IncompleteRead +from ..abc import ( + AnyByteReceiveStream, + AnyByteStream, + AnyByteStreamConnectable, + ByteReceiveStream, + ByteStream, + ByteStreamConnectable, +) + +if sys.version_info >= (3, 12): + from typing import override +else: + from typing_extensions import override + + +@dataclass(eq=False) +class BufferedByteReceiveStream(ByteReceiveStream): + """ + Wraps any bytes-based receive stream and uses a buffer to provide sophisticated + receiving capabilities in the form of a byte stream. + """ + + receive_stream: AnyByteReceiveStream + _buffer: bytearray = field(init=False, default_factory=bytearray) + _closed: bool = field(init=False, default=False) + + async def aclose(self) -> None: + await self.receive_stream.aclose() + self._closed = True + + @property + def buffer(self) -> bytes: + """The bytes currently in the buffer.""" + return bytes(self._buffer) + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return self.receive_stream.extra_attributes + + def feed_data(self, data: Iterable[SupportsIndex], /) -> None: + """ + Append data directly into the buffer. + + Any data in the buffer will be consumed by receive operations before receiving + anything from the wrapped stream. + + :param data: the data to append to the buffer (can be bytes or anything else + that supports ``__index__()``) + + """ + self._buffer.extend(data) + + async def receive(self, max_bytes: int = 65536) -> bytes: + if self._closed: + raise ClosedResourceError + + if self._buffer: + chunk = bytes(self._buffer[:max_bytes]) + del self._buffer[:max_bytes] + return chunk + elif isinstance(self.receive_stream, ByteReceiveStream): + return await self.receive_stream.receive(max_bytes) + else: + # With a bytes-oriented object stream, we need to handle any surplus bytes + # we get from the receive() call + chunk = await self.receive_stream.receive() + if len(chunk) > max_bytes: + # Save the surplus bytes in the buffer + self._buffer.extend(chunk[max_bytes:]) + return chunk[:max_bytes] + else: + return chunk + + async def receive_exactly(self, nbytes: int) -> bytes: + """ + Read exactly the given amount of bytes from the stream. + + :param nbytes: the number of bytes to read + :return: the bytes read + :raises ~anyio.IncompleteRead: if the stream was closed before the requested + amount of bytes could be read from the stream + + """ + while True: + remaining = nbytes - len(self._buffer) + if remaining <= 0: + retval = self._buffer[:nbytes] + del self._buffer[:nbytes] + return bytes(retval) + + try: + if isinstance(self.receive_stream, ByteReceiveStream): + chunk = await self.receive_stream.receive(remaining) + else: + chunk = await self.receive_stream.receive() + except EndOfStream as exc: + raise IncompleteRead from exc + + self._buffer.extend(chunk) + + async def receive_until(self, delimiter: bytes, max_bytes: int) -> bytes: + """ + Read from the stream until the delimiter is found or max_bytes have been read. + + :param delimiter: the marker to look for in the stream + :param max_bytes: maximum number of bytes that will be read before raising + :exc:`~anyio.DelimiterNotFound` + :return: the bytes read (not including the delimiter) + :raises ~anyio.IncompleteRead: if the stream was closed before the delimiter + was found + :raises ~anyio.DelimiterNotFound: if the delimiter is not found within the + bytes read up to the maximum allowed + + """ + delimiter_size = len(delimiter) + offset = 0 + while True: + # Check if the delimiter can be found in the current buffer + index = self._buffer.find(delimiter, offset) + if index >= 0: + found = self._buffer[:index] + del self._buffer[: index + len(delimiter) :] + return bytes(found) + + # Check if the buffer is already at or over the limit + if len(self._buffer) >= max_bytes: + raise DelimiterNotFound(max_bytes) + + # Read more data into the buffer from the socket + try: + data = await self.receive_stream.receive() + except EndOfStream as exc: + raise IncompleteRead from exc + + # Move the offset forward and add the new data to the buffer + offset = max(len(self._buffer) - delimiter_size + 1, 0) + self._buffer.extend(data) + + +class BufferedByteStream(BufferedByteReceiveStream, ByteStream): + """ + A full-duplex variant of :class:`BufferedByteReceiveStream`. All writes are passed + through to the wrapped stream as-is. + """ + + def __init__(self, stream: AnyByteStream): + """ + :param stream: the stream to be wrapped + + """ + super().__init__(stream) + self._stream = stream + + @override + async def send_eof(self) -> None: + await self._stream.send_eof() + + @override + async def send(self, item: bytes) -> None: + await self._stream.send(item) + + +class BufferedConnectable(ByteStreamConnectable): + def __init__(self, connectable: AnyByteStreamConnectable): + """ + :param connectable: the connectable to wrap + + """ + self.connectable = connectable + + @override + async def connect(self) -> BufferedByteStream: + stream = await self.connectable.connect() + return BufferedByteStream(stream) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/file.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/file.py new file mode 100644 index 0000000000000000000000000000000000000000..82d2da8965ab4281ef0b554f7b8cae857a21bde5 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/file.py @@ -0,0 +1,154 @@ +from __future__ import annotations + +__all__ = ( + "FileReadStream", + "FileStreamAttribute", + "FileWriteStream", +) + +from collections.abc import Callable, Mapping +from io import SEEK_SET, UnsupportedOperation +from os import PathLike +from pathlib import Path +from typing import Any, BinaryIO, cast + +from .. import ( + BrokenResourceError, + ClosedResourceError, + EndOfStream, + TypedAttributeSet, + to_thread, + typed_attribute, +) +from ..abc import ByteReceiveStream, ByteSendStream + + +class FileStreamAttribute(TypedAttributeSet): + #: the open file descriptor + file: BinaryIO = typed_attribute() + #: the path of the file on the file system, if available (file must be a real file) + path: Path = typed_attribute() + #: the file number, if available (file must be a real file or a TTY) + fileno: int = typed_attribute() + + +class _BaseFileStream: + def __init__(self, file: BinaryIO): + self._file = file + + async def aclose(self) -> None: + await to_thread.run_sync(self._file.close) + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + attributes: dict[Any, Callable[[], Any]] = { + FileStreamAttribute.file: lambda: self._file, + } + + if hasattr(self._file, "name"): + attributes[FileStreamAttribute.path] = lambda: Path(self._file.name) + + try: + self._file.fileno() + except UnsupportedOperation: + pass + else: + attributes[FileStreamAttribute.fileno] = lambda: self._file.fileno() + + return attributes + + +class FileReadStream(_BaseFileStream, ByteReceiveStream): + """ + A byte stream that reads from a file in the file system. + + :param file: a file that has been opened for reading in binary mode + + .. versionadded:: 3.0 + """ + + @classmethod + async def from_path(cls, path: str | PathLike[str]) -> FileReadStream: + """ + Create a file read stream by opening the given file. + + :param path: path of the file to read from + + """ + file = await to_thread.run_sync(Path(path).open, "rb") + return cls(cast(BinaryIO, file)) + + async def receive(self, max_bytes: int = 65536) -> bytes: + try: + data = await to_thread.run_sync(self._file.read, max_bytes) + except ValueError: + raise ClosedResourceError from None + except OSError as exc: + raise BrokenResourceError from exc + + if data: + return data + else: + raise EndOfStream + + async def seek(self, position: int, whence: int = SEEK_SET) -> int: + """ + Seek the file to the given position. + + .. seealso:: :meth:`io.IOBase.seek` + + .. note:: Not all file descriptors are seekable. + + :param position: position to seek the file to + :param whence: controls how ``position`` is interpreted + :return: the new absolute position + :raises OSError: if the file is not seekable + + """ + return await to_thread.run_sync(self._file.seek, position, whence) + + async def tell(self) -> int: + """ + Return the current stream position. + + .. note:: Not all file descriptors are seekable. + + :return: the current absolute position + :raises OSError: if the file is not seekable + + """ + return await to_thread.run_sync(self._file.tell) + + +class FileWriteStream(_BaseFileStream, ByteSendStream): + """ + A byte stream that writes to a file in the file system. + + :param file: a file that has been opened for writing in binary mode + + .. versionadded:: 3.0 + """ + + @classmethod + async def from_path( + cls, path: str | PathLike[str], append: bool = False + ) -> FileWriteStream: + """ + Create a file write stream by opening the given file for writing. + + :param path: path of the file to write to + :param append: if ``True``, open the file for appending; if ``False``, any + existing file at the given path will be truncated + + """ + mode = "ab" if append else "wb" + file = await to_thread.run_sync(Path(path).open, mode) + return cls(cast(BinaryIO, file)) + + async def send(self, item: bytes) -> None: + try: + await to_thread.run_sync(self._file.write, item) + except ValueError: + raise ClosedResourceError from None + except OSError as exc: + raise BrokenResourceError from exc diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/memory.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/memory.py new file mode 100644 index 0000000000000000000000000000000000000000..a3fa0c3d9783f34fb5225938f6ce5d1d31b9b85c --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/memory.py @@ -0,0 +1,325 @@ +from __future__ import annotations + +__all__ = ( + "MemoryObjectReceiveStream", + "MemoryObjectSendStream", + "MemoryObjectStreamStatistics", +) + +import warnings +from collections import OrderedDict, deque +from dataclasses import dataclass, field +from types import TracebackType +from typing import Generic, NamedTuple, TypeVar + +from .. import ( + BrokenResourceError, + ClosedResourceError, + EndOfStream, + WouldBlock, +) +from .._core._testing import TaskInfo, get_current_task +from ..abc import Event, ObjectReceiveStream, ObjectSendStream +from ..lowlevel import checkpoint + +T_Item = TypeVar("T_Item") +T_co = TypeVar("T_co", covariant=True) +T_contra = TypeVar("T_contra", contravariant=True) + + +class MemoryObjectStreamStatistics(NamedTuple): + current_buffer_used: int #: number of items stored in the buffer + #: maximum number of items that can be stored on this stream (or :data:`math.inf`) + max_buffer_size: float + open_send_streams: int #: number of unclosed clones of the send stream + open_receive_streams: int #: number of unclosed clones of the receive stream + #: number of tasks blocked on :meth:`MemoryObjectSendStream.send` + tasks_waiting_send: int + #: number of tasks blocked on :meth:`MemoryObjectReceiveStream.receive` + tasks_waiting_receive: int + + +@dataclass(eq=False) +class _MemoryObjectItemReceiver(Generic[T_Item]): + task_info: TaskInfo = field(init=False, default_factory=get_current_task) + item: T_Item = field(init=False) + + def __repr__(self) -> str: + # When item is not defined, we get following error with default __repr__: + # AttributeError: 'MemoryObjectItemReceiver' object has no attribute 'item' + item = getattr(self, "item", None) + return f"{self.__class__.__name__}(task_info={self.task_info}, item={item!r})" + + +@dataclass(eq=False) +class _MemoryObjectStreamState(Generic[T_Item]): + max_buffer_size: float = field() + buffer: deque[T_Item] = field(init=False, default_factory=deque) + open_send_channels: int = field(init=False, default=0) + open_receive_channels: int = field(init=False, default=0) + waiting_receivers: OrderedDict[Event, _MemoryObjectItemReceiver[T_Item]] = field( + init=False, default_factory=OrderedDict + ) + waiting_senders: OrderedDict[Event, T_Item] = field( + init=False, default_factory=OrderedDict + ) + + def statistics(self) -> MemoryObjectStreamStatistics: + return MemoryObjectStreamStatistics( + len(self.buffer), + self.max_buffer_size, + self.open_send_channels, + self.open_receive_channels, + len(self.waiting_senders), + len(self.waiting_receivers), + ) + + +@dataclass(eq=False) +class MemoryObjectReceiveStream(Generic[T_co], ObjectReceiveStream[T_co]): + _state: _MemoryObjectStreamState[T_co] + _closed: bool = field(init=False, default=False) + + def __post_init__(self) -> None: + self._state.open_receive_channels += 1 + + def receive_nowait(self) -> T_co: + """ + Receive the next item if it can be done without waiting. + + :return: the received item + :raises ~anyio.ClosedResourceError: if this send stream has been closed + :raises ~anyio.EndOfStream: if the buffer is empty and this stream has been + closed from the sending end + :raises ~anyio.WouldBlock: if there are no items in the buffer and no tasks + waiting to send + + """ + if self._closed: + raise ClosedResourceError + + if self._state.waiting_senders: + # Get the item from the next sender + send_event, item = self._state.waiting_senders.popitem(last=False) + self._state.buffer.append(item) + send_event.set() + + if self._state.buffer: + return self._state.buffer.popleft() + elif not self._state.open_send_channels: + raise EndOfStream + + raise WouldBlock + + async def receive(self) -> T_co: + await checkpoint() + try: + return self.receive_nowait() + except WouldBlock: + # Add ourselves in the queue + receive_event = Event() + receiver = _MemoryObjectItemReceiver[T_co]() + self._state.waiting_receivers[receive_event] = receiver + + try: + await receive_event.wait() + finally: + self._state.waiting_receivers.pop(receive_event, None) + + try: + return receiver.item + except AttributeError: + raise EndOfStream from None + + def clone(self) -> MemoryObjectReceiveStream[T_co]: + """ + Create a clone of this receive stream. + + Each clone can be closed separately. Only when all clones have been closed will + the receiving end of the memory stream be considered closed by the sending ends. + + :return: the cloned stream + + """ + if self._closed: + raise ClosedResourceError + + return MemoryObjectReceiveStream(_state=self._state) + + def close(self) -> None: + """ + Close the stream. + + This works the exact same way as :meth:`aclose`, but is provided as a special + case for the benefit of synchronous callbacks. + + """ + if not self._closed: + self._closed = True + self._state.open_receive_channels -= 1 + if self._state.open_receive_channels == 0: + send_events = list(self._state.waiting_senders.keys()) + for event in send_events: + event.set() + + async def aclose(self) -> None: + self.close() + + def statistics(self) -> MemoryObjectStreamStatistics: + """ + Return statistics about the current state of this stream. + + .. versionadded:: 3.0 + """ + return self._state.statistics() + + def __enter__(self) -> MemoryObjectReceiveStream[T_co]: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.close() + + def __del__(self) -> None: + if not self._closed: + warnings.warn( + f"Unclosed <{self.__class__.__name__} at {id(self):x}>", + ResourceWarning, + stacklevel=1, + source=self, + ) + + +@dataclass(eq=False) +class MemoryObjectSendStream(Generic[T_contra], ObjectSendStream[T_contra]): + _state: _MemoryObjectStreamState[T_contra] + _closed: bool = field(init=False, default=False) + + def __post_init__(self) -> None: + self._state.open_send_channels += 1 + + def send_nowait(self, item: T_contra) -> None: + """ + Send an item immediately if it can be done without waiting. + + :param item: the item to send + :raises ~anyio.ClosedResourceError: if this send stream has been closed + :raises ~anyio.BrokenResourceError: if the stream has been closed from the + receiving end + :raises ~anyio.WouldBlock: if the buffer is full and there are no tasks waiting + to receive + + """ + if self._closed: + raise ClosedResourceError + if not self._state.open_receive_channels: + raise BrokenResourceError + + while self._state.waiting_receivers: + receive_event, receiver = self._state.waiting_receivers.popitem(last=False) + if not receiver.task_info.has_pending_cancellation(): + receiver.item = item + receive_event.set() + return + + if len(self._state.buffer) < self._state.max_buffer_size: + self._state.buffer.append(item) + else: + raise WouldBlock + + async def send(self, item: T_contra) -> None: + """ + Send an item to the stream. + + If the buffer is full, this method blocks until there is again room in the + buffer or the item can be sent directly to a receiver. + + :param item: the item to send + :raises ~anyio.ClosedResourceError: if this send stream has been closed + :raises ~anyio.BrokenResourceError: if the stream has been closed from the + receiving end + + """ + await checkpoint() + try: + self.send_nowait(item) + except WouldBlock: + # Wait until there's someone on the receiving end + send_event = Event() + self._state.waiting_senders[send_event] = item + try: + await send_event.wait() + except BaseException: + self._state.waiting_senders.pop(send_event, None) + raise + + if send_event in self._state.waiting_senders: + del self._state.waiting_senders[send_event] + raise BrokenResourceError from None + + def clone(self) -> MemoryObjectSendStream[T_contra]: + """ + Create a clone of this send stream. + + Each clone can be closed separately. Only when all clones have been closed will + the sending end of the memory stream be considered closed by the receiving ends. + + :return: the cloned stream + + """ + if self._closed: + raise ClosedResourceError + + return MemoryObjectSendStream(_state=self._state) + + def close(self) -> None: + """ + Close the stream. + + This works the exact same way as :meth:`aclose`, but is provided as a special + case for the benefit of synchronous callbacks. + + """ + if not self._closed: + self._closed = True + self._state.open_send_channels -= 1 + if self._state.open_send_channels == 0: + receive_events = list(self._state.waiting_receivers.keys()) + self._state.waiting_receivers.clear() + for event in receive_events: + event.set() + + async def aclose(self) -> None: + self.close() + + def statistics(self) -> MemoryObjectStreamStatistics: + """ + Return statistics about the current state of this stream. + + .. versionadded:: 3.0 + """ + return self._state.statistics() + + def __enter__(self) -> MemoryObjectSendStream[T_contra]: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.close() + + def __del__(self) -> None: + if not self._closed: + warnings.warn( + f"Unclosed <{self.__class__.__name__} at {id(self):x}>", + ResourceWarning, + stacklevel=1, + source=self, + ) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/stapled.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/stapled.py new file mode 100644 index 0000000000000000000000000000000000000000..9248b68abfbff90ddd64646fbe9cabb9f0ebe869 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/stapled.py @@ -0,0 +1,147 @@ +from __future__ import annotations + +__all__ = ( + "MultiListener", + "StapledByteStream", + "StapledObjectStream", +) + +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass +from typing import Any, Generic, TypeVar + +from ..abc import ( + ByteReceiveStream, + ByteSendStream, + ByteStream, + Listener, + ObjectReceiveStream, + ObjectSendStream, + ObjectStream, + TaskGroup, +) + +T_Item = TypeVar("T_Item") +T_Stream = TypeVar("T_Stream") + + +@dataclass(eq=False) +class StapledByteStream(ByteStream): + """ + Combines two byte streams into a single, bidirectional byte stream. + + Extra attributes will be provided from both streams, with the receive stream + providing the values in case of a conflict. + + :param ByteSendStream send_stream: the sending byte stream + :param ByteReceiveStream receive_stream: the receiving byte stream + """ + + send_stream: ByteSendStream + receive_stream: ByteReceiveStream + + async def receive(self, max_bytes: int = 65536) -> bytes: + return await self.receive_stream.receive(max_bytes) + + async def send(self, item: bytes) -> None: + await self.send_stream.send(item) + + async def send_eof(self) -> None: + await self.send_stream.aclose() + + async def aclose(self) -> None: + await self.send_stream.aclose() + await self.receive_stream.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + **self.send_stream.extra_attributes, + **self.receive_stream.extra_attributes, + } + + +@dataclass(eq=False) +class StapledObjectStream(Generic[T_Item], ObjectStream[T_Item]): + """ + Combines two object streams into a single, bidirectional object stream. + + Extra attributes will be provided from both streams, with the receive stream + providing the values in case of a conflict. + + :param ObjectSendStream send_stream: the sending object stream + :param ObjectReceiveStream receive_stream: the receiving object stream + """ + + send_stream: ObjectSendStream[T_Item] + receive_stream: ObjectReceiveStream[T_Item] + + async def receive(self) -> T_Item: + return await self.receive_stream.receive() + + async def send(self, item: T_Item) -> None: + await self.send_stream.send(item) + + async def send_eof(self) -> None: + await self.send_stream.aclose() + + async def aclose(self) -> None: + await self.send_stream.aclose() + await self.receive_stream.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + **self.send_stream.extra_attributes, + **self.receive_stream.extra_attributes, + } + + +@dataclass(eq=False) +class MultiListener(Generic[T_Stream], Listener[T_Stream]): + """ + Combines multiple listeners into one, serving connections from all of them at once. + + Any MultiListeners in the given collection of listeners will have their listeners + moved into this one. + + Extra attributes are provided from each listener, with each successive listener + overriding any conflicting attributes from the previous one. + + :param listeners: listeners to serve + :type listeners: Sequence[Listener[T_Stream]] + """ + + listeners: Sequence[Listener[T_Stream]] + + def __post_init__(self) -> None: + listeners: list[Listener[T_Stream]] = [] + for listener in self.listeners: + if isinstance(listener, MultiListener): + listeners.extend(listener.listeners) + del listener.listeners[:] # type: ignore[attr-defined] + else: + listeners.append(listener) + + self.listeners = listeners + + async def serve( + self, handler: Callable[[T_Stream], Any], task_group: TaskGroup | None = None + ) -> None: + from .. import create_task_group + + async with create_task_group() as tg: + for listener in self.listeners: + tg.start_soon(listener.serve, handler, task_group) + + async def aclose(self) -> None: + for listener in self.listeners: + await listener.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + attributes: dict = {} + for listener in self.listeners: + attributes.update(listener.extra_attributes) + + return attributes diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/text.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/text.py new file mode 100644 index 0000000000000000000000000000000000000000..296cd250459f3848bb333301fff1ac32973f219a --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/text.py @@ -0,0 +1,176 @@ +from __future__ import annotations + +__all__ = ( + "TextConnectable", + "TextReceiveStream", + "TextSendStream", + "TextStream", +) + +import codecs +import sys +from collections.abc import Callable, Mapping +from dataclasses import InitVar, dataclass, field +from typing import Any + +from ..abc import ( + AnyByteReceiveStream, + AnyByteSendStream, + AnyByteStream, + AnyByteStreamConnectable, + ObjectReceiveStream, + ObjectSendStream, + ObjectStream, + ObjectStreamConnectable, +) + +if sys.version_info >= (3, 12): + from typing import override +else: + from typing_extensions import override + + +@dataclass(eq=False) +class TextReceiveStream(ObjectReceiveStream[str]): + """ + Stream wrapper that decodes bytes to strings using the given encoding. + + Decoding is done using :class:`~codecs.IncrementalDecoder` which returns any + completely received unicode characters as soon as they come in. + + :param transport_stream: any bytes-based receive stream + :param encoding: character encoding to use for decoding bytes to strings (defaults + to ``utf-8``) + :param errors: handling scheme for decoding errors (defaults to ``strict``; see the + `codecs module documentation`_ for a comprehensive list of options) + + .. _codecs module documentation: + https://docs.python.org/3/library/codecs.html#codec-objects + """ + + transport_stream: AnyByteReceiveStream + encoding: InitVar[str] = "utf-8" + errors: InitVar[str] = "strict" + _decoder: codecs.IncrementalDecoder = field(init=False) + + def __post_init__(self, encoding: str, errors: str) -> None: + decoder_class = codecs.getincrementaldecoder(encoding) + self._decoder = decoder_class(errors=errors) + + async def receive(self) -> str: + while True: + chunk = await self.transport_stream.receive() + decoded = self._decoder.decode(chunk) + if decoded: + return decoded + + async def aclose(self) -> None: + await self.transport_stream.aclose() + self._decoder.reset() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return self.transport_stream.extra_attributes + + +@dataclass(eq=False) +class TextSendStream(ObjectSendStream[str]): + """ + Sends strings to the wrapped stream as bytes using the given encoding. + + :param AnyByteSendStream transport_stream: any bytes-based send stream + :param str encoding: character encoding to use for encoding strings to bytes + (defaults to ``utf-8``) + :param str errors: handling scheme for encoding errors (defaults to ``strict``; see + the `codecs module documentation`_ for a comprehensive list of options) + + .. _codecs module documentation: + https://docs.python.org/3/library/codecs.html#codec-objects + """ + + transport_stream: AnyByteSendStream + encoding: InitVar[str] = "utf-8" + errors: str = "strict" + _encoder: Callable[..., tuple[bytes, int]] = field(init=False) + + def __post_init__(self, encoding: str) -> None: + self._encoder = codecs.getencoder(encoding) + + async def send(self, item: str) -> None: + encoded = self._encoder(item, self.errors)[0] + await self.transport_stream.send(encoded) + + async def aclose(self) -> None: + await self.transport_stream.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return self.transport_stream.extra_attributes + + +@dataclass(eq=False) +class TextStream(ObjectStream[str]): + """ + A bidirectional stream that decodes bytes to strings on receive and encodes strings + to bytes on send. + + Extra attributes will be provided from both streams, with the receive stream + providing the values in case of a conflict. + + :param AnyByteStream transport_stream: any bytes-based stream + :param str encoding: character encoding to use for encoding/decoding strings to/from + bytes (defaults to ``utf-8``) + :param str errors: handling scheme for encoding errors (defaults to ``strict``; see + the `codecs module documentation`_ for a comprehensive list of options) + + .. _codecs module documentation: + https://docs.python.org/3/library/codecs.html#codec-objects + """ + + transport_stream: AnyByteStream + encoding: InitVar[str] = "utf-8" + errors: InitVar[str] = "strict" + _receive_stream: TextReceiveStream = field(init=False) + _send_stream: TextSendStream = field(init=False) + + def __post_init__(self, encoding: str, errors: str) -> None: + self._receive_stream = TextReceiveStream( + self.transport_stream, encoding=encoding, errors=errors + ) + self._send_stream = TextSendStream( + self.transport_stream, encoding=encoding, errors=errors + ) + + async def receive(self) -> str: + return await self._receive_stream.receive() + + async def send(self, item: str) -> None: + await self._send_stream.send(item) + + async def send_eof(self) -> None: + await self.transport_stream.send_eof() + + async def aclose(self) -> None: + await self._send_stream.aclose() + await self._receive_stream.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + **self._send_stream.extra_attributes, + **self._receive_stream.extra_attributes, + } + + +class TextConnectable(ObjectStreamConnectable[str]): + def __init__(self, connectable: AnyByteStreamConnectable): + """ + :param connectable: the bytestream endpoint to wrap + + """ + self.connectable = connectable + + @override + async def connect(self) -> TextStream: + stream = await self.connectable.connect() + return TextStream(stream) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/tls.py b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/tls.py new file mode 100644 index 0000000000000000000000000000000000000000..b507488c57a3f90c64ea80733910dc9311e5a3e3 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/anyio/streams/tls.py @@ -0,0 +1,424 @@ +from __future__ import annotations + +__all__ = ( + "TLSAttribute", + "TLSConnectable", + "TLSListener", + "TLSStream", +) + +import logging +import re +import ssl +import sys +from collections.abc import Callable, Mapping +from dataclasses import dataclass +from functools import wraps +from ssl import SSLContext +from typing import Any, TypeVar + +from .. import ( + BrokenResourceError, + EndOfStream, + aclose_forcefully, + get_cancelled_exc_class, + to_thread, +) +from .._core._typedattr import TypedAttributeSet, typed_attribute +from ..abc import ( + AnyByteStream, + AnyByteStreamConnectable, + ByteStream, + ByteStreamConnectable, + Listener, + TaskGroup, +) + +if sys.version_info >= (3, 10): + from typing import TypeAlias +else: + from typing_extensions import TypeAlias + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +if sys.version_info >= (3, 12): + from typing import override +else: + from typing_extensions import override + +T_Retval = TypeVar("T_Retval") +PosArgsT = TypeVarTuple("PosArgsT") +_PCTRTT: TypeAlias = tuple[tuple[str, str], ...] +_PCTRTTT: TypeAlias = tuple[_PCTRTT, ...] + + +class TLSAttribute(TypedAttributeSet): + """Contains Transport Layer Security related attributes.""" + + #: the selected ALPN protocol + alpn_protocol: str | None = typed_attribute() + #: the channel binding for type ``tls-unique`` + channel_binding_tls_unique: bytes = typed_attribute() + #: the selected cipher + cipher: tuple[str, str, int] = typed_attribute() + #: the peer certificate in dictionary form (see :meth:`ssl.SSLSocket.getpeercert` + # for more information) + peer_certificate: None | (dict[str, str | _PCTRTTT | _PCTRTT]) = typed_attribute() + #: the peer certificate in binary form + peer_certificate_binary: bytes | None = typed_attribute() + #: ``True`` if this is the server side of the connection + server_side: bool = typed_attribute() + #: ciphers shared by the client during the TLS handshake (``None`` if this is the + #: client side) + shared_ciphers: list[tuple[str, str, int]] | None = typed_attribute() + #: the :class:`~ssl.SSLObject` used for encryption + ssl_object: ssl.SSLObject = typed_attribute() + #: ``True`` if this stream does (and expects) a closing TLS handshake when the + #: stream is being closed + standard_compatible: bool = typed_attribute() + #: the TLS protocol version (e.g. ``TLSv1.2``) + tls_version: str = typed_attribute() + + +@dataclass(eq=False) +class TLSStream(ByteStream): + """ + A stream wrapper that encrypts all sent data and decrypts received data. + + This class has no public initializer; use :meth:`wrap` instead. + All extra attributes from :class:`~TLSAttribute` are supported. + + :var AnyByteStream transport_stream: the wrapped stream + + """ + + transport_stream: AnyByteStream + standard_compatible: bool + _ssl_object: ssl.SSLObject + _read_bio: ssl.MemoryBIO + _write_bio: ssl.MemoryBIO + + @classmethod + async def wrap( + cls, + transport_stream: AnyByteStream, + *, + server_side: bool | None = None, + hostname: str | None = None, + ssl_context: ssl.SSLContext | None = None, + standard_compatible: bool = True, + ) -> TLSStream: + """ + Wrap an existing stream with Transport Layer Security. + + This performs a TLS handshake with the peer. + + :param transport_stream: a bytes-transporting stream to wrap + :param server_side: ``True`` if this is the server side of the connection, + ``False`` if this is the client side (if omitted, will be set to ``False`` + if ``hostname`` has been provided, ``False`` otherwise). Used only to create + a default context when an explicit context has not been provided. + :param hostname: host name of the peer (if host name checking is desired) + :param ssl_context: the SSLContext object to use (if not provided, a secure + default will be created) + :param standard_compatible: if ``False``, skip the closing handshake when + closing the connection, and don't raise an exception if the peer does the + same + :raises ~ssl.SSLError: if the TLS handshake fails + + """ + if server_side is None: + server_side = not hostname + + if not ssl_context: + purpose = ( + ssl.Purpose.CLIENT_AUTH if server_side else ssl.Purpose.SERVER_AUTH + ) + ssl_context = ssl.create_default_context(purpose) + + # Re-enable detection of unexpected EOFs if it was disabled by Python + if hasattr(ssl, "OP_IGNORE_UNEXPECTED_EOF"): + ssl_context.options &= ~ssl.OP_IGNORE_UNEXPECTED_EOF + + bio_in = ssl.MemoryBIO() + bio_out = ssl.MemoryBIO() + + # External SSLContext implementations may do blocking I/O in wrap_bio(), + # but the standard library implementation won't + if type(ssl_context) is ssl.SSLContext: + ssl_object = ssl_context.wrap_bio( + bio_in, bio_out, server_side=server_side, server_hostname=hostname + ) + else: + ssl_object = await to_thread.run_sync( + ssl_context.wrap_bio, + bio_in, + bio_out, + server_side, + hostname, + None, + ) + + wrapper = cls( + transport_stream=transport_stream, + standard_compatible=standard_compatible, + _ssl_object=ssl_object, + _read_bio=bio_in, + _write_bio=bio_out, + ) + await wrapper._call_sslobject_method(ssl_object.do_handshake) + return wrapper + + async def _call_sslobject_method( + self, func: Callable[[Unpack[PosArgsT]], T_Retval], *args: Unpack[PosArgsT] + ) -> T_Retval: + while True: + try: + result = func(*args) + except ssl.SSLWantReadError: + try: + # Flush any pending writes first + if self._write_bio.pending: + await self.transport_stream.send(self._write_bio.read()) + + data = await self.transport_stream.receive() + except EndOfStream: + self._read_bio.write_eof() + except OSError as exc: + self._read_bio.write_eof() + self._write_bio.write_eof() + raise BrokenResourceError from exc + else: + self._read_bio.write(data) + except ssl.SSLWantWriteError: + await self.transport_stream.send(self._write_bio.read()) + except ssl.SSLSyscallError as exc: + self._read_bio.write_eof() + self._write_bio.write_eof() + raise BrokenResourceError from exc + except ssl.SSLError as exc: + self._read_bio.write_eof() + self._write_bio.write_eof() + if isinstance(exc, ssl.SSLEOFError) or ( + exc.strerror and "UNEXPECTED_EOF_WHILE_READING" in exc.strerror + ): + if self.standard_compatible: + raise BrokenResourceError from exc + else: + raise EndOfStream from None + + raise + else: + # Flush any pending writes first + if self._write_bio.pending: + await self.transport_stream.send(self._write_bio.read()) + + return result + + async def unwrap(self) -> tuple[AnyByteStream, bytes]: + """ + Does the TLS closing handshake. + + :return: a tuple of (wrapped byte stream, bytes left in the read buffer) + + """ + await self._call_sslobject_method(self._ssl_object.unwrap) + self._read_bio.write_eof() + self._write_bio.write_eof() + return self.transport_stream, self._read_bio.read() + + async def aclose(self) -> None: + if self.standard_compatible: + try: + await self.unwrap() + except BaseException: + await aclose_forcefully(self.transport_stream) + raise + + await self.transport_stream.aclose() + + async def receive(self, max_bytes: int = 65536) -> bytes: + data = await self._call_sslobject_method(self._ssl_object.read, max_bytes) + if not data: + raise EndOfStream + + return data + + async def send(self, item: bytes) -> None: + await self._call_sslobject_method(self._ssl_object.write, item) + + async def send_eof(self) -> None: + tls_version = self.extra(TLSAttribute.tls_version) + match = re.match(r"TLSv(\d+)(?:\.(\d+))?", tls_version) + if match: + major, minor = int(match.group(1)), int(match.group(2) or 0) + if (major, minor) < (1, 3): + raise NotImplementedError( + f"send_eof() requires at least TLSv1.3; current " + f"session uses {tls_version}" + ) + + raise NotImplementedError( + "send_eof() has not yet been implemented for TLS streams" + ) + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + **self.transport_stream.extra_attributes, + TLSAttribute.alpn_protocol: self._ssl_object.selected_alpn_protocol, + TLSAttribute.channel_binding_tls_unique: ( + self._ssl_object.get_channel_binding + ), + TLSAttribute.cipher: self._ssl_object.cipher, + TLSAttribute.peer_certificate: lambda: self._ssl_object.getpeercert(False), + TLSAttribute.peer_certificate_binary: lambda: self._ssl_object.getpeercert( + True + ), + TLSAttribute.server_side: lambda: self._ssl_object.server_side, + TLSAttribute.shared_ciphers: lambda: self._ssl_object.shared_ciphers() + if self._ssl_object.server_side + else None, + TLSAttribute.standard_compatible: lambda: self.standard_compatible, + TLSAttribute.ssl_object: lambda: self._ssl_object, + TLSAttribute.tls_version: self._ssl_object.version, + } + + +@dataclass(eq=False) +class TLSListener(Listener[TLSStream]): + """ + A convenience listener that wraps another listener and auto-negotiates a TLS session + on every accepted connection. + + If the TLS handshake times out or raises an exception, + :meth:`handle_handshake_error` is called to do whatever post-mortem processing is + deemed necessary. + + Supports only the :attr:`~TLSAttribute.standard_compatible` extra attribute. + + :param Listener listener: the listener to wrap + :param ssl_context: the SSL context object + :param standard_compatible: a flag passed through to :meth:`TLSStream.wrap` + :param handshake_timeout: time limit for the TLS handshake + (passed to :func:`~anyio.fail_after`) + """ + + listener: Listener[Any] + ssl_context: ssl.SSLContext + standard_compatible: bool = True + handshake_timeout: float = 30 + + @staticmethod + async def handle_handshake_error(exc: BaseException, stream: AnyByteStream) -> None: + """ + Handle an exception raised during the TLS handshake. + + This method does 3 things: + + #. Forcefully closes the original stream + #. Logs the exception (unless it was a cancellation exception) using the + ``anyio.streams.tls`` logger + #. Reraises the exception if it was a base exception or a cancellation exception + + :param exc: the exception + :param stream: the original stream + + """ + await aclose_forcefully(stream) + + # Log all except cancellation exceptions + if not isinstance(exc, get_cancelled_exc_class()): + # CPython (as of 3.11.5) returns incorrect `sys.exc_info()` here when using + # any asyncio implementation, so we explicitly pass the exception to log + # (https://github.com/python/cpython/issues/108668). Trio does not have this + # issue because it works around the CPython bug. + logging.getLogger(__name__).exception( + "Error during TLS handshake", exc_info=exc + ) + + # Only reraise base exceptions and cancellation exceptions + if not isinstance(exc, Exception) or isinstance(exc, get_cancelled_exc_class()): + raise + + async def serve( + self, + handler: Callable[[TLSStream], Any], + task_group: TaskGroup | None = None, + ) -> None: + @wraps(handler) + async def handler_wrapper(stream: AnyByteStream) -> None: + from .. import fail_after + + try: + with fail_after(self.handshake_timeout): + wrapped_stream = await TLSStream.wrap( + stream, + ssl_context=self.ssl_context, + standard_compatible=self.standard_compatible, + ) + except BaseException as exc: + await self.handle_handshake_error(exc, stream) + else: + await handler(wrapped_stream) + + await self.listener.serve(handler_wrapper, task_group) + + async def aclose(self) -> None: + await self.listener.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + TLSAttribute.standard_compatible: lambda: self.standard_compatible, + } + + +class TLSConnectable(ByteStreamConnectable): + """ + Wraps another connectable and does TLS negotiation after a successful connection. + + :param connectable: the connectable to wrap + :param hostname: host name of the server (if host name checking is desired) + :param ssl_context: the SSLContext object to use (if not provided, a secure default + will be created) + :param standard_compatible: if ``False``, skip the closing handshake when closing + the connection, and don't raise an exception if the server does the same + """ + + def __init__( + self, + connectable: AnyByteStreamConnectable, + *, + hostname: str | None = None, + ssl_context: ssl.SSLContext | None = None, + standard_compatible: bool = True, + ) -> None: + self.connectable = connectable + self.ssl_context: SSLContext = ssl_context or ssl.create_default_context( + ssl.Purpose.SERVER_AUTH + ) + if not isinstance(self.ssl_context, ssl.SSLContext): + raise TypeError( + "ssl_context must be an instance of ssl.SSLContext, not " + f"{type(self.ssl_context).__name__}" + ) + self.hostname = hostname + self.standard_compatible = standard_compatible + + @override + async def connect(self) -> TLSStream: + stream = await self.connectable.connect() + try: + return await TLSStream.wrap( + stream, + hostname=self.hostname, + ssl_context=self.ssl_context, + standard_compatible=self.standard_compatible, + ) + except BaseException: + await aclose_forcefully(stream) + raise diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/__init__.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d8e56a4eca3749f3df543b4c8f2553acb441266 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/__init__.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_cmp.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_cmp.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c9a2f496a299b92dd8211d9a6de1ed86c1be2fa2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_cmp.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_compat.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_compat.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dbd079fcb22419a3f8228457a17eecd29a82b273 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_compat.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_config.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_config.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19df1c3493a8bd847377680eea2418341e21304b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_config.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_funcs.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_funcs.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..74f5cf8bb3db4022ce2421a4ea823aee86def3b7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_funcs.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_next_gen.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_next_gen.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f468c2f8d549ea07d9663abb221827ccae0341e4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_next_gen.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_version_info.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_version_info.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf7d7f00484d38e4468a5d2709a116d7ccbd4d09 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/_version_info.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/converters.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/converters.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfdc588b2550d02ff62bef92972341d968a776ce Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/converters.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/exceptions.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/exceptions.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..781ed41b03e4a3244399149d5a39cdb649704a8a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/exceptions.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/filters.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/filters.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8870d9fac0ce3e9c49ae9bd261957d3a75597e61 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/filters.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/setters.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/setters.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a5c68020cb3f8241df72fc929874c44ed8d7f7ab Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/setters.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/validators.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/validators.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..18949d75d3af71389539b5d3747a60a870e5e56f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attr/__pycache__/validators.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attrs-25.4.0.dist-info/licenses/LICENSE b/TTS/Kokoro/.venv/Lib/site-packages/attrs-25.4.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..2bd6453d255e19b973f19b128596a8b6dd65b2c3 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/attrs-25.4.0.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 Hynek Schlawack and the attrs contributors + +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. diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/__init__.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2c9855e1afa1776eac72a9d3a69170e7c5d1c185 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/__init__.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/converters.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/converters.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e843276883b2ca65ff0c023ece874aad4cab0c7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/converters.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/exceptions.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/exceptions.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f14bee19a4a85c8e1d04a3bd9d7c16cd2a62742 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/exceptions.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/filters.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/filters.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f12e3d057c58a442fdc11c366e05978d9e46c786 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/filters.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/setters.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/setters.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cfd78bbdeec6bd14ab6d1427a67e2ed119bac969 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/setters.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/validators.cpython-312.pyc b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/validators.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..20f5acaf4ead30702fd152faeea6ec385e672e9c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/attrs/__pycache__/validators.cpython-312.pyc differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/LICENSE.unicode b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/LICENSE.unicode new file mode 100644 index 0000000000000000000000000000000000000000..861b74f3c812088755fd185d964e82a244503bbd --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/LICENSE.unicode @@ -0,0 +1,41 @@ +UNICODE LICENSE V3 + +COPYRIGHT AND PERMISSION NOTICE + +Copyright © 2004-2025 Unicode, Inc. + +NOTICE TO USER: Carefully read the following legal agreement. BY +DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR +SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE +TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT +DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of data files and any associated documentation (the "Data Files") or +software and any associated documentation (the "Software") to deal in the +Data Files or Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, and/or sell +copies of the Data Files or Software, and to permit persons to whom the +Data Files or Software are furnished to do so, provided that either (a) +this copyright and permission notice appear with all copies of the Data +Files or Software, or (b) this copyright and permission notice appear in +associated Documentation. + +THE DATA FILES AND SOFTWARE ARE 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 OF +THIRD PARTY RIGHTS. + +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE +BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, +OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA +FILES OR SOFTWARE. + +Except as contained in this notice, the name of a copyright holder shall +not be used in advertising or otherwise to promote the sale, use or other +dealings in these Data Files or Software without prior written +authorization of the copyright holder. + +SPDX-License-Identifier: Unicode-3.0 diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa.dat new file mode 100644 index 0000000000000000000000000000000000000000..96b76a0033da33c6475640d3c10b20553ff128f4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa_DJ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa_DJ.dat new file mode 100644 index 0000000000000000000000000000000000000000..a3cb25635686451036b2754a2fb3c115b601a35a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa_DJ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa_ER.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa_ER.dat new file mode 100644 index 0000000000000000000000000000000000000000..a01edfca24195f77fc9cebfee00528f0be2d0a28 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa_ER.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa_ET.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa_ET.dat new file mode 100644 index 0000000000000000000000000000000000000000..119b891baccebe30a7c541ad82287c42dd675e2d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/aa_ET.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ab.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ab.dat new file mode 100644 index 0000000000000000000000000000000000000000..e1fbc6e6ef253786ea7444696479d0405d806115 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ab.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ab_GE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ab_GE.dat new file mode 100644 index 0000000000000000000000000000000000000000..15a980a714dee2c227f588cdaba5a3ec0d8ec830 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ab_GE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/af_NA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/af_NA.dat new file mode 100644 index 0000000000000000000000000000000000000000..d5ff2a3130c747a97805ce34b1a5365cadc7978a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/af_NA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/af_ZA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/af_ZA.dat new file mode 100644 index 0000000000000000000000000000000000000000..34779331c556c4dbe224b04867fee269e88ab24c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/af_ZA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/agq.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/agq.dat new file mode 100644 index 0000000000000000000000000000000000000000..a4eb919cd600397f3d722af988161e4c119a2e32 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/agq.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/agq_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/agq_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..57701c907d881ea5c8dd802b9d701d7c91b5dac2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/agq_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ak_GH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ak_GH.dat new file mode 100644 index 0000000000000000000000000000000000000000..a7c63daece80eab852e7bd80116053cd75f9063b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ak_GH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/am_ET.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/am_ET.dat new file mode 100644 index 0000000000000000000000000000000000000000..050cc76cc386513fca847f429550fba80898e3ab Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/am_ET.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/an.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/an.dat new file mode 100644 index 0000000000000000000000000000000000000000..1678ebce14fcd31fbe89d2a83e8e098e7c50b353 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/an.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/an_ES.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/an_ES.dat new file mode 100644 index 0000000000000000000000000000000000000000..a11156aacce8a5036e4301bbbb2ffbc931f5edae Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/an_ES.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ann.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ann.dat new file mode 100644 index 0000000000000000000000000000000000000000..cee6e2bb26f5cedef28b9e63de62244618bd8a72 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ann.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ann_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ann_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..612c3f89db737657e53e5779f54aaff56135354f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ann_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/apc.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/apc.dat new file mode 100644 index 0000000000000000000000000000000000000000..644ec2a159bc375568b8254ac91e85609052cb4c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/apc.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/apc_SY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/apc_SY.dat new file mode 100644 index 0000000000000000000000000000000000000000..6c5e15a7b9e8949f6436290a5020c46c7397e457 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/apc_SY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_001.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_001.dat new file mode 100644 index 0000000000000000000000000000000000000000..bdc0475f08f1e198c56f1d84a10a7a2d0449ee28 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_001.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_AE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_AE.dat new file mode 100644 index 0000000000000000000000000000000000000000..f838659750a4b2e43a7ece8b17674129cc8c6870 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_AE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_BH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_BH.dat new file mode 100644 index 0000000000000000000000000000000000000000..1792ea6b19832faf5e0fc5696b9129fa7dbc9eb2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_BH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_DJ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_DJ.dat new file mode 100644 index 0000000000000000000000000000000000000000..579056a59b874110abeb989deb701d16aa7ef2a7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_DJ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_DZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_DZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..2d61edcd8e1d67a6595e5c2fad3957f7d0993b7c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_DZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_EG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_EG.dat new file mode 100644 index 0000000000000000000000000000000000000000..d9be03e1c24531c71da7ffa7212dad0b9b816fbd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_EG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_EH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_EH.dat new file mode 100644 index 0000000000000000000000000000000000000000..df44a58b82d83dde1ff1d20e7ec74aa31af90eb9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_EH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_ER.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_ER.dat new file mode 100644 index 0000000000000000000000000000000000000000..cd0364300c3703d8ed4c2c38207c24d28c248a7d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_ER.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_IL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_IL.dat new file mode 100644 index 0000000000000000000000000000000000000000..557c47f47059810f6cac6611cccdbbe608ba33b7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_IL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_IQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_IQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..5b3d21c4487ae584b649e34bdd7fd18d06285ff7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_IQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_JO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_JO.dat new file mode 100644 index 0000000000000000000000000000000000000000..8bf13f2428a9981bf1a7371d07c387216fe110ef Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_JO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_KM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_KM.dat new file mode 100644 index 0000000000000000000000000000000000000000..88f1ac48bd1c1c61d48fbff7ddd6b21ff8eacb74 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_KM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_KW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_KW.dat new file mode 100644 index 0000000000000000000000000000000000000000..80762a479a48418e61556385242129803461ea03 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_KW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_LB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_LB.dat new file mode 100644 index 0000000000000000000000000000000000000000..060dfa4902bc34c9f2475c0bca0b425ef4ccb4c3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_LB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_LY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_LY.dat new file mode 100644 index 0000000000000000000000000000000000000000..a870e157c8863cf1aa13c0598ae1b261a4fe1448 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_LY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_MA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_MA.dat new file mode 100644 index 0000000000000000000000000000000000000000..ecdc22a57a258d7d2bf69c5f98dbbf199f0fdb34 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_MA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_MR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_MR.dat new file mode 100644 index 0000000000000000000000000000000000000000..7d66b5cf96182eb3418daaef4a32367f70d4590b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_MR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_OM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_OM.dat new file mode 100644 index 0000000000000000000000000000000000000000..d318d99fd7e21f1e543abb51ee99e875d9dc61a0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_OM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_PS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_PS.dat new file mode 100644 index 0000000000000000000000000000000000000000..2c3ef839d0323e3a07fa7285a309f216c619fd85 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_PS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_QA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_QA.dat new file mode 100644 index 0000000000000000000000000000000000000000..d187cc662347f457f6b2fd9f9f66f3f495229cbd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_QA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SA.dat new file mode 100644 index 0000000000000000000000000000000000000000..ae1ecaedc7d2002601631ab8ce7c5eca6fde9fb1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SD.dat new file mode 100644 index 0000000000000000000000000000000000000000..0ce23d8af072390261bcfa5ac57099f944f911f6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SO.dat new file mode 100644 index 0000000000000000000000000000000000000000..ed6648bc3f92e0a020c293b33f3f6d9baf394cdb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SS.dat new file mode 100644 index 0000000000000000000000000000000000000000..a2cadef74cc4cf202b2b5786279f01adf9817ca1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SY.dat new file mode 100644 index 0000000000000000000000000000000000000000..701de7adbc50f6008a1bda586fc51347ffb5ad7d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_SY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_TD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_TD.dat new file mode 100644 index 0000000000000000000000000000000000000000..deb0d9c4ced7b76716bab7c7099f80b633fe0abf Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_TD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_TN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_TN.dat new file mode 100644 index 0000000000000000000000000000000000000000..46853cec1a0555101a1f1a3b1318401376ba3340 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_TN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_YE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_YE.dat new file mode 100644 index 0000000000000000000000000000000000000000..8c2212b59aa24028471b0a6897d51f5ee8b81208 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ar_YE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/arn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/arn.dat new file mode 100644 index 0000000000000000000000000000000000000000..5abcc770a1daaa4d5bcf551ea30b6e8f1bb6a796 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/arn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/arn_CL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/arn_CL.dat new file mode 100644 index 0000000000000000000000000000000000000000..4aadebb14ae8e2071955943e59cd000bfec9e7f3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/arn_CL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/as_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/as_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..9f24d23082233fe3d9b3dde84b07a31793f69e12 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/as_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/asa.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/asa.dat new file mode 100644 index 0000000000000000000000000000000000000000..6c4f84f4627e949a3faf0e8c6fd4929ddabada77 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/asa.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/asa_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/asa_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..0b2adf25c99a6302fff5c878add74b60f266f88d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/asa_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ast_ES.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ast_ES.dat new file mode 100644 index 0000000000000000000000000000000000000000..af96de068f56934fc8355a71d52a25dc52108c2a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ast_ES.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab.dat new file mode 100644 index 0000000000000000000000000000000000000000..d18ccb510a2cf9b3f32838395a33f3af403f8811 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab_IQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab_IQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..393175fc4cc25cf794a0e1673bee0d41ae4acece Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab_IQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab_IR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab_IR.dat new file mode 100644 index 0000000000000000000000000000000000000000..8df9df25123613f36dbc71277b45eea350de15ce Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab_IR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab_TR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab_TR.dat new file mode 100644 index 0000000000000000000000000000000000000000..99fa84c46fbf81b82485c1abf1b735d4dad972db Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Arab_TR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Cyrl.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Cyrl.dat new file mode 100644 index 0000000000000000000000000000000000000000..2f79fbd082ebdb88e1153809ce50f8ca3a5adba0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Cyrl.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Cyrl_AZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Cyrl_AZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..75ee5220b3f24e0ff72922de1a6fc6c5395ccd8f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Cyrl_AZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Latn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Latn.dat new file mode 100644 index 0000000000000000000000000000000000000000..88c306fe8ed7f377862a68ed397d4dfa243d5bae Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Latn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Latn_AZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Latn_AZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..75ee5220b3f24e0ff72922de1a6fc6c5395ccd8f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/az_Latn_AZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ba.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ba.dat new file mode 100644 index 0000000000000000000000000000000000000000..99bc134f77e7797f8aa3d54808c29ec4409ed7fa Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ba.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ba_RU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ba_RU.dat new file mode 100644 index 0000000000000000000000000000000000000000..93dadc0fdcda7e91961102f2fd18782f58e5facd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ba_RU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal.dat new file mode 100644 index 0000000000000000000000000000000000000000..6135e5a3948f63e6a790cb3252b1e3504bacad9a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal_Arab.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal_Arab.dat new file mode 100644 index 0000000000000000000000000000000000000000..9fc6e82e132c4ddc1cf7ced7b54997993d24c75e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal_Arab.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal_Arab_PK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal_Arab_PK.dat new file mode 100644 index 0000000000000000000000000000000000000000..37f77e20a193813f04c6ee0a3d21cdc87d260062 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal_Arab_PK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal_Latn_PK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal_Latn_PK.dat new file mode 100644 index 0000000000000000000000000000000000000000..37f77e20a193813f04c6ee0a3d21cdc87d260062 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bal_Latn_PK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bas.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bas.dat new file mode 100644 index 0000000000000000000000000000000000000000..6afbc89dedd7d4c0f820fb71f16554bb3e37f7cf Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bas.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bas_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bas_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..992e8632e4b3f20c647af89430113cf87fb62b0b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bas_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/be_BY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/be_BY.dat new file mode 100644 index 0000000000000000000000000000000000000000..759f67a1cc5890f15d75b4968e70b26c71ce743f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/be_BY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bem.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bem.dat new file mode 100644 index 0000000000000000000000000000000000000000..35c138fca609fe85d83a45f34baffe3c1a1b04a1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bem.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bem_ZM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bem_ZM.dat new file mode 100644 index 0000000000000000000000000000000000000000..7f393a8bd45604553055fcce933b0487f599601e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bem_ZM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bew_ID.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bew_ID.dat new file mode 100644 index 0000000000000000000000000000000000000000..12cfbff66b86b5b94d403396fd4769becd6bdc4d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bew_ID.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bez.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bez.dat new file mode 100644 index 0000000000000000000000000000000000000000..04e40d183fd451293b96c09a16f32a4b73915987 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bez.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bez_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bez_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..76974eb111579a685272ce5b72a72232247dbefa Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bez_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bg_BG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bg_BG.dat new file mode 100644 index 0000000000000000000000000000000000000000..b69fe97905fd55b26c8430bd01ae17debd5b9482 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bg_BG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgc.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgc.dat new file mode 100644 index 0000000000000000000000000000000000000000..1a3cdd55f16cc38bda434169e71021768b1c4504 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgc.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgc_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgc_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..bc2e02172ab26ce98688f7b18eb355f4a19a3385 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgc_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn.dat new file mode 100644 index 0000000000000000000000000000000000000000..f8297eb3d293365575fec39019e1528173611066 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_AE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_AE.dat new file mode 100644 index 0000000000000000000000000000000000000000..0b17e78f8b36c9f42a011bbd3d142d22195d6d0d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_AE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_AF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_AF.dat new file mode 100644 index 0000000000000000000000000000000000000000..4062c74dbf1d5ca0f7cc8febf8573f07591bab15 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_AF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_IR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_IR.dat new file mode 100644 index 0000000000000000000000000000000000000000..99a1b50062132ab729bf979427447e38b56706be Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_IR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_OM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_OM.dat new file mode 100644 index 0000000000000000000000000000000000000000..f3962683f1823e2ae5a68b545bf94d7c39c09229 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_OM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_PK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_PK.dat new file mode 100644 index 0000000000000000000000000000000000000000..e15afea2c9d6eb0639289f44ebdd0f2aefdb2153 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bgn_PK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bho.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bho.dat new file mode 100644 index 0000000000000000000000000000000000000000..15f164ee9eb89ea08439e93badb57b165d039fb7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bho.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bho_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bho_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..4f7eb58e352c34053b2747472676cc764752d508 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bho_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/blo_BJ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/blo_BJ.dat new file mode 100644 index 0000000000000000000000000000000000000000..fbc0ae5170ce117ded221b89c8688ec471682b27 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/blo_BJ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/blt.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/blt.dat new file mode 100644 index 0000000000000000000000000000000000000000..fee952118c77c7994fe19c9d317e74804c63eeb5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/blt.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/blt_VN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/blt_VN.dat new file mode 100644 index 0000000000000000000000000000000000000000..1cf8aa304f149281e4d8a476cc4eec079f03df16 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/blt_VN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm.dat new file mode 100644 index 0000000000000000000000000000000000000000..35a8748fb7ba0b86385a66ee5b1d2719c9620c8f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm_ML.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm_ML.dat new file mode 100644 index 0000000000000000000000000000000000000000..db406084c6b19336f6c8ce1ae9c1b595e153b0b5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm_ML.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm_Nkoo.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm_Nkoo.dat new file mode 100644 index 0000000000000000000000000000000000000000..318955fea46286d7fd0eea6dd6086a2116301e29 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm_Nkoo.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm_Nkoo_ML.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm_Nkoo_ML.dat new file mode 100644 index 0000000000000000000000000000000000000000..db406084c6b19336f6c8ce1ae9c1b595e153b0b5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bm_Nkoo_ML.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bn_BD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bn_BD.dat new file mode 100644 index 0000000000000000000000000000000000000000..0814ec91dabd16255729320740d6850a7b6ba3ec Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bn_BD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bn_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bn_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..ea4c51c3221fd13406d34be235d9c18ed08a60c8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bn_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bo.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bo.dat new file mode 100644 index 0000000000000000000000000000000000000000..3e914649a37368a941a691f4571888b09fa764e1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bo.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bo_CN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bo_CN.dat new file mode 100644 index 0000000000000000000000000000000000000000..d9e62431203c4d41f84d0d1c9e0f2c8b928adddf Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bo_CN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bo_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bo_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..900a19e753e39513358e77ee8caa75892fe3a67b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bo_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/br_FR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/br_FR.dat new file mode 100644 index 0000000000000000000000000000000000000000..5964d661464cfbee086d2fc7c5974c2bbdb1c1a0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/br_FR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/brx_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/brx_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..6dafcc92652610eb937d141699f6ed32dc0d80bb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/brx_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bs_Cyrl_BA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bs_Cyrl_BA.dat new file mode 100644 index 0000000000000000000000000000000000000000..4a56da8f12bdf53b805f401364887b89b6127370 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bs_Cyrl_BA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bs_Latn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bs_Latn.dat new file mode 100644 index 0000000000000000000000000000000000000000..767af2e9f8f61a8056d684dc692372f2ef084e47 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bs_Latn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bs_Latn_BA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bs_Latn_BA.dat new file mode 100644 index 0000000000000000000000000000000000000000..4a56da8f12bdf53b805f401364887b89b6127370 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bs_Latn_BA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bss.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bss.dat new file mode 100644 index 0000000000000000000000000000000000000000..9b59977cfe4a05e65eb29b62730266b253243abc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bss.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bss_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bss_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..c02e93f2565988df568734714b40e80f62c51a51 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/bss_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/byn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/byn.dat new file mode 100644 index 0000000000000000000000000000000000000000..c8a14266747ab00c4c32785b99ac03f67eed9a0d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/byn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/byn_ER.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/byn_ER.dat new file mode 100644 index 0000000000000000000000000000000000000000..ef7364c07458ad5406840d32311f3a201a77f1c4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/byn_ER.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_AD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_AD.dat new file mode 100644 index 0000000000000000000000000000000000000000..417de47004156ba5b11b8718e1afd5d95b51c019 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_AD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_ES.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_ES.dat new file mode 100644 index 0000000000000000000000000000000000000000..1262e7c7d724c87b9362314220712ec79a0bd5ff Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_ES.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_ES_VALENCIA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_ES_VALENCIA.dat new file mode 100644 index 0000000000000000000000000000000000000000..f9a67d74a1fb482037eb21e32aa452e132336898 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_ES_VALENCIA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_FR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_FR.dat new file mode 100644 index 0000000000000000000000000000000000000000..1e13497d0fe23a430123235472ebbee4f6948f4b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_FR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..18daef701f3b6448432cb61f9461b63fa3ae53db Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ca_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cad.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cad.dat new file mode 100644 index 0000000000000000000000000000000000000000..e0751fea1fcd9df8ff1c391d417ac61d9d5bdb7d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cad.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cad_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cad_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..649a127793f376de545e3baac652178fa50d0188 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cad_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cch.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cch.dat new file mode 100644 index 0000000000000000000000000000000000000000..6bfb265eecc037ad895d16557ebdc6dfe70985fa Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cch.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cch_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cch_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..7ca50d067b03a79e5f09b3e254529eafd2b1f94c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cch_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ccp_BD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ccp_BD.dat new file mode 100644 index 0000000000000000000000000000000000000000..23248d87cd09d86965ce11a59e320b55436df5a8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ccp_BD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ccp_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ccp_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..e4fe9a0158fa8d3f231435decb8b82572242be4a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ccp_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ce_RU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ce_RU.dat new file mode 100644 index 0000000000000000000000000000000000000000..613de6603e5843e5f977382d38d1cf6d27f1dec4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ce_RU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ceb_PH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ceb_PH.dat new file mode 100644 index 0000000000000000000000000000000000000000..f5a88a136feb6d7d36be2a8ada45b405dcad27b9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ceb_PH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cgg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cgg.dat new file mode 100644 index 0000000000000000000000000000000000000000..5687c38bbfc733145010a4883043f0e719b05c93 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cgg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cgg_UG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cgg_UG.dat new file mode 100644 index 0000000000000000000000000000000000000000..3ed7de5ef69ca3b432e47520a8e1946353406b84 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cgg_UG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cho.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cho.dat new file mode 100644 index 0000000000000000000000000000000000000000..8d978b7cba4761132fbeba76c87b2189060a1929 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cho.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cho_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cho_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..927cd4515824f27eb037dec05c1ce0af24dca32b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cho_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/chr_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/chr_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..305798529f43ed96f33a3b104a94f99ca5f75cce Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/chr_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cic.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cic.dat new file mode 100644 index 0000000000000000000000000000000000000000..878775630166ddb6501c57b842ac5d79fe00af8d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cic.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cic_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cic_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..a2f944fbe0ea89a707ef029fe3b8366dfb0219e3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cic_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ckb.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ckb.dat new file mode 100644 index 0000000000000000000000000000000000000000..e8f1be3eeba7bc5780d7d9bf8c20812d1ecb2b68 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ckb.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ckb_IQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ckb_IQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..68ae78b5dbf6c9465a3af59c0469d24714a744cb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ckb_IQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ckb_IR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ckb_IR.dat new file mode 100644 index 0000000000000000000000000000000000000000..407a60584b2205a47cf5fa81b61d783f84527483 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ckb_IR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/co.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/co.dat new file mode 100644 index 0000000000000000000000000000000000000000..cf9e7bc6c963fa86c62c7f8ccb79aeec7548d0b9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/co.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/co_FR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/co_FR.dat new file mode 100644 index 0000000000000000000000000000000000000000..ac968523e7a54203de695e43438a75e4b614c3cd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/co_FR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cop.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cop.dat new file mode 100644 index 0000000000000000000000000000000000000000..01dd6959af4fa47109dde19c0f25a89d049e4e49 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cop.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cop_EG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cop_EG.dat new file mode 100644 index 0000000000000000000000000000000000000000..c6811e71512a4bdbfd4b9498ec03fbe76fc2c8cc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cop_EG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cs_CZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cs_CZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..0c492c42e18da675aaa5203b4e32d59d217beb5b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cs_CZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/csw.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/csw.dat new file mode 100644 index 0000000000000000000000000000000000000000..1224a99e3dc8b8de21ee301d59276fae3fe4c287 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/csw.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/csw_CA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/csw_CA.dat new file mode 100644 index 0000000000000000000000000000000000000000..01b6c60756b59a78f543477d3d7bb72145b2b697 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/csw_CA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cu.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cu.dat new file mode 100644 index 0000000000000000000000000000000000000000..19443c5208eafbe03e03ef361cf37f956a7f2408 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cu.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cu_RU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cu_RU.dat new file mode 100644 index 0000000000000000000000000000000000000000..a9d3101e6a5e3d757ec6495d4269ca62c2cd6d56 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cu_RU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cv_RU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cv_RU.dat new file mode 100644 index 0000000000000000000000000000000000000000..597599149a3276f5baa0328533bf4582b1a43531 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cv_RU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cy_GB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cy_GB.dat new file mode 100644 index 0000000000000000000000000000000000000000..f3febac60c7e0e4b45d60dd4eb76b064f235de5a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/cy_GB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/da_DK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/da_DK.dat new file mode 100644 index 0000000000000000000000000000000000000000..dbd067201ec8a548a3f31db287a76c9c3cad0387 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/da_DK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/da_GL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/da_GL.dat new file mode 100644 index 0000000000000000000000000000000000000000..ce46da126f18a4b27889ebd6b9ee23d319ce48ce Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/da_GL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dav.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dav.dat new file mode 100644 index 0000000000000000000000000000000000000000..8b63c2b6a4084640a08178402f4071c4ebcdde38 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dav.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dav_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dav_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..5e3fbf481317029a5d82fd45fd66ac6623d79d76 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dav_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_AT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_AT.dat new file mode 100644 index 0000000000000000000000000000000000000000..c8b9b62ec121d90118f82058f1fc1edb2088ee49 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_AT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_BE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_BE.dat new file mode 100644 index 0000000000000000000000000000000000000000..806b2914ead58754f1ba06ec402d50b3bfd65e46 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_BE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_CH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_CH.dat new file mode 100644 index 0000000000000000000000000000000000000000..9f50b2e13a26babd951b1395c95fd13366f465cd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_CH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_DE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_DE.dat new file mode 100644 index 0000000000000000000000000000000000000000..1d769ac8d591a87b7c65df4edaf72dbd3f800e70 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_DE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..7d7b9d2dd921610811c726dc538d1335124f2864 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_LI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_LI.dat new file mode 100644 index 0000000000000000000000000000000000000000..f4f1a3532a670b39bcb5f6a054a5e934274755d6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_LI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_LU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_LU.dat new file mode 100644 index 0000000000000000000000000000000000000000..ed9d8fb75b6b931170255e538c3f6caa65f66ca7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/de_LU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dje.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dje.dat new file mode 100644 index 0000000000000000000000000000000000000000..aafbdbda66850b91ec373e577667d31fe7869193 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dje.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dje_NE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dje_NE.dat new file mode 100644 index 0000000000000000000000000000000000000000..605bb83a9ba2c56ad18f9ecd7efc7e0822c040f7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dje_NE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/doi.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/doi.dat new file mode 100644 index 0000000000000000000000000000000000000000..44b79c8902fefeb75ba6f6fd7c15e682657c7683 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/doi.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/doi_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/doi_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..550ec0ec0457922d661210f887914005f0e0ddb8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/doi_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dsb_DE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dsb_DE.dat new file mode 100644 index 0000000000000000000000000000000000000000..f1a8d4bcb06d26f1f84e1d9807c7906bef760268 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dsb_DE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dua.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dua.dat new file mode 100644 index 0000000000000000000000000000000000000000..24ee495364a4a0918c3ff8e2ca0eecf2867788d3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dua.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dua_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dua_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..5eab8c9ba59f32f944dc187b29625b04b95b0e35 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dua_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dv.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dv.dat new file mode 100644 index 0000000000000000000000000000000000000000..f8c88ff8cf092bdcb6aa7794af37357d099e6ccb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dv.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dv_MV.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dv_MV.dat new file mode 100644 index 0000000000000000000000000000000000000000..6a6048b5a3ed3723e5e3f7ca67527ada18e58606 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dv_MV.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dyo.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dyo.dat new file mode 100644 index 0000000000000000000000000000000000000000..836d954de897f5f36ac88be32a7243d0a29c3f6a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dyo.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dyo_SN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dyo_SN.dat new file mode 100644 index 0000000000000000000000000000000000000000..734192ceaf4cecd8779443826bdf18cfed91ec35 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dyo_SN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dz.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dz.dat new file mode 100644 index 0000000000000000000000000000000000000000..a75ae5bd7e9e4cc66f9939ccebcd78f8e012655a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dz.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dz_BT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dz_BT.dat new file mode 100644 index 0000000000000000000000000000000000000000..34b2803b5e4545d99dfd63f0aed4c8659839f095 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/dz_BT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ebu.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ebu.dat new file mode 100644 index 0000000000000000000000000000000000000000..d02c22a0f02f42ac856c1fe6d4ea2b39b8f16e80 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ebu.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ebu_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ebu_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..0abfe0e4da22334234110444f63a515f567aa2d2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ebu_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ee.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ee.dat new file mode 100644 index 0000000000000000000000000000000000000000..9348aa2e7e455e76d108626d420540d75300cd23 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ee.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ee_GH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ee_GH.dat new file mode 100644 index 0000000000000000000000000000000000000000..3702d427cc6b32692f15a5ab5819e39a2cf7f012 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ee_GH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ee_TG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ee_TG.dat new file mode 100644 index 0000000000000000000000000000000000000000..5f19ac9f3f4294d86a6d4d93b0660a657f23ede7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ee_TG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/el_CY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/el_CY.dat new file mode 100644 index 0000000000000000000000000000000000000000..22fb87487fae149e6c4b31be5529ca5bdf60c668 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/el_CY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/el_GR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/el_GR.dat new file mode 100644 index 0000000000000000000000000000000000000000..ee095c9529bc7d62fbbcd4b6b1ce23819a1f5bf1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/el_GR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/el_POLYTON.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/el_POLYTON.dat new file mode 100644 index 0000000000000000000000000000000000000000..24a37da57526c9ff9916d6b71196f47f6443d943 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/el_POLYTON.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_001.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_001.dat new file mode 100644 index 0000000000000000000000000000000000000000..e799826a20a312f01c79ea2d905437a7be2215d1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_001.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_150.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_150.dat new file mode 100644 index 0000000000000000000000000000000000000000..82dd2718e23894cb77ffe49d96bda0d3f09d1801 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_150.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AE.dat new file mode 100644 index 0000000000000000000000000000000000000000..bd96c499deef99e03066d54f6f5ab123d5c1d944 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AG.dat new file mode 100644 index 0000000000000000000000000000000000000000..16d7fa5a38b5beb35a6d3efd257d78c5be413f22 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AI.dat new file mode 100644 index 0000000000000000000000000000000000000000..6f0437d67d7ec79c6fe75fe8ee72506e76cc11a4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AS.dat new file mode 100644 index 0000000000000000000000000000000000000000..d309d36540d0661d729122270913c7e70edea85b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AT.dat new file mode 100644 index 0000000000000000000000000000000000000000..ff190b61e4d1ad47b038c9e84a020f25b645a09c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AU.dat new file mode 100644 index 0000000000000000000000000000000000000000..a27ea0f677abd98b66d97d572bb6c112745b2b0c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_AU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BB.dat new file mode 100644 index 0000000000000000000000000000000000000000..fbcfdd8ab953f9dd65185c4d23f30c3b8204ed34 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BE.dat new file mode 100644 index 0000000000000000000000000000000000000000..481689fe6436c1af4aa7c2c562024f7c998ec276 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BI.dat new file mode 100644 index 0000000000000000000000000000000000000000..e2ef90f8131aaff969726705505894d2e538c4c4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BM.dat new file mode 100644 index 0000000000000000000000000000000000000000..f4e57b6aa16e16e6436a05d67f008bd222b59249 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BS.dat new file mode 100644 index 0000000000000000000000000000000000000000..aafa96f07e2bf07daac4764f055aec84096aeac0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BW.dat new file mode 100644 index 0000000000000000000000000000000000000000..2d0839235c7ba719f7fe2a4d8a951a568e5aef21 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..26326dcb0fa74d922819a3d4ad11582b8cba4101 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_BZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CA.dat new file mode 100644 index 0000000000000000000000000000000000000000..4bcd2d24a7c4eae6bb6632458350aa43209a5c1a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CC.dat new file mode 100644 index 0000000000000000000000000000000000000000..1102d2b56c51f37178ed95eaa85ef41be53f387b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CH.dat new file mode 100644 index 0000000000000000000000000000000000000000..bce7db95ea53c3ed40db4254c9ac559f48f9053d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CK.dat new file mode 100644 index 0000000000000000000000000000000000000000..e4870c84e1b50772d42ff61199c2362dd1ddb408 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..1816a83fd57a49a0fcb75febd7f93fe8417a6fb4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CX.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CX.dat new file mode 100644 index 0000000000000000000000000000000000000000..b0a5620b771df2f7465345132d65b446bc1fe35c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CX.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CY.dat new file mode 100644 index 0000000000000000000000000000000000000000..54fb2d1a1851eda9a3a60906ca25ef3216232978 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..9fd95110a3d21927b6dff96b34e13a5ec6cfb7b3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_CZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DE.dat new file mode 100644 index 0000000000000000000000000000000000000000..3d7ded02b4d790468211b311f6e47fcae44fda15 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DG.dat new file mode 100644 index 0000000000000000000000000000000000000000..1bdea430f221dc9e1539240ce61d63b67d38b3f1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DK.dat new file mode 100644 index 0000000000000000000000000000000000000000..cae041ede5e19d7760dbe291d765f365eb8a8f27 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DM.dat new file mode 100644 index 0000000000000000000000000000000000000000..00ce5e14c96cc3347bc117a0724bce35f80e3fac Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_DM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Dsrt.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Dsrt.dat new file mode 100644 index 0000000000000000000000000000000000000000..341ac66dd7367c656c96a421b542484953d067bd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Dsrt.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Dsrt_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Dsrt_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..663e826104ecc8a97881f609c67d6252a16571e1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Dsrt_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ER.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ER.dat new file mode 100644 index 0000000000000000000000000000000000000000..349173e3cdb28e713aff016c6f653dd84744e9a2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ER.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ES.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ES.dat new file mode 100644 index 0000000000000000000000000000000000000000..aad2b6d97c98a6f890e6c8c160f1834a535c0442 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ES.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FI.dat new file mode 100644 index 0000000000000000000000000000000000000000..90a35e72e7ef8cfeeb658ea90de750d3f0783320 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FJ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FJ.dat new file mode 100644 index 0000000000000000000000000000000000000000..e2013194004b40139158a5a1a96f885c5a13570a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FJ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FK.dat new file mode 100644 index 0000000000000000000000000000000000000000..3b586dd821b508710e0cab96787d4b9d83203e23 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FM.dat new file mode 100644 index 0000000000000000000000000000000000000000..4a4d6ab9303abea778558bd2daee466ed6fd5ba8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FR.dat new file mode 100644 index 0000000000000000000000000000000000000000..1141d02eb6e69b400604104507713f252277a9ce Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_FR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GB.dat new file mode 100644 index 0000000000000000000000000000000000000000..ce4687f538f32229593cf1e753f5352fa0086b57 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GD.dat new file mode 100644 index 0000000000000000000000000000000000000000..fbd024b4537bd71f3de584a7f126f3153cc18ddc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GG.dat new file mode 100644 index 0000000000000000000000000000000000000000..6195e7d8d091c8206bc13bd57aadaf9316c91b4e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GH.dat new file mode 100644 index 0000000000000000000000000000000000000000..bfcd6f57f538396843569e5b82e897d853dace15 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GI.dat new file mode 100644 index 0000000000000000000000000000000000000000..98b852ea48e01f32455a8b99582e19727e785cca Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GM.dat new file mode 100644 index 0000000000000000000000000000000000000000..4e7daad837905a81f9878e9b8d1624c1d10529b8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GS.dat new file mode 100644 index 0000000000000000000000000000000000000000..3438bbd55618a6a78471b7a47e86d3944eba78d4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GU.dat new file mode 100644 index 0000000000000000000000000000000000000000..6d184675e24410e1a32f9fcbdcdb83292118b5a3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GY.dat new file mode 100644 index 0000000000000000000000000000000000000000..4192d41b0d917e6965ed72ca4ee45b13b5a35ff2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_GY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_HK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_HK.dat new file mode 100644 index 0000000000000000000000000000000000000000..39a6d7f6cdcfa980825850bc17f35ecf0d9c4a2e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_HK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_HU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_HU.dat new file mode 100644 index 0000000000000000000000000000000000000000..5c6cf34022f82457257ca118554aa7512e462b47 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_HU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ID.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ID.dat new file mode 100644 index 0000000000000000000000000000000000000000..763ffdf53f9c88c25c3575cae635e588d9c1e2e9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ID.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IE.dat new file mode 100644 index 0000000000000000000000000000000000000000..36b4ffb100d2b626617c42d9bdbc89d1dfdb2f50 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IL.dat new file mode 100644 index 0000000000000000000000000000000000000000..9782e31a39566912e1c0150083111d3854ca3498 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IM.dat new file mode 100644 index 0000000000000000000000000000000000000000..a3789694fbe4ecd3251f4db70abbc18fa5fad27f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..03987cb1312c3ed5185ad29dcfa9dad4cec57dd0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IO.dat new file mode 100644 index 0000000000000000000000000000000000000000..ce4dba27593013e01d291b0696afa4df36f87388 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..cd577914d14c9f17bd55501cbaa0b354dcf0d7bd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_JE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_JE.dat new file mode 100644 index 0000000000000000000000000000000000000000..59fad12613c632f7880f692e4b8dc9bd8d6d08dc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_JE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_JM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_JM.dat new file mode 100644 index 0000000000000000000000000000000000000000..8bb03e32671a6273b7afb7fd046e3268516761a2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_JM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..5c1816798fb700443c1d698d57482eb25820295b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KI.dat new file mode 100644 index 0000000000000000000000000000000000000000..2c57a1608b27c02b81d8fa0775f60d50561434e7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KN.dat new file mode 100644 index 0000000000000000000000000000000000000000..79c9a818af720fe8ef02786600b6044a5c8586e0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KY.dat new file mode 100644 index 0000000000000000000000000000000000000000..013312f620a3d864de5399f01935f6cfb9ed926c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_KY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_LC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_LC.dat new file mode 100644 index 0000000000000000000000000000000000000000..0368fe364e09dfd3f2c9669d53da774ac0fbe784 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_LC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_LR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_LR.dat new file mode 100644 index 0000000000000000000000000000000000000000..80d77d8cdd795c1bb8bbe20f6d2943d7582e3b68 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_LR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_LS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_LS.dat new file mode 100644 index 0000000000000000000000000000000000000000..b3cbbfb68399fc8a57ccbbff51d65d641c066c72 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_LS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MG.dat new file mode 100644 index 0000000000000000000000000000000000000000..cf3db95a194620c3ed2ece07786a0f0ce599688c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MH.dat new file mode 100644 index 0000000000000000000000000000000000000000..f6bc501cd2a0544241b1cbba0515fce284882d51 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MO.dat new file mode 100644 index 0000000000000000000000000000000000000000..6635dc53a752d1d68b5612a87cf924775683437e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MP.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MP.dat new file mode 100644 index 0000000000000000000000000000000000000000..ede9c2bb56f9bf6b7ba72124b8a681fc927b9366 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MP.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MS.dat new file mode 100644 index 0000000000000000000000000000000000000000..53115eb587b55dabf816ba04b092bb6223ee0ae5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MT.dat new file mode 100644 index 0000000000000000000000000000000000000000..87c2b9534567d1e49f90c1e8f1616bca016722a4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MU.dat new file mode 100644 index 0000000000000000000000000000000000000000..524b3ac9758baeb765e3e4f07e2bea5d6279dbe9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MV.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MV.dat new file mode 100644 index 0000000000000000000000000000000000000000..852a33d9085dd2cd53a0d3fa6221fc02cc79ba49 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MV.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MW.dat new file mode 100644 index 0000000000000000000000000000000000000000..d0dcd6a9df98ad43ba08bb69f3ed4020c749761d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MY.dat new file mode 100644 index 0000000000000000000000000000000000000000..9479385f2fe2f4d4fed2ece47a85c7efc782866d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_MY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NA.dat new file mode 100644 index 0000000000000000000000000000000000000000..a3d882937c2e1fa20e3e3693f09a884e508bbad7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NF.dat new file mode 100644 index 0000000000000000000000000000000000000000..8003f609bff5f5eb56a55f0177251d46b50dff4e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..27bae0751159668e12eac70160b9a7c5ec38ea4a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NL.dat new file mode 100644 index 0000000000000000000000000000000000000000..8cd5773590de2525e061113f140ccf697aaa155d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NO.dat new file mode 100644 index 0000000000000000000000000000000000000000..0917f9e98cc73f4fc028a013ba98349f617877ad Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NR.dat new file mode 100644 index 0000000000000000000000000000000000000000..0c788a8d80638fc3b327a2f0e122f96db72b69aa Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NU.dat new file mode 100644 index 0000000000000000000000000000000000000000..f8607f6428184aa39166343b7d64e583b8219c40 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..7220c4cc4431518836137a4a9a15b890580cdb67 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_NZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PG.dat new file mode 100644 index 0000000000000000000000000000000000000000..4269e33194098e7f9ee4b1dc60b31ff5f0664bf3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PH.dat new file mode 100644 index 0000000000000000000000000000000000000000..9ce4fc0bb19147c0d570655e1a85d981b8bec9f5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PK.dat new file mode 100644 index 0000000000000000000000000000000000000000..f198d9ec84fe5a0eb30297b416f6081ab7f1f616 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PL.dat new file mode 100644 index 0000000000000000000000000000000000000000..02e4c0f52d24dbb2f7f28a13c72f252122f7cfe2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PN.dat new file mode 100644 index 0000000000000000000000000000000000000000..9977c74309031cd98369de5b68afaf17a184d66d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PR.dat new file mode 100644 index 0000000000000000000000000000000000000000..cdb83dbe4cac37cf7d15bb7d4bc0485d78eed8d5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PT.dat new file mode 100644 index 0000000000000000000000000000000000000000..4d7952e7a94aee2d31696b14da5162c8ab2be027 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PW.dat new file mode 100644 index 0000000000000000000000000000000000000000..e878083ff57f99b161eca4953964ba441a63fee6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_PW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_RO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_RO.dat new file mode 100644 index 0000000000000000000000000000000000000000..ca1e262f1e8a041f894ca436f33b3a023c212169 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_RO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_RW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_RW.dat new file mode 100644 index 0000000000000000000000000000000000000000..c46733b0acc7026c3cfa022e44e691dfafd7f2c7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_RW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SB.dat new file mode 100644 index 0000000000000000000000000000000000000000..b81625e3592103a60d60cb9f41c6ac55467f6506 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SC.dat new file mode 100644 index 0000000000000000000000000000000000000000..4816bb86a2a977854c91682a6b4bb757379d2329 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SD.dat new file mode 100644 index 0000000000000000000000000000000000000000..985e3e6bf7136b2099a86deb5bee2b446aade0d7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SE.dat new file mode 100644 index 0000000000000000000000000000000000000000..5f89bad51c52815e9f2e0b672caf7e80026a55ee Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SG.dat new file mode 100644 index 0000000000000000000000000000000000000000..a21a72a738972db8185809a52649d28c7afe2ed3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SH.dat new file mode 100644 index 0000000000000000000000000000000000000000..006487c34e75a82b6f94715e7749091e3df3190c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SI.dat new file mode 100644 index 0000000000000000000000000000000000000000..97b42d040f3f4d161bfa656b150d2685afe5efc8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SK.dat new file mode 100644 index 0000000000000000000000000000000000000000..1bda1791f3f876613c009ca2300253b2421db027 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SL.dat new file mode 100644 index 0000000000000000000000000000000000000000..127d12856862980443fbba9d61f99cf293830b9d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SS.dat new file mode 100644 index 0000000000000000000000000000000000000000..7192fd1381be6737d434c4497767d78a9bb40d28 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SX.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SX.dat new file mode 100644 index 0000000000000000000000000000000000000000..5dfff7d8f73ea8e30513b828a94c7d248c806599 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SX.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..90a9f7a141f31376ec8be449f7ec1e1087e25e3f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_SZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Shaw.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Shaw.dat new file mode 100644 index 0000000000000000000000000000000000000000..60936ea8a74464f79b0fdb271d3eea93a860a4c9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Shaw.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Shaw_GB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Shaw_GB.dat new file mode 100644 index 0000000000000000000000000000000000000000..214e5c6137efd3fced4ff24b8bd62d2ca664827b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_Shaw_GB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TC.dat new file mode 100644 index 0000000000000000000000000000000000000000..d1edd041e8f5ee12a8ae6ee304e7165489c81bb9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TK.dat new file mode 100644 index 0000000000000000000000000000000000000000..d81803f7a772c0955f1fbca76453a06c8f1b4cc0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TO.dat new file mode 100644 index 0000000000000000000000000000000000000000..4512ee44500ad362a72bb00a4b532bbaf968a08b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TT.dat new file mode 100644 index 0000000000000000000000000000000000000000..e704f06510c723fd3fb0ccde9d9c6ad9b3419576 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TV.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TV.dat new file mode 100644 index 0000000000000000000000000000000000000000..c936c695b2adfccb9a96207f35f3e91064a95a6a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TV.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..62091cee800eeaad52b62429d0f3767b03599a3b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_UG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_UG.dat new file mode 100644 index 0000000000000000000000000000000000000000..dd077ccae2a4caf99f897716847a58eb0824af4e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_UG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_UM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_UM.dat new file mode 100644 index 0000000000000000000000000000000000000000..3a027b2abb9f594ede329e3b62386b48f81dc051 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_UM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..663e826104ecc8a97881f609c67d6252a16571e1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_US_POSIX.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_US_POSIX.dat new file mode 100644 index 0000000000000000000000000000000000000000..a9ecf5b42c8bd13fa9b77602345b572d986f6638 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_US_POSIX.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VC.dat new file mode 100644 index 0000000000000000000000000000000000000000..86fb17d94b29c6cd96c647a96980289fd23aca98 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VG.dat new file mode 100644 index 0000000000000000000000000000000000000000..3fdd46cb82d3da3c010d85d432dcbf33c7f456ed Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VI.dat new file mode 100644 index 0000000000000000000000000000000000000000..c4520cc6b71c5f9d24518783a351ef11f733cd78 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VU.dat new file mode 100644 index 0000000000000000000000000000000000000000..12647a8c58931da9c3397452873ee02095dc6ae2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_VU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_WS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_WS.dat new file mode 100644 index 0000000000000000000000000000000000000000..8531d31161e217bf8891080f93c7d84cde7550e6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_WS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ZA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ZA.dat new file mode 100644 index 0000000000000000000000000000000000000000..8cc6b0e0d898770a4677600340f3b18a596f1465 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ZA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ZM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ZM.dat new file mode 100644 index 0000000000000000000000000000000000000000..50039250f1fb7e78e7b0fca92ee1112ff548700d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ZM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ZW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ZW.dat new file mode 100644 index 0000000000000000000000000000000000000000..6a8835f2b40fc2cec658f3a6a56cf63036c912f8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/en_ZW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/eo_001.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/eo_001.dat new file mode 100644 index 0000000000000000000000000000000000000000..ec48fb1ff1139ec14af7543228c4fc5dc860e34e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/eo_001.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_419.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_419.dat new file mode 100644 index 0000000000000000000000000000000000000000..38c8aa5bc1aa175b5796b49cd9f4ba99c9e5250d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_419.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_AR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_AR.dat new file mode 100644 index 0000000000000000000000000000000000000000..42787bdf6562ee6315f6eb62f16eccc0717873cf Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_AR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_BO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_BO.dat new file mode 100644 index 0000000000000000000000000000000000000000..df6a12996c7a121efde9261986e458544bd98be2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_BO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_BR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_BR.dat new file mode 100644 index 0000000000000000000000000000000000000000..7d1f1023bcb8bacd5d488ed9273563d5c5ba65e2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_BR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_BZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_BZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..ff0ff6ab382bfc45582347709e661e83dfb3f33f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_BZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CL.dat new file mode 100644 index 0000000000000000000000000000000000000000..87cd6243d21461ca2440bdca8cada0462185356b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CO.dat new file mode 100644 index 0000000000000000000000000000000000000000..09e03e3ae12ca25faa4f1ebb163438f55893835c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CR.dat new file mode 100644 index 0000000000000000000000000000000000000000..041296d123d15539cc14aaac64a7d2b7ef520e5a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CU.dat new file mode 100644 index 0000000000000000000000000000000000000000..ced5b381989bb9f2d8b02e75a0f1834c413a0965 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_CU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_DO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_DO.dat new file mode 100644 index 0000000000000000000000000000000000000000..cbec78124624e99df1830c819d0e59c593265d44 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_DO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_EA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_EA.dat new file mode 100644 index 0000000000000000000000000000000000000000..dfd0d910a1e39e1e8454e5e573b2220d965792bb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_EA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_EC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_EC.dat new file mode 100644 index 0000000000000000000000000000000000000000..0c6f37b64419387b40742f74f520eabb3f4ef7dd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_EC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_ES.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_ES.dat new file mode 100644 index 0000000000000000000000000000000000000000..3414dff28c5786a2e6e7ee87428b85971d28a523 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_ES.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_GQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_GQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..775e43b08bb32132dd04bd858bc4e07945963372 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_GQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_GT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_GT.dat new file mode 100644 index 0000000000000000000000000000000000000000..bedab31cecca46029a546e76deffd53cca5fa5b7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_GT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_HN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_HN.dat new file mode 100644 index 0000000000000000000000000000000000000000..c5223aae2dbc33e55c6fc82426b0238616d4473a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_HN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_IC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_IC.dat new file mode 100644 index 0000000000000000000000000000000000000000..3a9f9fd9fad2c3fdba7cd1d0a2ed5b4a23750ae0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_IC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_MX.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_MX.dat new file mode 100644 index 0000000000000000000000000000000000000000..91919c1527a43853307b4943a6f5c9d557b8f300 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_MX.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_NI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_NI.dat new file mode 100644 index 0000000000000000000000000000000000000000..9e1ab78f716eac44005064ddd322e3b861d143f4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_NI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PA.dat new file mode 100644 index 0000000000000000000000000000000000000000..edfcd54555b888837baaf75af5d83f31621b0fb8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PE.dat new file mode 100644 index 0000000000000000000000000000000000000000..82c50ad2333cdd2d13ef55d93ca5d0cf5e0ecc61 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PH.dat new file mode 100644 index 0000000000000000000000000000000000000000..91e24f13ce2ca664d08f079a5de4b308f4103483 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PR.dat new file mode 100644 index 0000000000000000000000000000000000000000..c45d5911b1e55cc88408dc0eff1c10d90a7dd88e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PY.dat new file mode 100644 index 0000000000000000000000000000000000000000..3f36570558ca4e03cf8580929251d0fedde9deb0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_PY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_SV.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_SV.dat new file mode 100644 index 0000000000000000000000000000000000000000..2c98032c1548d4d79fa42ec643090223d3736bdb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_SV.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..033881179dda0a8e2a8722977c93ca5bb760bf84 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_UY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_UY.dat new file mode 100644 index 0000000000000000000000000000000000000000..292fa0cc48ece7e98bbaef84a73ddf15c0eba9a7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_UY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_VE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_VE.dat new file mode 100644 index 0000000000000000000000000000000000000000..42cba455f32d39a3bb44bb8ee76710377549185f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/es_VE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/et_EE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/et_EE.dat new file mode 100644 index 0000000000000000000000000000000000000000..a08c682412ed948cf6b0d35c66bd5c5a98513c4a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/et_EE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/eu_ES.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/eu_ES.dat new file mode 100644 index 0000000000000000000000000000000000000000..62f7cc611d3b358f1c078c49d0c68ceb3efb1331 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/eu_ES.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ewo.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ewo.dat new file mode 100644 index 0000000000000000000000000000000000000000..5f7d570b939f7d6a95fc45e60dc44634fad7c76e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ewo.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ewo_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ewo_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..ae6b0f7ae364ed12b5d684649becc7b5d6514353 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ewo_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fa_AF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fa_AF.dat new file mode 100644 index 0000000000000000000000000000000000000000..689b4c7840362c71773a77afc7e93625d572874d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fa_AF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fa_IR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fa_IR.dat new file mode 100644 index 0000000000000000000000000000000000000000..b3dd8eb5d694cc4c3bd4657e3180b9b17bde6ab7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fa_IR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff.dat new file mode 100644 index 0000000000000000000000000000000000000000..531fffa908c6769edd28b908e328fd1e5f2066b3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_BF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_BF.dat new file mode 100644 index 0000000000000000000000000000000000000000..84f0ffbd7e845e79af1695b1f236b612536ea607 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_BF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..78bf620829fcd019e61788bbcf138bbf0577a463 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GH.dat new file mode 100644 index 0000000000000000000000000000000000000000..6667263b5317ac54c6cafb42fe5465b0e8647cfa Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GM.dat new file mode 100644 index 0000000000000000000000000000000000000000..e641b279ac6aa6ec7d1f2819c16da35a391d3c17 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GN.dat new file mode 100644 index 0000000000000000000000000000000000000000..216df0ba8947c9c39ff6c50188cbb0cac01701bb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GW.dat new file mode 100644 index 0000000000000000000000000000000000000000..63799caa1f251c8d2751071abaad62fa95c8055c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_GW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_LR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_LR.dat new file mode 100644 index 0000000000000000000000000000000000000000..f5e3cdebcf72c426e5e7c1a4094799955df62c6e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_LR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_MR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_MR.dat new file mode 100644 index 0000000000000000000000000000000000000000..716f23fd9e8681c57ff5ed3423a1984e5366aefb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_MR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_NE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_NE.dat new file mode 100644 index 0000000000000000000000000000000000000000..12098834f16aad851f2730742ed71fe60741867d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_NE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..a17d85c57ae003b64b27da1698e55b537897c284 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_SL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_SL.dat new file mode 100644 index 0000000000000000000000000000000000000000..d8825521b855bb5274a2d61d1ad1a3d4d15cba8d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_SL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_SN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_SN.dat new file mode 100644 index 0000000000000000000000000000000000000000..125d99943cd9b850cfdfc171ace042fa61f69126 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Adlm_SN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn.dat new file mode 100644 index 0000000000000000000000000000000000000000..df806dd47c3ad31254b1a43a9c21937667928f5e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_BF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_BF.dat new file mode 100644 index 0000000000000000000000000000000000000000..bb3a2e0e48294214fcb4d19da441977cd4cc9c3e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_BF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..a3229cdcab58ea5c07e67befbcc0562eaae4f42e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GH.dat new file mode 100644 index 0000000000000000000000000000000000000000..58222300eb512e550f70ab56959fcfe5b82001ec Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GM.dat new file mode 100644 index 0000000000000000000000000000000000000000..82022dfa7330c78ee90418a52cf4a37f6032ec48 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GN.dat new file mode 100644 index 0000000000000000000000000000000000000000..1a99d48f0d12e50ca976a8f8717fdc9d5bb0406e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GW.dat new file mode 100644 index 0000000000000000000000000000000000000000..a2b55bf7bd2cbd3e7ae4edfb3a16a4bac74ad4c8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_GW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_LR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_LR.dat new file mode 100644 index 0000000000000000000000000000000000000000..5dce447e7e27c1d6d614767ab460c02335cc840b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_LR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_MR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_MR.dat new file mode 100644 index 0000000000000000000000000000000000000000..e6178b867edf6925bbb35d19e323136d4cf6c830 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_MR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_NE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_NE.dat new file mode 100644 index 0000000000000000000000000000000000000000..82151e8f9f0d5641934229b32b53c19beb0d11c3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_NE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..086889e64c39e90e63be03021450a012bb001e5c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_SL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_SL.dat new file mode 100644 index 0000000000000000000000000000000000000000..e50753de46b4d384c7bfcf4b57b55cd8e9bc6f20 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_SL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_SN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_SN.dat new file mode 100644 index 0000000000000000000000000000000000000000..faeff87cc7ef16dd2fddd101cb0b7ce4fa29edbd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ff_Latn_SN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fi_FI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fi_FI.dat new file mode 100644 index 0000000000000000000000000000000000000000..fa20daec45d61d87841d13ae5f150ad0668c84e9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fi_FI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fil_PH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fil_PH.dat new file mode 100644 index 0000000000000000000000000000000000000000..dc08338cb8bd6cb1a8fa3905f27daaf89bf9c000 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fil_PH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fo_DK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fo_DK.dat new file mode 100644 index 0000000000000000000000000000000000000000..669088d75173dd1690c69e453d8960c25a4b5a93 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fo_DK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fo_FO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fo_FO.dat new file mode 100644 index 0000000000000000000000000000000000000000..7d8a81451b92357cbbfe4e5f6656d4aac0f31dd9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fo_FO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BE.dat new file mode 100644 index 0000000000000000000000000000000000000000..cc842fe06bf69365af497805eeca37366d4a3189 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BF.dat new file mode 100644 index 0000000000000000000000000000000000000000..ba1ecc57a7dc4f1128a17407182f7a4faa3e6cf3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BI.dat new file mode 100644 index 0000000000000000000000000000000000000000..d4036bede6982a40dedbd0610ebbfd9415bdab3c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BJ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BJ.dat new file mode 100644 index 0000000000000000000000000000000000000000..562758e8509e57c9c9494e4ea34b4b4abaca09f5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BJ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BL.dat new file mode 100644 index 0000000000000000000000000000000000000000..e311ee66cd8394009be17c132906f50ca4d10804 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_BL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CA.dat new file mode 100644 index 0000000000000000000000000000000000000000..da870066c3b328aaa058367d1d01df1bbdbe569c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CD.dat new file mode 100644 index 0000000000000000000000000000000000000000..248278871fa714d437625e47d40e248934199f15 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CF.dat new file mode 100644 index 0000000000000000000000000000000000000000..2468e1eda5ea4cdddbb048e6051e3ecf12a571f5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CG.dat new file mode 100644 index 0000000000000000000000000000000000000000..b7df1a92fbf90a31b9f15043adece20104351def Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CH.dat new file mode 100644 index 0000000000000000000000000000000000000000..fa5b7b4771fdc94797ff2cc4b94d5e5a97df1ee0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CI.dat new file mode 100644 index 0000000000000000000000000000000000000000..3d92afcfd400ef15a7b9d557b4cb2e12d87c3e49 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..a779b4a7e9a02784135b7836dcd66cfcb0347063 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_DJ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_DJ.dat new file mode 100644 index 0000000000000000000000000000000000000000..79aa6e6701700ee97360b585c2dc3d4c63d70d5b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_DJ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_DZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_DZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..3f56d231db0ab439b966e853f025de01403cf28a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_DZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_FR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_FR.dat new file mode 100644 index 0000000000000000000000000000000000000000..553d5e4a2bd44aa5cef5b83db863df2e2a6adf4c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_FR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GA.dat new file mode 100644 index 0000000000000000000000000000000000000000..beb0dd5667847a73edce54227be9d93d125ac0b3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GF.dat new file mode 100644 index 0000000000000000000000000000000000000000..eb9ffc902a5f0da8fe66221a023cd4dc3fc1944d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GN.dat new file mode 100644 index 0000000000000000000000000000000000000000..c4f9f808c293c654a044531369b42046f65c2115 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GP.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GP.dat new file mode 100644 index 0000000000000000000000000000000000000000..e2834c7dbbf7d4e23852dad6df30873c381ba7cd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GP.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..a04de173ae0f1e9a590b17661a786b5fad273106 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_GQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_HT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_HT.dat new file mode 100644 index 0000000000000000000000000000000000000000..33b39563214156f84061ec466f63bc5485b998f2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_HT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_KM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_KM.dat new file mode 100644 index 0000000000000000000000000000000000000000..9ece5936c5be9d70636f9c676ff0882bb014af70 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_KM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_LU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_LU.dat new file mode 100644 index 0000000000000000000000000000000000000000..062b9ab0244833879d9cbdce3fafd2c3db5fd580 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_LU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MA.dat new file mode 100644 index 0000000000000000000000000000000000000000..6ee8eb9f0fd0dd36fbd7f3a86d7dc4e3fbedc9e9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MC.dat new file mode 100644 index 0000000000000000000000000000000000000000..52315a3da7afa3df5a01b35ada1e4b1ac70b7b9f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MF.dat new file mode 100644 index 0000000000000000000000000000000000000000..e5a1df0e02dfce3047bbd161e970b0e077566ed9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MG.dat new file mode 100644 index 0000000000000000000000000000000000000000..c01d050a17972c3423c396bd4e3d36f3f61386fe Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_ML.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_ML.dat new file mode 100644 index 0000000000000000000000000000000000000000..721771ea35aa86b54ec1d18805b8b5bd8969108e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_ML.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..90becb7632cba74c35e4d9b2f373efea98130b63 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MR.dat new file mode 100644 index 0000000000000000000000000000000000000000..28ef3f140c05fb7d1b947e19c75a8bd05f22818a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MU.dat new file mode 100644 index 0000000000000000000000000000000000000000..76fc2ab4f1acdb6d11dabcd3a15e1db1a557cc32 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_MU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_NC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_NC.dat new file mode 100644 index 0000000000000000000000000000000000000000..6aaf03421f7ee350007519f69e4442199d1f2106 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_NC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_NE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_NE.dat new file mode 100644 index 0000000000000000000000000000000000000000..143ac4fddc2c67587d4a474cdad73adde05923d9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_NE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_PF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_PF.dat new file mode 100644 index 0000000000000000000000000000000000000000..e2f11dcdbf5fe9a8afade839270d0e0352356f73 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_PF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_PM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_PM.dat new file mode 100644 index 0000000000000000000000000000000000000000..4f9cdf7be49a114bbf3e60bb6c44be0883d47312 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_PM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_RE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_RE.dat new file mode 100644 index 0000000000000000000000000000000000000000..214ad4faa870887bd9262b1feb54758402f1c362 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_RE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_RW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_RW.dat new file mode 100644 index 0000000000000000000000000000000000000000..6739c522d011141c04abb65c4e1538eefadee116 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_RW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_SC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_SC.dat new file mode 100644 index 0000000000000000000000000000000000000000..1fedefe530a4e3b63870de2cb6d95d6fb1953150 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_SC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_SN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_SN.dat new file mode 100644 index 0000000000000000000000000000000000000000..48207856b742d2f56de113dc0847956c313ebf20 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_SN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_SY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_SY.dat new file mode 100644 index 0000000000000000000000000000000000000000..8dd53967843f6251a6684da6adc200a35b06746d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_SY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_TD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_TD.dat new file mode 100644 index 0000000000000000000000000000000000000000..6abebabdb50f21561aeecdc230048b9689476c14 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_TD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_TG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_TG.dat new file mode 100644 index 0000000000000000000000000000000000000000..9395eaafb94a3e6bef84724ce14c09b0ff6a992a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_TG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_TN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_TN.dat new file mode 100644 index 0000000000000000000000000000000000000000..bf1e55153f84f2c719e60ac28bdf924eece46d70 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_TN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_VU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_VU.dat new file mode 100644 index 0000000000000000000000000000000000000000..f29eeed92eecf5d9849e71b2cfe1d2637e40033d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_VU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_WF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_WF.dat new file mode 100644 index 0000000000000000000000000000000000000000..2d38ac6f0c9206ad95ccd0f9330b864f78123a97 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_WF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_YT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_YT.dat new file mode 100644 index 0000000000000000000000000000000000000000..9e9ba28c0345af71c670367417c5d9c22439a82a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fr_YT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/frr_DE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/frr_DE.dat new file mode 100644 index 0000000000000000000000000000000000000000..ecab3304dd5d074d0b6948e6d546fda5b7d9d4fd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/frr_DE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fur.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fur.dat new file mode 100644 index 0000000000000000000000000000000000000000..81a28ed2d63e3d0c9fa301e78555b53d9a44abf2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fur.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fur_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fur_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..2c40e5c09b7437bd06e1c08ee0a6da6182d121e4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fur_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fy_NL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fy_NL.dat new file mode 100644 index 0000000000000000000000000000000000000000..1a8f5811a93f7c72affcf76e64b47abaa12855b0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/fy_NL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ga_GB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ga_GB.dat new file mode 100644 index 0000000000000000000000000000000000000000..7432317e0d037e78fce88748f98dfa10c4651e3a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ga_GB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ga_IE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ga_IE.dat new file mode 100644 index 0000000000000000000000000000000000000000..422b05a5f28b1c2c1f5983b93489fc75f63ffb4b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ga_IE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gaa.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gaa.dat new file mode 100644 index 0000000000000000000000000000000000000000..5028b29c694929897e0bbf8c44df5050454d8993 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gaa.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gaa_GH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gaa_GH.dat new file mode 100644 index 0000000000000000000000000000000000000000..7312993b691654663f9b0c0eaaff2147d64d3f59 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gaa_GH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gd_GB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gd_GB.dat new file mode 100644 index 0000000000000000000000000000000000000000..e37057856938dc80f7ed5ff550d2cdeb308fcbdd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gd_GB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gez.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gez.dat new file mode 100644 index 0000000000000000000000000000000000000000..c3fe514f814c9c03925481093ad6dfffe6926ff9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gez.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gez_ER.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gez_ER.dat new file mode 100644 index 0000000000000000000000000000000000000000..20c18a527b7f0746c831e82b8883d47e569ec9bd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gez_ER.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gez_ET.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gez_ET.dat new file mode 100644 index 0000000000000000000000000000000000000000..a70d43dd5c91e60f59c1a0de7b243ea8b46d8cc7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gez_ET.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gl_ES.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gl_ES.dat new file mode 100644 index 0000000000000000000000000000000000000000..d432bb25bf7072d14508ee98ce72f0184aecd1fb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gl_ES.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gn.dat new file mode 100644 index 0000000000000000000000000000000000000000..2d6eb9f5d021c2c3eb65589fc16c0ad7f1e73229 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gn_PY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gn_PY.dat new file mode 100644 index 0000000000000000000000000000000000000000..a217cc7a8d5079e602149b839b2db11fd1966e67 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gn_PY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw.dat new file mode 100644 index 0000000000000000000000000000000000000000..0d241c698a01460fc21731574de1c8550edf2fd1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw_CH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw_CH.dat new file mode 100644 index 0000000000000000000000000000000000000000..39ed5a8c190588586daa8b758362899cf2514ace Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw_CH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw_FR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw_FR.dat new file mode 100644 index 0000000000000000000000000000000000000000..8687c5c14a4cbcd5ad96fd2cb3a60a4e908123e5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw_FR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw_LI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw_LI.dat new file mode 100644 index 0000000000000000000000000000000000000000..2e72e060d3bb15cb855e2e9995a3adc5a9a74dc9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gsw_LI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gu_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gu_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..a7071f7035c98fa3745e8041cd891996c26fc11e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gu_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/guz.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/guz.dat new file mode 100644 index 0000000000000000000000000000000000000000..386e37bc5e0db8e9a27d4e0465e45a246b6455d5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/guz.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/guz_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/guz_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..3b2c102d89f2f5a9d921517ea32937bd28ad1ec4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/guz_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gv.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gv.dat new file mode 100644 index 0000000000000000000000000000000000000000..b493494c4de49b0efd2c7224f2d3355adbdce73d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gv.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gv_IM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gv_IM.dat new file mode 100644 index 0000000000000000000000000000000000000000..0793d83827e90b4cd4c95f50caebfb68a2a5328c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/gv_IM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_Arab.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_Arab.dat new file mode 100644 index 0000000000000000000000000000000000000000..1395d9e02350c637398027e0190dc42ca4d27758 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_Arab.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_Arab_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_Arab_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..0a98ac88ed3910cd0a02bf619d1b1fe0d1b54238 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_Arab_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_Arab_SD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_Arab_SD.dat new file mode 100644 index 0000000000000000000000000000000000000000..e33c2b3c487031527e5cca3761d82f66343694d4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_Arab_SD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_GH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_GH.dat new file mode 100644 index 0000000000000000000000000000000000000000..74d5780544564f5e9b043ba7804170ee7cff01b5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_GH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_NE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_NE.dat new file mode 100644 index 0000000000000000000000000000000000000000..d06afa95c993d74d2066659fe3c2101b418343b6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_NE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..0a98ac88ed3910cd0a02bf619d1b1fe0d1b54238 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ha_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/haw.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/haw.dat new file mode 100644 index 0000000000000000000000000000000000000000..8b2b47cdce299453888c1a863c7f690658e3e65a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/haw.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/haw_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/haw_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..18706f16dccdaa507295e3e37df78dfec5542214 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/haw_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/he_IL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/he_IL.dat new file mode 100644 index 0000000000000000000000000000000000000000..3a0da6c074e88d982b3a299f76daa29ae72142ea Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/he_IL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hi_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hi_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..9fbfd57dd5de3062e7aa6e73854d4d4f7c2aba71 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hi_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hi_Latn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hi_Latn.dat new file mode 100644 index 0000000000000000000000000000000000000000..17b23a7db73dbcc8af079c3a6987a0d566ebfd5b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hi_Latn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hi_Latn_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hi_Latn_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..9fbfd57dd5de3062e7aa6e73854d4d4f7c2aba71 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hi_Latn_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hnj.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hnj.dat new file mode 100644 index 0000000000000000000000000000000000000000..07eeb51642690284dbd561c20dd5881f484a9ebc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hnj.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hnj_Hmnp.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hnj_Hmnp.dat new file mode 100644 index 0000000000000000000000000000000000000000..c8935a2eea155b1eecab03f3452844f5246abd81 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hnj_Hmnp.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hnj_Hmnp_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hnj_Hmnp_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..46c371477d04d4a659e6252ef6017a4809a3dcd6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hnj_Hmnp_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hr_BA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hr_BA.dat new file mode 100644 index 0000000000000000000000000000000000000000..44129abfe5bad3dee3e5b5a554907eafba192fc6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hr_BA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hr_HR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hr_HR.dat new file mode 100644 index 0000000000000000000000000000000000000000..a0ae43dde24a8349dec1a34c4a7c4c6e1728a0b1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hr_HR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hsb_DE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hsb_DE.dat new file mode 100644 index 0000000000000000000000000000000000000000..5de4a2c3f3fffeea3a779a48c3c7afb8653bf1b4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hsb_DE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ht.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ht.dat new file mode 100644 index 0000000000000000000000000000000000000000..153d09f68ce9b23c857eb1751d0e7c09dd8a27ac Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ht.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ht_HT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ht_HT.dat new file mode 100644 index 0000000000000000000000000000000000000000..48f31169742e79d599b288146c6f994dc3c7dd01 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ht_HT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hu_HU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hu_HU.dat new file mode 100644 index 0000000000000000000000000000000000000000..113faedef4da0be13a26cbee6eeddea88b88a644 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hu_HU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hy_AM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hy_AM.dat new file mode 100644 index 0000000000000000000000000000000000000000..fa2eaf7d3c331ebde0d1ff8bae1e07707b0fc083 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/hy_AM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ia_001.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ia_001.dat new file mode 100644 index 0000000000000000000000000000000000000000..b0a1770b08619694fb15ea2c0984aaf44ee309d4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ia_001.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/id_ID.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/id_ID.dat new file mode 100644 index 0000000000000000000000000000000000000000..cf7c8e5ef56da81a261b222c7be58f0ba3816c90 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/id_ID.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ie.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ie.dat new file mode 100644 index 0000000000000000000000000000000000000000..a6ae1fe3b6d41f7694a3acc206fab6b209ce1067 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ie.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ie_EE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ie_EE.dat new file mode 100644 index 0000000000000000000000000000000000000000..91566139adf95acb1a94eaa6e119314597a25ba7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ie_EE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ig.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ig.dat new file mode 100644 index 0000000000000000000000000000000000000000..4f4627c00336d593718b876e49c94409c15127c5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ig.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ig_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ig_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..4b5635b8b348cabc69689c1e37d3d39da1232cbe Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ig_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ii.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ii.dat new file mode 100644 index 0000000000000000000000000000000000000000..93158e63d273ad861d54d2d2d32c46bc9589e481 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ii.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ii_CN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ii_CN.dat new file mode 100644 index 0000000000000000000000000000000000000000..ef6effaa17c3ec3cd7522b5a8689ee73b83d5d88 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ii_CN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/io.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/io.dat new file mode 100644 index 0000000000000000000000000000000000000000..33aa1fae3e4923f2b7d860bef47c671c16c616ab Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/io.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/io_001.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/io_001.dat new file mode 100644 index 0000000000000000000000000000000000000000..964a6ab69af59f7725e9e558106fbe6a822e36ff Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/io_001.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/is_IS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/is_IS.dat new file mode 100644 index 0000000000000000000000000000000000000000..b3649a764485e0c917239047845ef4d5382b405d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/is_IS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_CH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_CH.dat new file mode 100644 index 0000000000000000000000000000000000000000..cddfb6b51e29118fcedef45a64702147c32e1207 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_CH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..b9a944aa1cb160ca192597ef1b468bddefb7307d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_SM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_SM.dat new file mode 100644 index 0000000000000000000000000000000000000000..db8432aa4460d3468fc4b3cbde7c242293327d6e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_SM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_VA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_VA.dat new file mode 100644 index 0000000000000000000000000000000000000000..30ecca00fc088b0a5d58223d5ed1d71d8bf7acbb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/it_VA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu.dat new file mode 100644 index 0000000000000000000000000000000000000000..ca5b1f7a3b7ce5758de06e21d7990589a412c6e0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu_CA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu_CA.dat new file mode 100644 index 0000000000000000000000000000000000000000..61bb544859cc38d21555cc7cc7b5eaa067dd5b5d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu_CA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu_Latn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu_Latn.dat new file mode 100644 index 0000000000000000000000000000000000000000..20b7cedc76f10ede8d0b56938bc84316fe0f51e9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu_Latn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu_Latn_CA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu_Latn_CA.dat new file mode 100644 index 0000000000000000000000000000000000000000..61bb544859cc38d21555cc7cc7b5eaa067dd5b5d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/iu_Latn_CA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ja_JP.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ja_JP.dat new file mode 100644 index 0000000000000000000000000000000000000000..f0d4479b6d04853b694b33a342b2f8d109984a60 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ja_JP.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jbo.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jbo.dat new file mode 100644 index 0000000000000000000000000000000000000000..1bf2dbb9adf617cbe329946f4f5077d8b89b182d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jbo.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jbo_001.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jbo_001.dat new file mode 100644 index 0000000000000000000000000000000000000000..dcc98aef622315e30a1d2f3a9114132cd6a5b98d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jbo_001.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jgo.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jgo.dat new file mode 100644 index 0000000000000000000000000000000000000000..1b6230ad98233cf8fba6df5b8a06c3cb246e03e7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jgo.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jgo_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jgo_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..7a523f3be854c36007d124713884d61e2d7fedc2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jgo_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jmc.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jmc.dat new file mode 100644 index 0000000000000000000000000000000000000000..a4abf969f6f7f28d7079b200f0e76e7dcbe0efd6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jmc.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jmc_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jmc_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..6abba3279d9ef516f3da5d2ccb97ad8b674016ea Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jmc_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jv_ID.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jv_ID.dat new file mode 100644 index 0000000000000000000000000000000000000000..b60dc4db6f97d0bb2c4e61c960e7863420a2841f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/jv_ID.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ka_GE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ka_GE.dat new file mode 100644 index 0000000000000000000000000000000000000000..73278fabcf96d35b5b5e8a73bd75a6bbaba2a6a4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ka_GE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa.dat new file mode 100644 index 0000000000000000000000000000000000000000..e6b6abdb483106caf7a0fd488a763c354125ce6a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Cyrl.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Cyrl.dat new file mode 100644 index 0000000000000000000000000000000000000000..085710f6f028f7cdb08673215627197e7a90e1d0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Cyrl.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Cyrl_UZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Cyrl_UZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..b2e4590f6f2f06c063b4ac533012c4123abcf501 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Cyrl_UZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Latn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Latn.dat new file mode 100644 index 0000000000000000000000000000000000000000..085710f6f028f7cdb08673215627197e7a90e1d0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Latn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Latn_UZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Latn_UZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..b2e4590f6f2f06c063b4ac533012c4123abcf501 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaa_Latn_UZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kab_DZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kab_DZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..c0cbad8bd1b5633b172646b45c8bd21ba435c911 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kab_DZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaj.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaj.dat new file mode 100644 index 0000000000000000000000000000000000000000..8d304e93b3f096cce394b45e813a427c8287847a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaj.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaj_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaj_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..a94d6f7ce26e102ff62b870f19176c3221bce819 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kaj_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kam.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kam.dat new file mode 100644 index 0000000000000000000000000000000000000000..2ef195ab440db50e94a4d74d98e448596a62df83 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kam.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kam_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kam_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..d16ca2a1d148fabd6ec58da05e93efaf7661ca3b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kam_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kcg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kcg.dat new file mode 100644 index 0000000000000000000000000000000000000000..3ff14c35c9af928727d6265f9fddf0ec625c3a77 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kcg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kcg_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kcg_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..1e6dc36b116ecfc157b654d621b77537103276be Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kcg_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kde.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kde.dat new file mode 100644 index 0000000000000000000000000000000000000000..6d51d911598cff46f5cfe1dd7c803c680fee4cf3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kde.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kde_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kde_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..2fcf1d47e7881326e0307bd78a9e9a33c9d75917 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kde_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kea.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kea.dat new file mode 100644 index 0000000000000000000000000000000000000000..42d05295a225a21be8970f004b9054253beaa74b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kea.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kea_CV.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kea_CV.dat new file mode 100644 index 0000000000000000000000000000000000000000..da97962e8c8ad12527b44ee2acbc3e310d342b68 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kea_CV.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ken.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ken.dat new file mode 100644 index 0000000000000000000000000000000000000000..57e91a15bcdab4b6cf46e92f13a327e22596cc8b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ken.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ken_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ken_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..9ef618000d11c874a2cb699b99e79042e43aff7c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ken_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kgp_BR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kgp_BR.dat new file mode 100644 index 0000000000000000000000000000000000000000..44b499db7bc27f8dfa4c704838c8e7814d76d14a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kgp_BR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/khq.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/khq.dat new file mode 100644 index 0000000000000000000000000000000000000000..61cc45f5bccfa826c072f8fe9026d88d4c3e363d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/khq.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/khq_ML.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/khq_ML.dat new file mode 100644 index 0000000000000000000000000000000000000000..91f7da18eb6a8ae209b0c686ce1fdb3583a5243b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/khq_ML.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ki.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ki.dat new file mode 100644 index 0000000000000000000000000000000000000000..0a7eb8d195ef2057a266d04a4657e8880089b00d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ki.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ki_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ki_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..901b92145484f3cb60eb4765afa061ca8a689b4b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ki_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_Arab_CN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_Arab_CN.dat new file mode 100644 index 0000000000000000000000000000000000000000..d8b9432a0e0199aef696ec1d337271d4df9f1204 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_Arab_CN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_Cyrl.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_Cyrl.dat new file mode 100644 index 0000000000000000000000000000000000000000..082c754571d432c5153870bca6d1d743678167f0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_Cyrl.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_Cyrl_KZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_Cyrl_KZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..ca827ac1dc2af99f50e83dd2cfe07ee383bc98f5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_Cyrl_KZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_KZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_KZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..ca827ac1dc2af99f50e83dd2cfe07ee383bc98f5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kk_KZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kkj.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kkj.dat new file mode 100644 index 0000000000000000000000000000000000000000..529c4175c342e598c0bdb3caff088658fb791a64 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kkj.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kkj_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kkj_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..231f08bd492e2b0f85f67f77e51370fdab6ca5be Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kkj_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kl.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kl.dat new file mode 100644 index 0000000000000000000000000000000000000000..d82a25bb5c62473ba8cd2446af2b61db3e9f6904 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kl.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kl_GL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kl_GL.dat new file mode 100644 index 0000000000000000000000000000000000000000..a8fb28dc88213878d60939a3dd04142a49b1858c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kl_GL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kln.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kln.dat new file mode 100644 index 0000000000000000000000000000000000000000..65e435cb00ba22a1dec3bfd943147a7130f13bd2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kln.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kln_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kln_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..9a12beb465eaff7dba578149e2f984ef440eb5e4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kln_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/km_KH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/km_KH.dat new file mode 100644 index 0000000000000000000000000000000000000000..2ccaba66acc1f88733b39bfec63f6c6b6a40fa5a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/km_KH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kn_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kn_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..1f0d6462b488b293474370e07ca4fe0caaecc2fb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kn_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ko_CN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ko_CN.dat new file mode 100644 index 0000000000000000000000000000000000000000..170698df794a95b51921c796d9c22354a8b83434 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ko_CN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ko_KP.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ko_KP.dat new file mode 100644 index 0000000000000000000000000000000000000000..7c76309ae8d52a14ffd9fbae7ca45c1798f33f95 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ko_KP.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ko_KR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ko_KR.dat new file mode 100644 index 0000000000000000000000000000000000000000..4af3b628f2f72c3564a82d3bd7386f9a9b0dfb4c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ko_KR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Deva.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Deva.dat new file mode 100644 index 0000000000000000000000000000000000000000..e92bf9d5950f316888058b0b3d9094ad2401307d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Deva.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Deva_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Deva_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..8fff8b19fd5e43af52a6ec2f67b993b0ea5273ed Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Deva_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Latn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Latn.dat new file mode 100644 index 0000000000000000000000000000000000000000..d3fbcce66d5d2169602d26d893878f116497fd9c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Latn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Latn_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Latn_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..8fff8b19fd5e43af52a6ec2f67b993b0ea5273ed Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kok_Latn_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kpe.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kpe.dat new file mode 100644 index 0000000000000000000000000000000000000000..48cf0bf5552aaff040759624c53cdbd148024fff Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kpe.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kpe_GN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kpe_GN.dat new file mode 100644 index 0000000000000000000000000000000000000000..d333167e153bcde71c6dcff3a54ef2601a78443e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kpe_GN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kpe_LR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kpe_LR.dat new file mode 100644 index 0000000000000000000000000000000000000000..8afe47b96cd5fd09a1df002a544e5fadf189ba48 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kpe_LR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Arab.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Arab.dat new file mode 100644 index 0000000000000000000000000000000000000000..6441efedebe97ffe672bef2dc5e3e8e41075cc01 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Arab.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Arab_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Arab_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..02a5d1167e2749317703102f646a9f4ebe2c75ea Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Arab_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Deva.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Deva.dat new file mode 100644 index 0000000000000000000000000000000000000000..e63809267213167fdc9f2a27ebded38bea1e8dd0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Deva.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Deva_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Deva_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..02a5d1167e2749317703102f646a9f4ebe2c75ea Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ks_Deva_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksb.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksb.dat new file mode 100644 index 0000000000000000000000000000000000000000..7ced57e880da350f50462955531ac87b5f114ec4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksb.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksb_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksb_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..6837e3753ed2bb1111b807d118e0c34cc2c6c613 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksb_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksf.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksf.dat new file mode 100644 index 0000000000000000000000000000000000000000..7fba25266c0be1b3674496c41723906c22560ce6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksf.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksf_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksf_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..fc29c4985abeaebc5af5a0ad920c871319fdb964 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksf_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksh.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksh.dat new file mode 100644 index 0000000000000000000000000000000000000000..b7bb1f17203d272c15a2312036a66185c1d62696 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksh.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksh_DE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksh_DE.dat new file mode 100644 index 0000000000000000000000000000000000000000..9318d48d822f5bfaa4d4a4db2683468dcadf1eb6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ksh_DE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ku_TR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ku_TR.dat new file mode 100644 index 0000000000000000000000000000000000000000..206426aa05d3c5da3867c45c81c9bb830bbfb06e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ku_TR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kw.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kw.dat new file mode 100644 index 0000000000000000000000000000000000000000..3d103e3792d51747659d00f345b174d5bbf27a1f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kw.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kw_GB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kw_GB.dat new file mode 100644 index 0000000000000000000000000000000000000000..da81c10f13717d70f37d965b6685fd904cb1c684 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kw_GB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv.dat new file mode 100644 index 0000000000000000000000000000000000000000..2849d6cc93edfb6138ab3d683f1001d3df97bb6f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Deva.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Deva.dat new file mode 100644 index 0000000000000000000000000000000000000000..184addcd430d0b365574dffb2d4ba45ffbef34ac Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Deva.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Deva_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Deva_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..8a1e28980c4166f7d6b942005b8528d8a3518db7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Deva_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Latn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Latn.dat new file mode 100644 index 0000000000000000000000000000000000000000..35b2695db7962af7f9f290d6faabfd5028771583 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Latn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Latn_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Latn_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..8a1e28980c4166f7d6b942005b8528d8a3518db7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Latn_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Orya.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Orya.dat new file mode 100644 index 0000000000000000000000000000000000000000..98172abd950bd3cf13a880b488f2c748a9317e1b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Orya.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Orya_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Orya_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..8a1e28980c4166f7d6b942005b8528d8a3518db7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Orya_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Telu.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Telu.dat new file mode 100644 index 0000000000000000000000000000000000000000..1b3ac8b8c11820ad46579b3bed22333a70ce3b10 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Telu.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Telu_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Telu_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..8a1e28980c4166f7d6b942005b8528d8a3518db7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/kxv_Telu_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ky_KG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ky_KG.dat new file mode 100644 index 0000000000000000000000000000000000000000..c61073fe2d704f7de254bf9937769fb98c59a71b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ky_KG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/la.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/la.dat new file mode 100644 index 0000000000000000000000000000000000000000..1ccac42fa74d3d488caeabf8668972afd7a08ca3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/la.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/la_VA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/la_VA.dat new file mode 100644 index 0000000000000000000000000000000000000000..31a68ac99d364d4c35e937cd4a90fa50580b7f4a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/la_VA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lag.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lag.dat new file mode 100644 index 0000000000000000000000000000000000000000..f8da045f8865c761792921ff7eb145ba8ad5f138 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lag.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lag_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lag_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..7893a0eda2ad8833be220faac3668ceefcd9031c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lag_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lb_LU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lb_LU.dat new file mode 100644 index 0000000000000000000000000000000000000000..bcb56532aa2d3783f530d822f181b8a809f56afb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lb_LU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lg.dat new file mode 100644 index 0000000000000000000000000000000000000000..cd4e5a9d4bed9e9bab2079eb03b1b0b8928756ae Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lg_UG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lg_UG.dat new file mode 100644 index 0000000000000000000000000000000000000000..6ee321dc7f52d05a56322b21460ae97e859f2deb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lg_UG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lij_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lij_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..6969b5283273f116c0fe167c4f1b1c72fe05a617 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lij_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lkt.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lkt.dat new file mode 100644 index 0000000000000000000000000000000000000000..515ac6c47cd8bde606e213d4b5ef4b55b2b92234 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lkt.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lkt_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lkt_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..44a5969a02d4653b44ee1cef9a3ef8c460ded918 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lkt_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lld.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lld.dat new file mode 100644 index 0000000000000000000000000000000000000000..04c0806888b89091b708c58fb431d5067842f8b2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lld.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lld_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lld_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..f8d12f0fab6585ad64cc8659af5880982f5a8345 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lld_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lmo.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lmo.dat new file mode 100644 index 0000000000000000000000000000000000000000..c7388c7dae2ce08b793d8c6f300e31975ed0f186 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lmo.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lmo_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lmo_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..50dd59272f2559d925bc535f62656e963fb2a760 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lmo_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln.dat new file mode 100644 index 0000000000000000000000000000000000000000..cc8edb15ba028473c951dd30c2fbefecbf8def42 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_AO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_AO.dat new file mode 100644 index 0000000000000000000000000000000000000000..60dd0ba87f4635fcacb66dc1b1146c1fab07757c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_AO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_CD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_CD.dat new file mode 100644 index 0000000000000000000000000000000000000000..b87aad7d28925d9db976365cc1af27dfb736612a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_CD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_CF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_CF.dat new file mode 100644 index 0000000000000000000000000000000000000000..b5a9a827ee2871c12c330fafdd13ba4d24343b24 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_CF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_CG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_CG.dat new file mode 100644 index 0000000000000000000000000000000000000000..4059b369e75596e442343fb2c0bedadbb8a5dfe3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ln_CG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lo_LA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lo_LA.dat new file mode 100644 index 0000000000000000000000000000000000000000..6f12ab55995942428f0faad4a1bf30ffc6ad8e20 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lo_LA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lrc.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lrc.dat new file mode 100644 index 0000000000000000000000000000000000000000..4452aa52edf97353fe25e1da4d56ff02de86204e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lrc.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lrc_IQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lrc_IQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..b7fdaf27a0559fedab829c0ca1d18fed93160dd1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lrc_IQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lrc_IR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lrc_IR.dat new file mode 100644 index 0000000000000000000000000000000000000000..75d897526c32c812a089147faf1d6d4ee1fa9f0d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lrc_IR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lt_LT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lt_LT.dat new file mode 100644 index 0000000000000000000000000000000000000000..abd28f771f27c9ae600a7bd2319cf2cbc972b96c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lt_LT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ltg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ltg.dat new file mode 100644 index 0000000000000000000000000000000000000000..8937b94340aaec75a9952957c4e9596d66f02937 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ltg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ltg_LV.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ltg_LV.dat new file mode 100644 index 0000000000000000000000000000000000000000..6afb15176f5af8c27324b9ddf6372de9959d30c3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ltg_LV.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lu.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lu.dat new file mode 100644 index 0000000000000000000000000000000000000000..438bb41b1e962e9a330a94a7ca5bb2b8f104959d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lu.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lu_CD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lu_CD.dat new file mode 100644 index 0000000000000000000000000000000000000000..b2f405ccf6bc6b294b96546547731a655480d957 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lu_CD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luo.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luo.dat new file mode 100644 index 0000000000000000000000000000000000000000..1fbbe68e4cc171e4c2d5fa12a4a1ee5ca9b3366a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luo.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luo_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luo_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..9ad4a6a49e0351b00d3b218e1a6123b7dd0dce79 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luo_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luy.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luy.dat new file mode 100644 index 0000000000000000000000000000000000000000..c82c89292138b3a1cb34b0bb8c3ec220463c34cb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luy.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luy_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luy_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..e1b346e46e46347a6bee8be9d548f066a54d089b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/luy_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lv_LV.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lv_LV.dat new file mode 100644 index 0000000000000000000000000000000000000000..37bb4e261bb466b1ddd8e02b315a257b0a43557a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/lv_LV.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mai.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mai.dat new file mode 100644 index 0000000000000000000000000000000000000000..bde3b353b461a556480f3dd0f859922aa37fe52a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mai.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mai_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mai_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..288b92f8a8947a8e0c0ed4472cb29811d4ad3f47 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mai_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mas.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mas.dat new file mode 100644 index 0000000000000000000000000000000000000000..7e254ed9466b903dd1389bc1b30f07d12cfef944 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mas.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mas_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mas_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..b264c8371c065ae8a34083e4f335c5cb73cd88f1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mas_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mas_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mas_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..d5c71c37f9a2807c88508942f9add20eee7995e8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mas_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mdf.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mdf.dat new file mode 100644 index 0000000000000000000000000000000000000000..5d4d3f839e8dbce60b786f9738e8b9216dbfde12 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mdf.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mdf_RU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mdf_RU.dat new file mode 100644 index 0000000000000000000000000000000000000000..9457135938f9f140fcded2860931c6bb14a8aabd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mdf_RU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mer.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mer.dat new file mode 100644 index 0000000000000000000000000000000000000000..f6657fe13d56aee002dd062da1b2ce9aa1a25b93 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mer.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mer_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mer_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..a7c286f72bb11d021537e292f6efd6bdbe19ea55 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mer_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mfe.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mfe.dat new file mode 100644 index 0000000000000000000000000000000000000000..10eef776c01ea1debd6da686d7e74579d269f1a3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mfe.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mfe_MU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mfe_MU.dat new file mode 100644 index 0000000000000000000000000000000000000000..2f4715ba083648ed21845f0e48b0f1808266b37f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mfe_MU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mg.dat new file mode 100644 index 0000000000000000000000000000000000000000..f91a1dd194af199229fd02d8ac8ae03d07f9aefa Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mg_MG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mg_MG.dat new file mode 100644 index 0000000000000000000000000000000000000000..9e18e6cb756b87633bd09a2102d2f6844008e201 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mg_MG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgh.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgh.dat new file mode 100644 index 0000000000000000000000000000000000000000..e8a28060538c61b1420bb56b67737c1c04f8a154 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgh.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgh_MZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgh_MZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..999e8efb02c824f2ee9b44e396f4b750de11d276 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgh_MZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgo.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgo.dat new file mode 100644 index 0000000000000000000000000000000000000000..edbda97941e390080a9c3a32bb144c0978ff1384 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgo.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgo_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgo_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..667c017285337c4b48c3bdc86047738a83888882 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mgo_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mhn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mhn.dat new file mode 100644 index 0000000000000000000000000000000000000000..1a3303d9b5daedb0cc2d5c4d29d18b3f3ff2b246 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mhn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mhn_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mhn_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..c647205542d73e8daa4ecf485cd244deabf3c33e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mhn_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mi.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mi.dat new file mode 100644 index 0000000000000000000000000000000000000000..79eb095aa3549568dfb2542817542c8bed633a24 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mi.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mi_NZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mi_NZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..7c8b4d19b8e9e4e3840b296766d8469ddde66f29 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mi_NZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mic.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mic.dat new file mode 100644 index 0000000000000000000000000000000000000000..3ca1892e1d51369f5a68369b8c12da3bfb230daf Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mic.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mic_CA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mic_CA.dat new file mode 100644 index 0000000000000000000000000000000000000000..f43465a947872a0f4ec053bd7c88228619d50efb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mic_CA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mk_MK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mk_MK.dat new file mode 100644 index 0000000000000000000000000000000000000000..33207d9a9960ba975c30fd1b4c2d6f418bee86fa Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mk_MK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ml_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ml_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..5f89f111a5decfceccfb95ad80d6e552253c3268 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ml_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_MN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_MN.dat new file mode 100644 index 0000000000000000000000000000000000000000..096cb10478eefce99d693c2877f3d1e444c3a75b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_MN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_Mong.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_Mong.dat new file mode 100644 index 0000000000000000000000000000000000000000..287f85265b30743065120e2fa442bb5bfc54492f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_Mong.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_Mong_CN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_Mong_CN.dat new file mode 100644 index 0000000000000000000000000000000000000000..284cbee85de0bc4210e44769410b40a617b5b494 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_Mong_CN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_Mong_MN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_Mong_MN.dat new file mode 100644 index 0000000000000000000000000000000000000000..ad54681c07d5d696d72bba8f9a49c02c2d86baed Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mn_Mong_MN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni.dat new file mode 100644 index 0000000000000000000000000000000000000000..4ebcfc59aad390f57e5af3047d0d522d31ebdb50 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Beng.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Beng.dat new file mode 100644 index 0000000000000000000000000000000000000000..de357a87140a76e8342b6d9c7fb878a91b06ced8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Beng.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Beng_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Beng_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..28787ccd0c661f1d3765f33dad8f51154d52ab47 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Beng_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Mtei.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Mtei.dat new file mode 100644 index 0000000000000000000000000000000000000000..654042f8bb4c2da1fb319cf9ec89d64d61458188 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Mtei.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Mtei_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Mtei_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..28787ccd0c661f1d3765f33dad8f51154d52ab47 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mni_Mtei_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/moh.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/moh.dat new file mode 100644 index 0000000000000000000000000000000000000000..c301f3f730cdf8e657f9af60771d1ce434dd7db8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/moh.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/moh_CA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/moh_CA.dat new file mode 100644 index 0000000000000000000000000000000000000000..ba2eddea629cd2557f9bdd3e48cfe2be012bdf3f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/moh_CA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mr_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mr_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..a57af72d972822e818300a8c827367a7362d2b4a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mr_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_Arab.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_Arab.dat new file mode 100644 index 0000000000000000000000000000000000000000..7ee5bee07c52d8711e69205a711aee26f4fd91d2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_Arab.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_Arab_BN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_Arab_BN.dat new file mode 100644 index 0000000000000000000000000000000000000000..1785baa75df82ae8b657074e9ec1d894ece1c20a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_Arab_BN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_Arab_MY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_Arab_MY.dat new file mode 100644 index 0000000000000000000000000000000000000000..5df0cb7512eee5622689658266dfa12550f73321 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_Arab_MY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_BN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_BN.dat new file mode 100644 index 0000000000000000000000000000000000000000..1785baa75df82ae8b657074e9ec1d894ece1c20a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_BN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_ID.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_ID.dat new file mode 100644 index 0000000000000000000000000000000000000000..07b0e7693690a52fa6abbbac6388fc95bcd01210 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_ID.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_MY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_MY.dat new file mode 100644 index 0000000000000000000000000000000000000000..5df0cb7512eee5622689658266dfa12550f73321 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_MY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_SG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_SG.dat new file mode 100644 index 0000000000000000000000000000000000000000..33205113e184c9337fc92ac987a32e68b16c7325 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ms_SG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mt.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mt.dat new file mode 100644 index 0000000000000000000000000000000000000000..502594b2908c824af35e6fb29e5212de1500fedc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mt.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mt_MT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mt_MT.dat new file mode 100644 index 0000000000000000000000000000000000000000..9f4731e41b870956c24fa2e322e292705bcc1ff2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mt_MT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mua.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mua.dat new file mode 100644 index 0000000000000000000000000000000000000000..7d28adf1b12cfc6b77afbbc3959132275f1a9f96 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mua.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mua_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mua_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..5b71a89b73f4e0225d52cfe9a9efb20fd197bde9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mua_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mus.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mus.dat new file mode 100644 index 0000000000000000000000000000000000000000..b323269db48c396fa6b73444439b0a8cb15a1046 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mus.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mus_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mus_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..a506b8bdc53b29aa79518d3a7ac160cfdfe85fba Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mus_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/my_MM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/my_MM.dat new file mode 100644 index 0000000000000000000000000000000000000000..33bc9111bc7d012bd403d66369cc6c854e32bb40 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/my_MM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/myv.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/myv.dat new file mode 100644 index 0000000000000000000000000000000000000000..896bdd71e70083976936fe2c146e4688ccdf074f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/myv.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/myv_RU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/myv_RU.dat new file mode 100644 index 0000000000000000000000000000000000000000..de64fee658593881d312351505ea347eeae06f7e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/myv_RU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mzn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mzn.dat new file mode 100644 index 0000000000000000000000000000000000000000..51d9f1323d3bca270ea4e58b3ed8843bc5b6902f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mzn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mzn_IR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mzn_IR.dat new file mode 100644 index 0000000000000000000000000000000000000000..73990744c34b9dc21913fb29a7a2a7cb2fce118b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/mzn_IR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/naq.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/naq.dat new file mode 100644 index 0000000000000000000000000000000000000000..786b2ffedea8a833d5b635e02907404f6a235388 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/naq.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/naq_NA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/naq_NA.dat new file mode 100644 index 0000000000000000000000000000000000000000..82c109a0e40453c362ef5af05fc22ee11ef15d2c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/naq_NA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nb.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nb.dat new file mode 100644 index 0000000000000000000000000000000000000000..5abc2536ec7d0e253ec14958960b83981c94df6c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nb.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nb_NO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nb_NO.dat new file mode 100644 index 0000000000000000000000000000000000000000..fc57a39a55e6f0d10d4bdeb99da1c49e16111b66 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nb_NO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nb_SJ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nb_SJ.dat new file mode 100644 index 0000000000000000000000000000000000000000..9af3a275de68e92a628034bcc058d913aa1f99b4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nb_SJ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nd.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nd.dat new file mode 100644 index 0000000000000000000000000000000000000000..c13781ab1845c9e17e776fc7633d5c6b03cbfc7b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nd.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nd_ZW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nd_ZW.dat new file mode 100644 index 0000000000000000000000000000000000000000..bb86d3f6ae698e8f87e8a34483f98cee09460fb9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nd_ZW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nds.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nds.dat new file mode 100644 index 0000000000000000000000000000000000000000..e1c76cae91eba026aa8ba057d694465376c5d940 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nds.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nds_DE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nds_DE.dat new file mode 100644 index 0000000000000000000000000000000000000000..771fba3e2ecb6b40cad0a4343eeb490c10b1c802 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nds_DE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nds_NL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nds_NL.dat new file mode 100644 index 0000000000000000000000000000000000000000..14b9b12306790de2097804d28e8e9ea2ab92740e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nds_NL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ne_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ne_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..647efe6d89a1cc182a20e0c20247296f92834a0c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ne_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ne_NP.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ne_NP.dat new file mode 100644 index 0000000000000000000000000000000000000000..5c513db988b647f59c5b8f0daa7147efb43a53e3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ne_NP.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_AW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_AW.dat new file mode 100644 index 0000000000000000000000000000000000000000..0bd826c468a7010a777176528b95795c904423d4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_AW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_BE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_BE.dat new file mode 100644 index 0000000000000000000000000000000000000000..4023b7a2a8975e37c6e2b4df17d34c0d7e95354b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_BE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_BQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_BQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..8f686f79c1bcf0273415016ebaee024a15c79ff2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_BQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_CW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_CW.dat new file mode 100644 index 0000000000000000000000000000000000000000..ea3eb94fe8753e8e1ea147664f09f6b1ce4903b2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_CW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_NL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_NL.dat new file mode 100644 index 0000000000000000000000000000000000000000..c686473e2ce475ef8c48fa1595e2ad5179d7b014 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_NL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_SR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_SR.dat new file mode 100644 index 0000000000000000000000000000000000000000..6ffb0f92c9f2219111867a3ac57fab37c3f1b44f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_SR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_SX.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_SX.dat new file mode 100644 index 0000000000000000000000000000000000000000..6932aa19fdf9f10afa37ad18d667e7b5ab329c9c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nl_SX.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nmg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nmg.dat new file mode 100644 index 0000000000000000000000000000000000000000..1e508106d4c505b1a447dcfe3ae7d44675222bfd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nmg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nmg_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nmg_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..f675485dbffb6757f2c4c527c9265c6f9d234b72 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nmg_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nn.dat new file mode 100644 index 0000000000000000000000000000000000000000..fde5bfc99a3bdfbcc428f9002eb2d1ede104a206 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nn_NO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nn_NO.dat new file mode 100644 index 0000000000000000000000000000000000000000..0e233b7d2ae91fc1fa221785eb341dd8f0837f94 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nn_NO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nnh.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nnh.dat new file mode 100644 index 0000000000000000000000000000000000000000..2389679051264463b4622188dc3be6e7b3f47918 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nnh.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nnh_CM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nnh_CM.dat new file mode 100644 index 0000000000000000000000000000000000000000..7722c099277483aea5ce2d679da8f078fe8a5770 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nnh_CM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nqo_GN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nqo_GN.dat new file mode 100644 index 0000000000000000000000000000000000000000..3cdbcbcd5ae4700ac750c9e3a24b1f0338088001 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nqo_GN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nr.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nr.dat new file mode 100644 index 0000000000000000000000000000000000000000..1306c925de68f0494c58a8bbae38d23e6c84a224 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nr.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nr_ZA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nr_ZA.dat new file mode 100644 index 0000000000000000000000000000000000000000..ff0ba0b081864023c8dc43e26fc41dba3ed8ae38 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nr_ZA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nso.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nso.dat new file mode 100644 index 0000000000000000000000000000000000000000..25529c1af5588d068f2c17c89caff64ef7818b70 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nso.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nso_ZA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nso_ZA.dat new file mode 100644 index 0000000000000000000000000000000000000000..42f9efca9ca91ded4ab6bb32c1d8500f7eb83050 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nso_ZA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nus.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nus.dat new file mode 100644 index 0000000000000000000000000000000000000000..6bc938281e5c8dd2ae139c32a3e097f70f84a57f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nus.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nus_SS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nus_SS.dat new file mode 100644 index 0000000000000000000000000000000000000000..b8b86575ec1940f98bef06533bf3d049e3de8ffc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nus_SS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nv.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nv.dat new file mode 100644 index 0000000000000000000000000000000000000000..146e037b9543e98059b19a19639bf6b6c028eb68 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nv.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nv_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nv_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..2c78aa76506372a1532d53bac1b8e42e53677c51 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nv_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ny.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ny.dat new file mode 100644 index 0000000000000000000000000000000000000000..e1fc061388f76d4949d585278c1b5809552e1996 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ny.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ny_MW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ny_MW.dat new file mode 100644 index 0000000000000000000000000000000000000000..003925586cac629d3ee8905b84490e4c68b0501f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ny_MW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nyn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nyn.dat new file mode 100644 index 0000000000000000000000000000000000000000..ccd34096be729fa5b770ce802d74273ec91c6c26 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nyn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nyn_UG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nyn_UG.dat new file mode 100644 index 0000000000000000000000000000000000000000..2e51c77b7f00af6db1bf126b0cf0905121ceed64 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/nyn_UG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/oc.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/oc.dat new file mode 100644 index 0000000000000000000000000000000000000000..b678c283ab791173b7f8d3b380937fac4843dd81 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/oc.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/oc_ES.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/oc_ES.dat new file mode 100644 index 0000000000000000000000000000000000000000..936a4bacaf1d69c4be16af8b8552127154dbaa44 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/oc_ES.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/oc_FR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/oc_FR.dat new file mode 100644 index 0000000000000000000000000000000000000000..613abbe703e300c4514c9ef5f0f5a1d5d6565bc0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/oc_FR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/om.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/om.dat new file mode 100644 index 0000000000000000000000000000000000000000..c83455ff1ae8c40c618939a71d45d7e3fd6fec61 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/om.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/om_ET.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/om_ET.dat new file mode 100644 index 0000000000000000000000000000000000000000..82c438b4bdfe6d49fdec95ed1410a4d375a0f8a4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/om_ET.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/om_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/om_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..daf3734d8bc3321ec6c6e6f46cec5bc18e8bf6c6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/om_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/or_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/or_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..12b4f1bcbbce3f411f945bbcdaaee98c6c42350c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/or_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/os.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/os.dat new file mode 100644 index 0000000000000000000000000000000000000000..a90e8198ee26d4118dc21ca1e8a1da0ca1bdbea5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/os.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/os_GE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/os_GE.dat new file mode 100644 index 0000000000000000000000000000000000000000..205ddbf23aea70eb4ad61d0e4de3d7d4ec9d2c5a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/os_GE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/os_RU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/os_RU.dat new file mode 100644 index 0000000000000000000000000000000000000000..f51d3d917392be3c302134ec56c2935ca1cb23b2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/os_RU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/osa.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/osa.dat new file mode 100644 index 0000000000000000000000000000000000000000..eb1d4ff42ffa3247631b07605977997ac1b02ba4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/osa.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/osa_US.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/osa_US.dat new file mode 100644 index 0000000000000000000000000000000000000000..03c110027bf4fc1ed63dbd85ad525ec60fa65e77 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/osa_US.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Arab.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Arab.dat new file mode 100644 index 0000000000000000000000000000000000000000..0d02acbd475a0e8dde9a58b0986bf85601c20630 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Arab.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Arab_PK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Arab_PK.dat new file mode 100644 index 0000000000000000000000000000000000000000..eefdeba166313b4fc73728951d7b40134f0059fe Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Arab_PK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Guru.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Guru.dat new file mode 100644 index 0000000000000000000000000000000000000000..ed8c6b6f0425c4510e391e282e72733dc130d21d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Guru.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Guru_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Guru_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..6af3517d71095fa5f27b527915d1a8871017af84 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pa_Guru_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pap.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pap.dat new file mode 100644 index 0000000000000000000000000000000000000000..68b8dc4626d6a72322b5dd754766fc846e39e4b5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pap.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pap_AW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pap_AW.dat new file mode 100644 index 0000000000000000000000000000000000000000..973cc7637c55c10d66dad0ab3d92a98c5897ce32 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pap_AW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pap_CW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pap_CW.dat new file mode 100644 index 0000000000000000000000000000000000000000..3c481d471cdc3c17c26a82434e7d66c81070930e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pap_CW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pcm_NG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pcm_NG.dat new file mode 100644 index 0000000000000000000000000000000000000000..7ee82746f22bcd192bab118da5ceaa98d4fa1a36 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pcm_NG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pis.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pis.dat new file mode 100644 index 0000000000000000000000000000000000000000..55726a02fcfe8efcec0209eae4b2571bc180ccd6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pis.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pis_SB.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pis_SB.dat new file mode 100644 index 0000000000000000000000000000000000000000..3b1f17cde15d79277dcda75fd0c662b1f5d9c440 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pis_SB.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pl_PL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pl_PL.dat new file mode 100644 index 0000000000000000000000000000000000000000..7a4339abac54c5a104e8dae0ee24a67d75bf51a3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pl_PL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/prg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/prg.dat new file mode 100644 index 0000000000000000000000000000000000000000..06219914d6b96ee3ef9d57adcdf6348b21cc253e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/prg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/prg_PL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/prg_PL.dat new file mode 100644 index 0000000000000000000000000000000000000000..7b1970517c0e7eda3f412ab77eae5a628c6b080a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/prg_PL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ps_AF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ps_AF.dat new file mode 100644 index 0000000000000000000000000000000000000000..94a50bffb0731a4244db3bc63bccc03552ae2d46 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ps_AF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ps_PK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ps_PK.dat new file mode 100644 index 0000000000000000000000000000000000000000..691557eaaa20262a7dd86f8598f0c1543fa3e6ad Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ps_PK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_AO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_AO.dat new file mode 100644 index 0000000000000000000000000000000000000000..4cd1fbdac7cfc218a0c9ab5dad23b260c0a6d91a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_AO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_BR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_BR.dat new file mode 100644 index 0000000000000000000000000000000000000000..22952c77d0156d99b1a57a17c6d3f4a2ec34fd83 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_BR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_CH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_CH.dat new file mode 100644 index 0000000000000000000000000000000000000000..268428655db5c8288d57d534df4d70b91453d16d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_CH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_CV.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_CV.dat new file mode 100644 index 0000000000000000000000000000000000000000..78e2bbcf844a54d1973d06425f237743e89549b0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_CV.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_GQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_GQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..88968337f024e2090db6a647e327b3da3e3ae981 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_GQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_GW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_GW.dat new file mode 100644 index 0000000000000000000000000000000000000000..d44108a14b441bb8e6befd35965e43a4278798e8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_GW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_LU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_LU.dat new file mode 100644 index 0000000000000000000000000000000000000000..af0b45b3dfa18f4a64fad761f6ecb6461986db26 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_LU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_MO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_MO.dat new file mode 100644 index 0000000000000000000000000000000000000000..4fcee0991caf305b91bec53eaf4499180449fa02 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_MO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_MZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_MZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..198075e8198e9bbcb9a3d49ab8ae1e912c572792 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_MZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_PT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_PT.dat new file mode 100644 index 0000000000000000000000000000000000000000..aa6a6ccb9080927139e20b0cc32493ca5c9b43f3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_PT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_ST.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_ST.dat new file mode 100644 index 0000000000000000000000000000000000000000..cdccab774c4c8a1949ea8c9c3a42133a702d4e66 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_ST.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_TL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_TL.dat new file mode 100644 index 0000000000000000000000000000000000000000..7bb756cda597ecabd0864f06d527d249ed7ec3d3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/pt_TL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu.dat new file mode 100644 index 0000000000000000000000000000000000000000..85cc9eca812e0277658be03e451a0b8aa1a9d412 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu_BO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu_BO.dat new file mode 100644 index 0000000000000000000000000000000000000000..bc994ff71279cddb8ff5f163e6c55b13603cfdb6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu_BO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu_EC.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu_EC.dat new file mode 100644 index 0000000000000000000000000000000000000000..8f7f46ad54b91576184c6b8c63dcc996b333f504 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu_EC.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu_PE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu_PE.dat new file mode 100644 index 0000000000000000000000000000000000000000..07aacf94b96a35e1e5305c9539acf688c6f355b2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/qu_PE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/quc.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/quc.dat new file mode 100644 index 0000000000000000000000000000000000000000..f7e02d8abcbdbace395dc68ab09f34cb6f8e8538 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/quc.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/quc_GT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/quc_GT.dat new file mode 100644 index 0000000000000000000000000000000000000000..c14f849cbbb44e7186dfce2305d938dccb991c23 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/quc_GT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/raj.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/raj.dat new file mode 100644 index 0000000000000000000000000000000000000000..8f4477fa0201ca11adf07c795bc48a13ab188712 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/raj.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/raj_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/raj_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..e56e75027f47427213473db8b21702ff874b6c75 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/raj_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg.dat new file mode 100644 index 0000000000000000000000000000000000000000..192bbff035a534ee3776e2c02598e74b591cd8c0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg_Rohg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg_Rohg.dat new file mode 100644 index 0000000000000000000000000000000000000000..01b82ecf252b8e27e8e21cd8ba16f40c5b5de863 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg_Rohg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg_Rohg_BD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg_Rohg_BD.dat new file mode 100644 index 0000000000000000000000000000000000000000..cc14c7f83aba67864d14968a00ba2937e7adcd94 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg_Rohg_BD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg_Rohg_MM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg_Rohg_MM.dat new file mode 100644 index 0000000000000000000000000000000000000000..6cfde86150cf0c630c1a25eaf24544221d3979e9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rhg_Rohg_MM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rif.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rif.dat new file mode 100644 index 0000000000000000000000000000000000000000..b5efc905394ac93ddca4c68a75831cd5788cb21b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rif.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rif_MA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rif_MA.dat new file mode 100644 index 0000000000000000000000000000000000000000..9b7f4342e75ed050ba9c3e2f4ea9969c3cfad261 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rif_MA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rm.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rm.dat new file mode 100644 index 0000000000000000000000000000000000000000..2398d9074f095fd87b56ff2c852cc1467c2b8125 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rm.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rm_CH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rm_CH.dat new file mode 100644 index 0000000000000000000000000000000000000000..26eccfc329149ee1eba4e79a7a3c4a326227ab7d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rm_CH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rn.dat new file mode 100644 index 0000000000000000000000000000000000000000..f21edd4ded5cf9afab85f5022d68935403280b43 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rn_BI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rn_BI.dat new file mode 100644 index 0000000000000000000000000000000000000000..d1ef9755fd037d5bd16a8a1425871b3e7400da99 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rn_BI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ro_MD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ro_MD.dat new file mode 100644 index 0000000000000000000000000000000000000000..82b8bb6d93ef041761e5d3fd6a8269e66c70463e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ro_MD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ro_RO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ro_RO.dat new file mode 100644 index 0000000000000000000000000000000000000000..3517a61009c522d0149fbc45d50ddd88fd119194 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ro_RO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rof.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rof.dat new file mode 100644 index 0000000000000000000000000000000000000000..6f0e55144527317134867c80a2096bfafc9fc64a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rof.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rof_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rof_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..d7ffaeb0a76c472368770e0b89c4ca3f548e0bec Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rof_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/root.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/root.dat new file mode 100644 index 0000000000000000000000000000000000000000..441bbdc9afbf7a5b871c150adfb512d55c93e0be Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/root.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_BY.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_BY.dat new file mode 100644 index 0000000000000000000000000000000000000000..e8ef98d49b3f9e7a332dd318b2eae72abb3bda1b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_BY.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_KG.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_KG.dat new file mode 100644 index 0000000000000000000000000000000000000000..f3e59502c9630323391f612d73430c070032f36e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_KG.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_KZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_KZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..b66765a5cd34a1c674992aa836c3adbb96c7f187 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_KZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_MD.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_MD.dat new file mode 100644 index 0000000000000000000000000000000000000000..d70419944cc220a58cc228563058cc4188a468cd Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_MD.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_RU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_RU.dat new file mode 100644 index 0000000000000000000000000000000000000000..a11835701502cde3d61172ac31ce75aba85650c2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_RU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_UA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_UA.dat new file mode 100644 index 0000000000000000000000000000000000000000..cebd8c23b818cb244dc79471fb2c8fef39295fdf Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ru_UA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rw.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rw.dat new file mode 100644 index 0000000000000000000000000000000000000000..d767b3093d8803f48495b46720153470ee2d2b50 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rw.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rw_RW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rw_RW.dat new file mode 100644 index 0000000000000000000000000000000000000000..4ade0dd6463c6ca8ded2cf511a016204f72993bc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rw_RW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rwk.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rwk.dat new file mode 100644 index 0000000000000000000000000000000000000000..fd69cc075357bd892714a04ac375d53d14d8c166 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rwk.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rwk_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rwk_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..fedafc3ef2eb0ed4c45dc0672420040a1e12edd2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/rwk_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sa.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sa.dat new file mode 100644 index 0000000000000000000000000000000000000000..76f67c4d570eb3c69cb0067c45af14aa9429cc0d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sa.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sa_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sa_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..317817512296780bbc08e5a16a6fc9f0b0fae82e Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sa_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sah.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sah.dat new file mode 100644 index 0000000000000000000000000000000000000000..bad972f99b8ff84db7fcb3a149f2d52b78ceecce Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sah.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sah_RU.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sah_RU.dat new file mode 100644 index 0000000000000000000000000000000000000000..44075f9fa05087862b23d993c4cbb3feee664763 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sah_RU.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/saq.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/saq.dat new file mode 100644 index 0000000000000000000000000000000000000000..9532083360997414160626483375e8a66942cd08 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/saq.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/saq_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/saq_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..ffd91c3524ca86dea29df7af3d62dd3ef27b1aac Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/saq_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat.dat new file mode 100644 index 0000000000000000000000000000000000000000..3a63c743e9e7cf2c64850e6d3a64e1ea744ea046 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Deva.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Deva.dat new file mode 100644 index 0000000000000000000000000000000000000000..9a1af369a0d66e19e5c8d92040e1e3e276107975 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Deva.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Deva_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Deva_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..1781be05559c4785f3de05c40b9e72bb66e3976c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Deva_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Olck.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Olck.dat new file mode 100644 index 0000000000000000000000000000000000000000..444b35844ee4767f280814e5577d674a8a992633 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Olck.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Olck_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Olck_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..1781be05559c4785f3de05c40b9e72bb66e3976c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sat_Olck_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sbp.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sbp.dat new file mode 100644 index 0000000000000000000000000000000000000000..e1ea58b95cafa2a8a1be83a601dc3922b1a4a3a7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sbp.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sbp_TZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sbp_TZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..2292ffb6f713c108e496b514adc70ffcc6bb427f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sbp_TZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sc_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sc_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..12c8c5630fb293389f3f1f9f64ba514d9444fa20 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sc_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/scn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/scn.dat new file mode 100644 index 0000000000000000000000000000000000000000..c8ebaec1509ce5d9b454877b51f44535d82fe853 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/scn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/scn_IT.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/scn_IT.dat new file mode 100644 index 0000000000000000000000000000000000000000..0e8b90ec46da7160c9ca3adc39be0b71c7835188 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/scn_IT.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Arab.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Arab.dat new file mode 100644 index 0000000000000000000000000000000000000000..8003f26f9e289645c45b938a95ae9b5e6da27670 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Arab.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Arab_PK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Arab_PK.dat new file mode 100644 index 0000000000000000000000000000000000000000..42f6290f13c23b37fe618ea639def889b7d77fe8 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Arab_PK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Deva.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Deva.dat new file mode 100644 index 0000000000000000000000000000000000000000..5193db74b6d4e5540d2e78ed42f4df92293d155d Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Deva.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Deva_IN.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Deva_IN.dat new file mode 100644 index 0000000000000000000000000000000000000000..21aee01ca3c81d80b437d36e0ff6fe8722208eec Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sd_Deva_IN.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sdh.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sdh.dat new file mode 100644 index 0000000000000000000000000000000000000000..f51767d16291d64ebd08ac206081beec41893da0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sdh.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sdh_IQ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sdh_IQ.dat new file mode 100644 index 0000000000000000000000000000000000000000..774d04d58131d20e0f41869658d9b86527c6e423 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sdh_IQ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sdh_IR.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sdh_IR.dat new file mode 100644 index 0000000000000000000000000000000000000000..6e83d1f11ec54d6d342c30130bc602a3734ad066 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sdh_IR.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se.dat new file mode 100644 index 0000000000000000000000000000000000000000..8da459229016874775b910345a0204d96094e472 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se_FI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se_FI.dat new file mode 100644 index 0000000000000000000000000000000000000000..2f927646782dd3c588ff94cbeae5e2bd725e5c5c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se_FI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se_NO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se_NO.dat new file mode 100644 index 0000000000000000000000000000000000000000..09eca0d2b90185593876c25eb6b9ac7d7e7475a1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se_NO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se_SE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se_SE.dat new file mode 100644 index 0000000000000000000000000000000000000000..632b54e7c2c279853e98bc4376cc3b8509e5fbc3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/se_SE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/seh.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/seh.dat new file mode 100644 index 0000000000000000000000000000000000000000..e61f09ba4f51b8ae980211e2bf304965f2249131 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/seh.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/seh_MZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/seh_MZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..ba30e958ac150994928afc1416a42d02b1f4eaa0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/seh_MZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ses.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ses.dat new file mode 100644 index 0000000000000000000000000000000000000000..f9858d965c73945b3a7fcc0578124ffd34d488d3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ses.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ses_ML.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ses_ML.dat new file mode 100644 index 0000000000000000000000000000000000000000..a0010889626d998765bcb8341368b773fb0591f5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ses_ML.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sg.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sg.dat new file mode 100644 index 0000000000000000000000000000000000000000..8ce0d409ecf73a0225169b2ee7c7d7af0d658864 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sg.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sg_CF.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sg_CF.dat new file mode 100644 index 0000000000000000000000000000000000000000..0ca555a69e81432f4499cc9ea2d3dd532f62fd84 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sg_CF.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi.dat new file mode 100644 index 0000000000000000000000000000000000000000..f3d106679e47f50ef0ee7ec2a04dd4c7aef844e9 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Latn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Latn.dat new file mode 100644 index 0000000000000000000000000000000000000000..fecc8217a3a7ce7f38d2ceab1d31bfbbab058b8f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Latn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Latn_MA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Latn_MA.dat new file mode 100644 index 0000000000000000000000000000000000000000..14955853f11ba0456a324ba01a15e69b344035b6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Latn_MA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Tfng.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Tfng.dat new file mode 100644 index 0000000000000000000000000000000000000000..63ebefe7836a18f2c25e3eae285b52075a7c70d7 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Tfng.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Tfng_MA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Tfng_MA.dat new file mode 100644 index 0000000000000000000000000000000000000000..14955853f11ba0456a324ba01a15e69b344035b6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shi_Tfng_MA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shn.dat new file mode 100644 index 0000000000000000000000000000000000000000..7eb56999cfe4dcfec3e2a5c2f52b31dc1adc52a5 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shn_MM.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shn_MM.dat new file mode 100644 index 0000000000000000000000000000000000000000..3cace2923308a496a9b54e51f207f66a211388c4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shn_MM.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shn_TH.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shn_TH.dat new file mode 100644 index 0000000000000000000000000000000000000000..cc5364a2d984bd1db01ccf2d78ecd678b52cd7e1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/shn_TH.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/si_LK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/si_LK.dat new file mode 100644 index 0000000000000000000000000000000000000000..eb323029502a6044f9ab907cadcd096e7cbd5ae1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/si_LK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sid.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sid.dat new file mode 100644 index 0000000000000000000000000000000000000000..3445845df95cb84e640ceb39779467a6d7da7cf2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sid.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sid_ET.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sid_ET.dat new file mode 100644 index 0000000000000000000000000000000000000000..1be7a4a9060cd200310d19dcebbb586c48b706eb Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sid_ET.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sk_SK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sk_SK.dat new file mode 100644 index 0000000000000000000000000000000000000000..4ba6c84139206eace0430588a3194e3b2e07177c Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sk_SK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/skr.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/skr.dat new file mode 100644 index 0000000000000000000000000000000000000000..d9fc42902123f12cd4886b8e6cbb84146bcb2932 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/skr.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/skr_PK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/skr_PK.dat new file mode 100644 index 0000000000000000000000000000000000000000..8db57bc586b6a2352cf618c05985073fb8de3c54 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/skr_PK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sl_SI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sl_SI.dat new file mode 100644 index 0000000000000000000000000000000000000000..b4955823a5ffd7ed7e855f25a37114b3308eba11 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sl_SI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sma.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sma.dat new file mode 100644 index 0000000000000000000000000000000000000000..925c9565690eb2ccb1fb4e9dcbc126a2f9a0f578 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sma.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sma_NO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sma_NO.dat new file mode 100644 index 0000000000000000000000000000000000000000..325e16cc601d985ccc4ea77f2ebda7ee20f27bd1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sma_NO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sma_SE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sma_SE.dat new file mode 100644 index 0000000000000000000000000000000000000000..b9cb4e75432c2271f0c4530b650cf17882caf524 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sma_SE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smj.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smj.dat new file mode 100644 index 0000000000000000000000000000000000000000..377b17c7023540028324205ecba59267f9cdb8e2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smj.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smj_NO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smj_NO.dat new file mode 100644 index 0000000000000000000000000000000000000000..7cc36547fc202742bd6c92af1270d907c54d034a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smj_NO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smj_SE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smj_SE.dat new file mode 100644 index 0000000000000000000000000000000000000000..78aa9de9e710fc9325c156d781058e30c8d827e0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smj_SE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smn.dat new file mode 100644 index 0000000000000000000000000000000000000000..f63177affd2dac60e2d8fd144362c1bb8dcb37f3 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smn_FI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smn_FI.dat new file mode 100644 index 0000000000000000000000000000000000000000..a88e29d9de08a73a47ff0e85a90ef2ca79409a66 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/smn_FI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sms.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sms.dat new file mode 100644 index 0000000000000000000000000000000000000000..590f25adbddb3883f99ec5739e418c55e3e995e6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sms.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sms_FI.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sms_FI.dat new file mode 100644 index 0000000000000000000000000000000000000000..91bdf45ea9b4a2826d121a196f97d995f299b4f0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sms_FI.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sn.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sn.dat new file mode 100644 index 0000000000000000000000000000000000000000..cb8e1bd84853eb5d4bab203b741f8dc69f301217 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sn.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sn_ZW.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sn_ZW.dat new file mode 100644 index 0000000000000000000000000000000000000000..4dd1932db2306017bf98ba7f556aa4610759bb08 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sn_ZW.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_DJ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_DJ.dat new file mode 100644 index 0000000000000000000000000000000000000000..756644b6d4fc3c62c3317de59cb5180cc5105970 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_DJ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_ET.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_ET.dat new file mode 100644 index 0000000000000000000000000000000000000000..abd6c12547ff495072603b833697f526480faea2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_ET.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_KE.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_KE.dat new file mode 100644 index 0000000000000000000000000000000000000000..2c422f93be494a29087d1df7e70fc56741ea1dd6 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_KE.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_SO.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_SO.dat new file mode 100644 index 0000000000000000000000000000000000000000..aa7955c507825ed0cf07fbc45fb8176f8d706e9b Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/so_SO.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sq_AL.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sq_AL.dat new file mode 100644 index 0000000000000000000000000000000000000000..5a5320fce78a249a2ede83a487834c2aba9fc4c2 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sq_AL.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sq_MK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sq_MK.dat new file mode 100644 index 0000000000000000000000000000000000000000..32565ce7c375306da1fb3223f08e11300148748a Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sq_MK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sq_XK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sq_XK.dat new file mode 100644 index 0000000000000000000000000000000000000000..bbe0062ec8c42c6cd349aa34d64ecf1c87aff874 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sq_XK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl.dat new file mode 100644 index 0000000000000000000000000000000000000000..89154355eb169abd69d29b60f028cdc711db14fc Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_BA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_BA.dat new file mode 100644 index 0000000000000000000000000000000000000000..6a0aaf69a1ec25e1ba9a921985b33c66b31241b4 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_BA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_ME.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_ME.dat new file mode 100644 index 0000000000000000000000000000000000000000..357ab293176b6418e8d7acf46dfc0deb795b57af Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_ME.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_RS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_RS.dat new file mode 100644 index 0000000000000000000000000000000000000000..b26330986819e979ae2f69dd23733cef18c8bba0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_RS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_XK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_XK.dat new file mode 100644 index 0000000000000000000000000000000000000000..b574d058a91e78c50aac552b26f4f8822dc690d1 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Cyrl_XK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_BA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_BA.dat new file mode 100644 index 0000000000000000000000000000000000000000..d1be6b892586f58be464ea56d38b8c8cdd3a8f54 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_BA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_ME.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_ME.dat new file mode 100644 index 0000000000000000000000000000000000000000..b8b9a5b4bfde9df9249517fd8cc79444c88f6a42 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_ME.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_RS.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_RS.dat new file mode 100644 index 0000000000000000000000000000000000000000..b26330986819e979ae2f69dd23733cef18c8bba0 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_RS.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_XK.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_XK.dat new file mode 100644 index 0000000000000000000000000000000000000000..778db676e1814bb2650ccf42cc356f68d231f56f Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/sr_Latn_XK.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ss.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ss.dat new file mode 100644 index 0000000000000000000000000000000000000000..91c10e2c036419d78257cd0f1cf4ea870082f287 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ss.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ss_SZ.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ss_SZ.dat new file mode 100644 index 0000000000000000000000000000000000000000..b4fcf77904aad4b123c599eee895c194903c1973 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ss_SZ.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ss_ZA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ss_ZA.dat new file mode 100644 index 0000000000000000000000000000000000000000..67315698ed962181e364d2a1242be770b8e2ef93 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ss_ZA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ssy.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ssy.dat new file mode 100644 index 0000000000000000000000000000000000000000..a42b5e83b5fe50bcad0bef85aa75ccb920c10b50 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ssy.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ssy_ER.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ssy_ER.dat new file mode 100644 index 0000000000000000000000000000000000000000..1d28855a7056fc961022a4aa34ce3ce6a2234a70 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/ssy_ER.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/st.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/st.dat new file mode 100644 index 0000000000000000000000000000000000000000..26d9b21a3242ddf795e9bd56538ff6e9c11ad135 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/st.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/st_ZA.dat b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/st_ZA.dat new file mode 100644 index 0000000000000000000000000000000000000000..9539d6249c3db89c3f93d47981ff61f51dc72d14 Binary files /dev/null and b/TTS/Kokoro/.venv/Lib/site-packages/babel/locale-data/st_ZA.dat differ diff --git a/TTS/Kokoro/.venv/Lib/site-packages/transformers-5.2.0.dist-info/METADATA b/TTS/Kokoro/.venv/Lib/site-packages/transformers-5.2.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..b70a14bc578d7962311944913846ded8d4828b02 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/transformers-5.2.0.dist-info/METADATA @@ -0,0 +1,644 @@ +Metadata-Version: 2.4 +Name: transformers +Version: 5.2.0 +Summary: Transformers: the model-definition framework for state-of-the-art machine learning models in text, vision, audio, and multimodal models, for both inference and training. +Home-page: https://github.com/huggingface/transformers +Author: The Hugging Face team (past and future) with the help of all our contributors (https://github.com/huggingface/transformers/graphs/contributors) +Author-email: transformers@huggingface.co +License: Apache 2.0 License +Keywords: machine-learning nlp python pytorch transformer llm vlm deep-learning inference training model-hub pretrained-models llama gemma qwen +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Requires-Python: >=3.10.0 +Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: huggingface-hub<2.0,>=1.3.0 +Requires-Dist: numpy>=1.17 +Requires-Dist: packaging>=20.0 +Requires-Dist: pyyaml>=5.1 +Requires-Dist: regex!=2019.12.17 +Requires-Dist: tokenizers<=0.23.0,>=0.22.0 +Requires-Dist: typer-slim +Requires-Dist: safetensors>=0.4.3 +Requires-Dist: tqdm>=4.27 +Provides-Extra: torch +Requires-Dist: torch>=2.4; extra == "torch" +Requires-Dist: accelerate>=1.1.0; extra == "torch" +Provides-Extra: vision +Requires-Dist: torchvision; extra == "vision" +Requires-Dist: Pillow<=15.0,>=10.0.1; extra == "vision" +Provides-Extra: audio +Requires-Dist: torchaudio; extra == "audio" +Requires-Dist: librosa; extra == "audio" +Requires-Dist: pyctcdecode>=0.4.0; extra == "audio" +Requires-Dist: phonemizer; extra == "audio" +Provides-Extra: video +Requires-Dist: av; extra == "video" +Provides-Extra: timm +Requires-Dist: timm>=1.0.23; extra == "timm" +Provides-Extra: quality +Requires-Dist: datasets>=2.15.0; extra == "quality" +Requires-Dist: ruff==0.14.10; extra == "quality" +Requires-Dist: GitPython<3.1.19; extra == "quality" +Requires-Dist: urllib3<2.0.0; extra == "quality" +Requires-Dist: libcst; extra == "quality" +Requires-Dist: rich; extra == "quality" +Provides-Extra: kernels +Requires-Dist: kernels<0.11,>=0.10.2; extra == "kernels" +Provides-Extra: sentencepiece +Requires-Dist: sentencepiece!=0.1.92,>=0.1.91; extra == "sentencepiece" +Requires-Dist: protobuf; extra == "sentencepiece" +Provides-Extra: tiktoken +Requires-Dist: tiktoken; extra == "tiktoken" +Requires-Dist: blobfile; extra == "tiktoken" +Provides-Extra: mistral-common +Requires-Dist: mistral-common[image]>=1.8.8; extra == "mistral-common" +Provides-Extra: chat-template +Requires-Dist: jinja2>=3.1.0; extra == "chat-template" +Requires-Dist: jmespath>=1.0.1; extra == "chat-template" +Provides-Extra: sklearn +Requires-Dist: scikit-learn; extra == "sklearn" +Provides-Extra: accelerate +Requires-Dist: accelerate>=1.1.0; extra == "accelerate" +Provides-Extra: retrieval +Requires-Dist: faiss-cpu; extra == "retrieval" +Requires-Dist: datasets>=2.15.0; extra == "retrieval" +Provides-Extra: sagemaker +Requires-Dist: sagemaker>=2.31.0; extra == "sagemaker" +Provides-Extra: deepspeed +Requires-Dist: deepspeed>=0.9.3; extra == "deepspeed" +Requires-Dist: accelerate>=1.1.0; extra == "deepspeed" +Provides-Extra: optuna +Requires-Dist: optuna; extra == "optuna" +Provides-Extra: integrations +Requires-Dist: kernels<0.11,>=0.10.2; extra == "integrations" +Requires-Dist: optuna; extra == "integrations" +Requires-Dist: codecarbon>=2.8.1; extra == "integrations" +Requires-Dist: ray[tune]>=2.7.0; extra == "integrations" +Provides-Extra: ray +Requires-Dist: ray[tune]>=2.7.0; extra == "ray" +Provides-Extra: codecarbon +Requires-Dist: codecarbon>=2.8.1; extra == "codecarbon" +Provides-Extra: serving +Requires-Dist: openai>=1.98.0; extra == "serving" +Requires-Dist: pydantic>=2; extra == "serving" +Requires-Dist: uvicorn; extra == "serving" +Requires-Dist: fastapi; extra == "serving" +Requires-Dist: starlette; extra == "serving" +Requires-Dist: rich; extra == "serving" +Requires-Dist: torch>=2.4; extra == "serving" +Requires-Dist: accelerate>=1.1.0; extra == "serving" +Provides-Extra: num2words +Requires-Dist: num2words; extra == "num2words" +Provides-Extra: benchmark +Requires-Dist: optimum-benchmark>=0.3.0; extra == "benchmark" +Provides-Extra: ja +Requires-Dist: fugashi>=1.0; extra == "ja" +Requires-Dist: ipadic<2.0,>=1.0.0; extra == "ja" +Requires-Dist: unidic_lite>=1.0.7; extra == "ja" +Requires-Dist: unidic>=1.0.2; extra == "ja" +Requires-Dist: rhoknp<1.3.1,>=1.1.0; extra == "ja" +Requires-Dist: sudachipy>=0.6.6; extra == "ja" +Requires-Dist: sudachidict_core>=20220729; extra == "ja" +Provides-Extra: open-telemetry +Requires-Dist: opentelemetry-api; extra == "open-telemetry" +Requires-Dist: opentelemetry-exporter-otlp; extra == "open-telemetry" +Requires-Dist: opentelemetry-sdk; extra == "open-telemetry" +Provides-Extra: testing +Requires-Dist: pytest<9.0.0,>=7.2.0; extra == "testing" +Requires-Dist: pytest-asyncio>=1.2.0; extra == "testing" +Requires-Dist: pytest-random-order; extra == "testing" +Requires-Dist: pytest-rich; extra == "testing" +Requires-Dist: pytest-xdist; extra == "testing" +Requires-Dist: pytest-order; extra == "testing" +Requires-Dist: pytest-rerunfailures<16.0; extra == "testing" +Requires-Dist: pytest-timeout; extra == "testing" +Requires-Dist: pytest-env; extra == "testing" +Requires-Dist: timeout-decorator; extra == "testing" +Requires-Dist: parameterized>=0.9; extra == "testing" +Requires-Dist: psutil; extra == "testing" +Requires-Dist: dill<0.3.5; extra == "testing" +Requires-Dist: evaluate>=0.4.6; extra == "testing" +Requires-Dist: rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1; extra == "testing" +Requires-Dist: nltk<=3.8.1; extra == "testing" +Requires-Dist: sacremoses; extra == "testing" +Requires-Dist: rjieba; extra == "testing" +Requires-Dist: beautifulsoup4; extra == "testing" +Requires-Dist: tensorboard; extra == "testing" +Requires-Dist: sacrebleu<2.0.0,>=1.4.12; extra == "testing" +Requires-Dist: filelock; extra == "testing" +Requires-Dist: datasets>=2.15.0; extra == "testing" +Requires-Dist: ruff==0.14.10; extra == "testing" +Requires-Dist: GitPython<3.1.19; extra == "testing" +Requires-Dist: urllib3<2.0.0; extra == "testing" +Requires-Dist: libcst; extra == "testing" +Requires-Dist: rich; extra == "testing" +Requires-Dist: faiss-cpu; extra == "testing" +Requires-Dist: datasets>=2.15.0; extra == "testing" +Requires-Dist: sentencepiece!=0.1.92,>=0.1.91; extra == "testing" +Requires-Dist: protobuf; extra == "testing" +Requires-Dist: openai>=1.98.0; extra == "testing" +Requires-Dist: pydantic>=2; extra == "testing" +Requires-Dist: uvicorn; extra == "testing" +Requires-Dist: fastapi; extra == "testing" +Requires-Dist: starlette; extra == "testing" +Requires-Dist: rich; extra == "testing" +Requires-Dist: torch>=2.4; extra == "testing" +Requires-Dist: accelerate>=1.1.0; extra == "testing" +Requires-Dist: mistral-common[image]>=1.8.8; extra == "testing" +Provides-Extra: deepspeed-testing +Requires-Dist: deepspeed>=0.9.3; extra == "deepspeed-testing" +Requires-Dist: accelerate>=1.1.0; extra == "deepspeed-testing" +Requires-Dist: pytest<9.0.0,>=7.2.0; extra == "deepspeed-testing" +Requires-Dist: pytest-asyncio>=1.2.0; extra == "deepspeed-testing" +Requires-Dist: pytest-random-order; extra == "deepspeed-testing" +Requires-Dist: pytest-rich; extra == "deepspeed-testing" +Requires-Dist: pytest-xdist; extra == "deepspeed-testing" +Requires-Dist: pytest-order; extra == "deepspeed-testing" +Requires-Dist: pytest-rerunfailures<16.0; extra == "deepspeed-testing" +Requires-Dist: pytest-timeout; extra == "deepspeed-testing" +Requires-Dist: pytest-env; extra == "deepspeed-testing" +Requires-Dist: timeout-decorator; extra == "deepspeed-testing" +Requires-Dist: parameterized>=0.9; extra == "deepspeed-testing" +Requires-Dist: psutil; extra == "deepspeed-testing" +Requires-Dist: dill<0.3.5; extra == "deepspeed-testing" +Requires-Dist: evaluate>=0.4.6; extra == "deepspeed-testing" +Requires-Dist: rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1; extra == "deepspeed-testing" +Requires-Dist: nltk<=3.8.1; extra == "deepspeed-testing" +Requires-Dist: sacremoses; extra == "deepspeed-testing" +Requires-Dist: rjieba; extra == "deepspeed-testing" +Requires-Dist: beautifulsoup4; extra == "deepspeed-testing" +Requires-Dist: tensorboard; extra == "deepspeed-testing" +Requires-Dist: sacrebleu<2.0.0,>=1.4.12; extra == "deepspeed-testing" +Requires-Dist: filelock; extra == "deepspeed-testing" +Requires-Dist: datasets>=2.15.0; extra == "deepspeed-testing" +Requires-Dist: ruff==0.14.10; extra == "deepspeed-testing" +Requires-Dist: GitPython<3.1.19; extra == "deepspeed-testing" +Requires-Dist: urllib3<2.0.0; extra == "deepspeed-testing" +Requires-Dist: libcst; extra == "deepspeed-testing" +Requires-Dist: rich; extra == "deepspeed-testing" +Requires-Dist: faiss-cpu; extra == "deepspeed-testing" +Requires-Dist: datasets>=2.15.0; extra == "deepspeed-testing" +Requires-Dist: sentencepiece!=0.1.92,>=0.1.91; extra == "deepspeed-testing" +Requires-Dist: protobuf; extra == "deepspeed-testing" +Requires-Dist: openai>=1.98.0; extra == "deepspeed-testing" +Requires-Dist: pydantic>=2; extra == "deepspeed-testing" +Requires-Dist: uvicorn; extra == "deepspeed-testing" +Requires-Dist: fastapi; extra == "deepspeed-testing" +Requires-Dist: starlette; extra == "deepspeed-testing" +Requires-Dist: rich; extra == "deepspeed-testing" +Requires-Dist: torch>=2.4; extra == "deepspeed-testing" +Requires-Dist: accelerate>=1.1.0; extra == "deepspeed-testing" +Requires-Dist: mistral-common[image]>=1.8.8; extra == "deepspeed-testing" +Requires-Dist: optuna; extra == "deepspeed-testing" +Requires-Dist: sentencepiece!=0.1.92,>=0.1.91; extra == "deepspeed-testing" +Requires-Dist: protobuf; extra == "deepspeed-testing" +Provides-Extra: all +Requires-Dist: torch>=2.4; extra == "all" +Requires-Dist: accelerate>=1.1.0; extra == "all" +Requires-Dist: torchvision; extra == "all" +Requires-Dist: Pillow<=15.0,>=10.0.1; extra == "all" +Requires-Dist: torchaudio; extra == "all" +Requires-Dist: librosa; extra == "all" +Requires-Dist: pyctcdecode>=0.4.0; extra == "all" +Requires-Dist: phonemizer; extra == "all" +Requires-Dist: av; extra == "all" +Requires-Dist: kernels<0.11,>=0.10.2; extra == "all" +Requires-Dist: timm>=1.0.23; extra == "all" +Requires-Dist: sentencepiece!=0.1.92,>=0.1.91; extra == "all" +Requires-Dist: protobuf; extra == "all" +Requires-Dist: tiktoken; extra == "all" +Requires-Dist: blobfile; extra == "all" +Requires-Dist: jinja2>=3.1.0; extra == "all" +Requires-Dist: jmespath>=1.0.1; extra == "all" +Requires-Dist: num2words; extra == "all" +Requires-Dist: mistral-common[image]>=1.8.8; extra == "all" +Provides-Extra: dev +Requires-Dist: torch>=2.4; extra == "dev" +Requires-Dist: accelerate>=1.1.0; extra == "dev" +Requires-Dist: torchvision; extra == "dev" +Requires-Dist: Pillow<=15.0,>=10.0.1; extra == "dev" +Requires-Dist: torchaudio; extra == "dev" +Requires-Dist: librosa; extra == "dev" +Requires-Dist: pyctcdecode>=0.4.0; extra == "dev" +Requires-Dist: phonemizer; extra == "dev" +Requires-Dist: av; extra == "dev" +Requires-Dist: kernels<0.11,>=0.10.2; extra == "dev" +Requires-Dist: timm>=1.0.23; extra == "dev" +Requires-Dist: sentencepiece!=0.1.92,>=0.1.91; extra == "dev" +Requires-Dist: protobuf; extra == "dev" +Requires-Dist: tiktoken; extra == "dev" +Requires-Dist: blobfile; extra == "dev" +Requires-Dist: jinja2>=3.1.0; extra == "dev" +Requires-Dist: jmespath>=1.0.1; extra == "dev" +Requires-Dist: num2words; extra == "dev" +Requires-Dist: mistral-common[image]>=1.8.8; extra == "dev" +Requires-Dist: pytest<9.0.0,>=7.2.0; extra == "dev" +Requires-Dist: pytest-asyncio>=1.2.0; extra == "dev" +Requires-Dist: pytest-random-order; extra == "dev" +Requires-Dist: pytest-rich; extra == "dev" +Requires-Dist: pytest-xdist; extra == "dev" +Requires-Dist: pytest-order; extra == "dev" +Requires-Dist: pytest-rerunfailures<16.0; extra == "dev" +Requires-Dist: pytest-timeout; extra == "dev" +Requires-Dist: pytest-env; extra == "dev" +Requires-Dist: timeout-decorator; extra == "dev" +Requires-Dist: parameterized>=0.9; extra == "dev" +Requires-Dist: psutil; extra == "dev" +Requires-Dist: dill<0.3.5; extra == "dev" +Requires-Dist: evaluate>=0.4.6; extra == "dev" +Requires-Dist: rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1; extra == "dev" +Requires-Dist: nltk<=3.8.1; extra == "dev" +Requires-Dist: sacremoses; extra == "dev" +Requires-Dist: rjieba; extra == "dev" +Requires-Dist: beautifulsoup4; extra == "dev" +Requires-Dist: tensorboard; extra == "dev" +Requires-Dist: sacrebleu<2.0.0,>=1.4.12; extra == "dev" +Requires-Dist: filelock; extra == "dev" +Requires-Dist: datasets>=2.15.0; extra == "dev" +Requires-Dist: ruff==0.14.10; extra == "dev" +Requires-Dist: GitPython<3.1.19; extra == "dev" +Requires-Dist: urllib3<2.0.0; extra == "dev" +Requires-Dist: libcst; extra == "dev" +Requires-Dist: rich; extra == "dev" +Requires-Dist: faiss-cpu; extra == "dev" +Requires-Dist: datasets>=2.15.0; extra == "dev" +Requires-Dist: sentencepiece!=0.1.92,>=0.1.91; extra == "dev" +Requires-Dist: protobuf; extra == "dev" +Requires-Dist: openai>=1.98.0; extra == "dev" +Requires-Dist: pydantic>=2; extra == "dev" +Requires-Dist: uvicorn; extra == "dev" +Requires-Dist: fastapi; extra == "dev" +Requires-Dist: starlette; extra == "dev" +Requires-Dist: rich; extra == "dev" +Requires-Dist: torch>=2.4; extra == "dev" +Requires-Dist: accelerate>=1.1.0; extra == "dev" +Requires-Dist: mistral-common[image]>=1.8.8; extra == "dev" +Requires-Dist: fugashi>=1.0; extra == "dev" +Requires-Dist: ipadic<2.0,>=1.0.0; extra == "dev" +Requires-Dist: unidic_lite>=1.0.7; extra == "dev" +Requires-Dist: unidic>=1.0.2; extra == "dev" +Requires-Dist: rhoknp<1.3.1,>=1.1.0; extra == "dev" +Requires-Dist: sudachipy>=0.6.6; extra == "dev" +Requires-Dist: sudachidict_core>=20220729; extra == "dev" +Requires-Dist: scikit-learn; extra == "dev" +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: keywords +Dynamic: license +Dynamic: license-file +Dynamic: provides-extra +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + + +

+ + + + Hugging Face Transformers Library + +
+
+

+ +

+ Checkpoints on Hub + Build + GitHub + Documentation + GitHub release + Contributor Covenant + DOI +

+ +

+

+ English | + 简体中文 | + 繁體中文 | + 한국어 | + Español | + 日本語 | + हिन्दी | + Русский | + Português | + తెలుగు | + Français | + Deutsch | + Italiano | + Tiếng Việt | + العربية | + اردو | + বাংলা | +

+

+ +

+

State-of-the-art pretrained models for inference and training

+

+ +

+ +

+ +Transformers acts as the model-definition framework for state-of-the-art machine learning with text, computer +vision, audio, video, and multimodal models, for both inference and training. + +It centralizes the model definition so that this definition is agreed upon across the ecosystem. `transformers` is the +pivot across frameworks: if a model definition is supported, it will be compatible with the majority of training +frameworks (Axolotl, Unsloth, DeepSpeed, FSDP, PyTorch-Lightning, ...), inference engines (vLLM, SGLang, TGI, ...), +and adjacent modeling libraries (llama.cpp, mlx, ...) which leverage the model definition from `transformers`. + +We pledge to help support new state-of-the-art models and democratize their usage by having their model definition be +simple, customizable, and efficient. + +There are over 1M+ Transformers [model checkpoints](https://huggingface.co/models?library=transformers&sort=trending) on the [Hugging Face Hub](https://huggingface.com/models) you can use. + +Explore the [Hub](https://huggingface.com/) today to find a model and use Transformers to help you get started right away. + +## Installation + +Transformers works with Python 3.10+, and [PyTorch](https://pytorch.org/get-started/locally/) 2.4+. + +Create and activate a virtual environment with [venv](https://docs.python.org/3/library/venv.html) or [uv](https://docs.astral.sh/uv/), a fast Rust-based Python package and project manager. + +```py +# venv +python -m venv .my-env +source .my-env/bin/activate +# uv +uv venv .my-env +source .my-env/bin/activate +``` + +Install Transformers in your virtual environment. + +```py +# pip +pip install "transformers[torch]" + +# uv +uv pip install "transformers[torch]" +``` + +Install Transformers from source if you want the latest changes in the library or are interested in contributing. However, the *latest* version may not be stable. Feel free to open an [issue](https://github.com/huggingface/transformers/issues) if you encounter an error. + +```shell +git clone https://github.com/huggingface/transformers.git +cd transformers + +# pip +pip install '.[torch]' + +# uv +uv pip install '.[torch]' +``` + +## Quickstart + +Get started with Transformers right away with the [Pipeline](https://huggingface.co/docs/transformers/pipeline_tutorial) API. The `Pipeline` is a high-level inference class that supports text, audio, vision, and multimodal tasks. It handles preprocessing the input and returns the appropriate output. + +Instantiate a pipeline and specify model to use for text generation. The model is downloaded and cached so you can easily reuse it again. Finally, pass some text to prompt the model. + +```py +from transformers import pipeline + +pipeline = pipeline(task="text-generation", model="Qwen/Qwen2.5-1.5B") +pipeline("the secret to baking a really good cake is ") +[{'generated_text': 'the secret to baking a really good cake is 1) to use the right ingredients and 2) to follow the recipe exactly. the recipe for the cake is as follows: 1 cup of sugar, 1 cup of flour, 1 cup of milk, 1 cup of butter, 1 cup of eggs, 1 cup of chocolate chips. if you want to make 2 cakes, how much sugar do you need? To make 2 cakes, you will need 2 cups of sugar.'}] +``` + +To chat with a model, the usage pattern is the same. The only difference is you need to construct a chat history (the input to `Pipeline`) between you and the system. + +> [!TIP] +> You can also chat with a model directly from the command line, as long as [`transformers serve` is running](https://huggingface.co/docs/transformers/main/en/serving). +> ```shell +> transformers chat Qwen/Qwen2.5-0.5B-Instruct +> ``` + +```py +import torch +from transformers import pipeline + +chat = [ + {"role": "system", "content": "You are a sassy, wise-cracking robot as imagined by Hollywood circa 1986."}, + {"role": "user", "content": "Hey, can you tell me any fun things to do in New York?"} +] + +pipeline = pipeline(task="text-generation", model="meta-llama/Meta-Llama-3-8B-Instruct", dtype=torch.bfloat16, device_map="auto") +response = pipeline(chat, max_new_tokens=512) +print(response[0]["generated_text"][-1]["content"]) +``` + +Expand the examples below to see how `Pipeline` works for different modalities and tasks. + +
+Automatic speech recognition + +```py +from transformers import pipeline + +pipeline = pipeline(task="automatic-speech-recognition", model="openai/whisper-large-v3") +pipeline("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac") +{'text': ' I have a dream that one day this nation will rise up and live out the true meaning of its creed.'} +``` + +
+ +
+Image classification + +

+ +

+ +```py +from transformers import pipeline + +pipeline = pipeline(task="image-classification", model="facebook/dinov2-small-imagenet1k-1-layer") +pipeline("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png") +[{'label': 'macaw', 'score': 0.997848391532898}, + {'label': 'sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita', + 'score': 0.0016551691805943847}, + {'label': 'lorikeet', 'score': 0.00018523589824326336}, + {'label': 'African grey, African gray, Psittacus erithacus', + 'score': 7.85409429227002e-05}, + {'label': 'quail', 'score': 5.502637941390276e-05}] +``` + +
+ +
+Visual question answering + +

+ +

+ +```py +from transformers import pipeline + +pipeline = pipeline(task="visual-question-answering", model="Salesforce/blip-vqa-base") +pipeline( + image="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/idefics-few-shot.jpg", + question="What is in the image?", +) +[{'answer': 'statue of liberty'}] +``` + +
+ +## Why should I use Transformers? + +1. Easy-to-use state-of-the-art models: + - High performance on natural language understanding & generation, computer vision, audio, video, and multimodal tasks. + - Low barrier to entry for researchers, engineers, and developers. + - Few user-facing abstractions with just three classes to learn. + - A unified API for using all our pretrained models. + +1. Lower compute costs, smaller carbon footprint: + - Share trained models instead of training from scratch. + - Reduce compute time and production costs. + - Dozens of model architectures with 1M+ pretrained checkpoints across all modalities. + +1. Choose the right framework for every part of a model's lifetime: + - Train state-of-the-art models in 3 lines of code. + - Move a single model between PyTorch/JAX/TF2.0 frameworks at will. + - Pick the right framework for training, evaluation, and production. + +1. Easily customize a model or an example to your needs: + - We provide examples for each architecture to reproduce the results published by its original authors. + - Model internals are exposed as consistently as possible. + - Model files can be used independently of the library for quick experiments. + + + Hugging Face Enterprise Hub +
+ +## Why shouldn't I use Transformers? + +- This library is not a modular toolbox of building blocks for neural nets. The code in the model files is not refactored with additional abstractions on purpose, so that researchers can quickly iterate on each of the models without diving into additional abstractions/files. +- The training API is optimized to work with PyTorch models provided by Transformers. For generic machine learning loops, you should use another library like [Accelerate](https://huggingface.co/docs/accelerate). +- The [example scripts](https://github.com/huggingface/transformers/tree/main/examples) are only *examples*. They may not necessarily work out-of-the-box on your specific use case and you'll need to adapt the code for it to work. + +## 100 projects using Transformers + +Transformers is more than a toolkit to use pretrained models, it's a community of projects built around it and the +Hugging Face Hub. We want Transformers to enable developers, researchers, students, professors, engineers, and anyone +else to build their dream projects. + +In order to celebrate Transformers 100,000 stars, we wanted to put the spotlight on the +community with the [awesome-transformers](./awesome-transformers.md) page which lists 100 +incredible projects built with Transformers. + +If you own or use a project that you believe should be part of the list, please open a PR to add it! + +## Example models + +You can test most of our models directly on their [Hub model pages](https://huggingface.co/models). + +Expand each modality below to see a few example models for various use cases. + +
+Audio + +- Audio classification with [CLAP](https://huggingface.co/laion/clap-htsat-fused) +- Automatic speech recognition with [Parakeet](https://huggingface.co/nvidia/parakeet-ctc-1.1b#transcribing-using-transformers-%F0%9F%A4%97), [Whisper](https://huggingface.co/openai/whisper-large-v3-turbo), [GLM-ASR](https://huggingface.co/zai-org/GLM-ASR-Nano-2512) and [Moonshine-Streaming](https://huggingface.co/UsefulSensors/moonshine-streaming-medium) +- Keyword spotting with [Wav2Vec2](https://huggingface.co/superb/wav2vec2-base-superb-ks) +- Speech to speech generation with [Moshi](https://huggingface.co/kyutai/moshiko-pytorch-bf16) +- Text to audio with [MusicGen](https://huggingface.co/facebook/musicgen-large) +- Text to speech with [CSM](https://huggingface.co/sesame/csm-1b) + +
+ +
+Computer vision + +- Automatic mask generation with [SAM](https://huggingface.co/facebook/sam-vit-base) +- Depth estimation with [DepthPro](https://huggingface.co/apple/DepthPro-hf) +- Image classification with [DINO v2](https://huggingface.co/facebook/dinov2-base) +- Keypoint detection with [SuperPoint](https://huggingface.co/magic-leap-community/superpoint) +- Keypoint matching with [SuperGlue](https://huggingface.co/magic-leap-community/superglue_outdoor) +- Object detection with [RT-DETRv2](https://huggingface.co/PekingU/rtdetr_v2_r50vd) +- Pose Estimation with [VitPose](https://huggingface.co/usyd-community/vitpose-base-simple) +- Universal segmentation with [OneFormer](https://huggingface.co/shi-labs/oneformer_ade20k_swin_large) +- Video classification with [VideoMAE](https://huggingface.co/MCG-NJU/videomae-large) + +
+ +
+Multimodal + +- Audio or text to text with [Voxtral](https://huggingface.co/mistralai/Voxtral-Mini-3B-2507), [Audio Flamingo](https://huggingface.co/nvidia/audio-flamingo-3-hf) +- Document question answering with [LayoutLMv3](https://huggingface.co/microsoft/layoutlmv3-base) +- Image or text to text with [Qwen-VL](https://huggingface.co/Qwen/Qwen2.5-VL-3B-Instruct) +- Image captioning [BLIP-2](https://huggingface.co/Salesforce/blip2-opt-2.7b) +- OCR-based document understanding with [GOT-OCR2](https://huggingface.co/stepfun-ai/GOT-OCR-2.0-hf) +- Table question answering with [TAPAS](https://huggingface.co/google/tapas-base) +- Unified multimodal understanding and generation with [Emu3](https://huggingface.co/BAAI/Emu3-Gen) +- Vision to text with [Llava-OneVision](https://huggingface.co/llava-hf/llava-onevision-qwen2-0.5b-ov-hf) +- Visual question answering with [Llava](https://huggingface.co/llava-hf/llava-1.5-7b-hf) +- Visual referring expression segmentation with [Kosmos-2](https://huggingface.co/microsoft/kosmos-2-patch14-224) + +
+ +
+NLP + +- Masked word completion with [ModernBERT](https://huggingface.co/answerdotai/ModernBERT-base) +- Named entity recognition with [Gemma](https://huggingface.co/google/gemma-2-2b) +- Question answering with [Mixtral](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1) +- Summarization with [BART](https://huggingface.co/facebook/bart-large-cnn) +- Translation with [T5](https://huggingface.co/google-t5/t5-base) +- Text generation with [Llama](https://huggingface.co/meta-llama/Llama-3.2-1B) +- Text classification with [Qwen](https://huggingface.co/Qwen/Qwen2.5-0.5B) + +
+ +## Citation + +We now have a [paper](https://www.aclweb.org/anthology/2020.emnlp-demos.6/) you can cite for the 🤗 Transformers library: +```bibtex +@inproceedings{wolf-etal-2020-transformers, + title = "Transformers: State-of-the-Art Natural Language Processing", + author = "Thomas Wolf and Lysandre Debut and Victor Sanh and Julien Chaumond and Clement Delangue and Anthony Moi and Pierric Cistac and Tim Rault and Rémi Louf and Morgan Funtowicz and Joe Davison and Sam Shleifer and Patrick von Platen and Clara Ma and Yacine Jernite and Julien Plu and Canwen Xu and Teven Le Scao and Sylvain Gugger and Mariama Drame and Quentin Lhoest and Alexander M. Rush", + booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations", + month = oct, + year = "2020", + address = "Online", + publisher = "Association for Computational Linguistics", + url = "https://www.aclweb.org/anthology/2020.emnlp-demos.6", + pages = "38--45" +} +``` diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/INSTALLER b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/METADATA b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..8fc14ea2b68c0df97b52da5802a44e0083973d26 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/METADATA @@ -0,0 +1,412 @@ +Metadata-Version: 2.4 +Name: typer +Version: 0.24.1 +Summary: Typer, build great CLIs. Easy to code. Based on Python type hints. +Author-Email: =?utf-8?q?Sebasti=C3=A1n_Ram=C3=ADrez?= +License-Expression: MIT +License-File: LICENSE +Classifier: Intended Audience :: Information Technology +Classifier: Intended Audience :: System Administrators +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python +Classifier: Topic :: Software Development :: Libraries :: Application Frameworks +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Software Development :: Libraries +Classifier: Topic :: Software Development +Classifier: Typing :: Typed +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Project-URL: Homepage, https://github.com/fastapi/typer +Project-URL: Documentation, https://typer.tiangolo.com +Project-URL: Repository, https://github.com/fastapi/typer +Project-URL: Issues, https://github.com/fastapi/typer/issues +Project-URL: Changelog, https://typer.tiangolo.com/release-notes/ +Requires-Python: >=3.10 +Requires-Dist: click>=8.2.1 +Requires-Dist: shellingham>=1.3.0 +Requires-Dist: rich>=12.3.0 +Requires-Dist: annotated-doc>=0.0.2 +Description-Content-Type: text/markdown + +

+ Typer + +

+

+ Typer, build great CLIs. Easy to code. Based on Python type hints. +

+

+ + Test + + + Publish + + + Coverage + + Package version + +

+ +--- + +**Documentation**: https://typer.tiangolo.com + +**Source Code**: https://github.com/fastapi/typer + +--- + +Typer is a library for building CLI applications that users will **love using** and developers will **love creating**. Based on Python type hints. + +It's also a command line tool to run scripts, automatically converting them to CLI applications. + +The key features are: + +* **Intuitive to write**: Great editor support. Completion everywhere. Less time debugging. Designed to be easy to use and learn. Less time reading docs. +* **Easy to use**: It's easy to use for the final users. Automatic help, and automatic completion for all shells. +* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs. +* **Start simple**: The simplest example adds only 2 lines of code to your app: **1 import, 1 function call**. +* **Grow large**: Grow in complexity as much as you want, create arbitrarily complex trees of commands and groups of subcommands, with options and arguments. +* **Run scripts**: Typer includes a `typer` command/program that you can use to run scripts, automatically converting them to CLIs, even if they don't use Typer internally. + +## 2026 February - Typer developer survey + +Help us define Typer's future by filling the Typer developer survey. ✨ + +## FastAPI of CLIs + +**Typer** is FastAPI's little sibling, it's the FastAPI of CLIs. + +## Installation + +Create and activate a virtual environment and then install **Typer**: + +
+ +```console +$ pip install typer +---> 100% +Successfully installed typer rich shellingham +``` + +
+ +## Example + +### The absolute minimum + +* Create a file `main.py` with: + +```Python +def main(name: str): + print(f"Hello {name}") +``` + +This script doesn't even use Typer internally. But you can use the `typer` command to run it as a CLI application. + +### Run it + +Run your application with the `typer` command: + +
+ +```console +// Run your application +$ typer main.py run + +// You get a nice error, you are missing NAME +Usage: typer [PATH_OR_MODULE] run [OPTIONS] NAME +Try 'typer [PATH_OR_MODULE] run --help' for help. +╭─ Error ───────────────────────────────────────────╮ +│ Missing argument 'NAME'. │ +╰───────────────────────────────────────────────────╯ + + +// You get a --help for free +$ typer main.py run --help + +Usage: typer [PATH_OR_MODULE] run [OPTIONS] NAME + +Run the provided Typer app. + +╭─ Arguments ───────────────────────────────────────╮ +│ * name TEXT [default: None] [required] | +╰───────────────────────────────────────────────────╯ +╭─ Options ─────────────────────────────────────────╮ +│ --help Show this message and exit. │ +╰───────────────────────────────────────────────────╯ + +// Now pass the NAME argument +$ typer main.py run Camila + +Hello Camila + +// It works! 🎉 +``` + +
+ +This is the simplest use case, not even using Typer internally, but it can already be quite useful for simple scripts. + +**Note**: auto-completion works when you create a Python package and run it with `--install-completion` or when you use the `typer` command. + +## Use Typer in your code + +Now let's start using Typer in your own code, update `main.py` with: + +```Python +import typer + + +def main(name: str): + print(f"Hello {name}") + + +if __name__ == "__main__": + typer.run(main) +``` + +Now you could run it with Python directly: + +
+ +```console +// Run your application +$ python main.py + +// You get a nice error, you are missing NAME +Usage: main.py [OPTIONS] NAME +Try 'main.py --help' for help. +╭─ Error ───────────────────────────────────────────╮ +│ Missing argument 'NAME'. │ +╰───────────────────────────────────────────────────╯ + + +// You get a --help for free +$ python main.py --help + +Usage: main.py [OPTIONS] NAME + +╭─ Arguments ───────────────────────────────────────╮ +│ * name TEXT [default: None] [required] | +╰───────────────────────────────────────────────────╯ +╭─ Options ─────────────────────────────────────────╮ +│ --help Show this message and exit. │ +╰───────────────────────────────────────────────────╯ + +// Now pass the NAME argument +$ python main.py Camila + +Hello Camila + +// It works! 🎉 +``` + +
+ +**Note**: you can also call this same script with the `typer` command, but you don't need to. + +## Example upgrade + +This was the simplest example possible. + +Now let's see one a bit more complex. + +### An example with two subcommands + +Modify the file `main.py`. + +Create a `typer.Typer()` app, and create two subcommands with their parameters. + +```Python hl_lines="3 6 11 20" +import typer + +app = typer.Typer() + + +@app.command() +def hello(name: str): + print(f"Hello {name}") + + +@app.command() +def goodbye(name: str, formal: bool = False): + if formal: + print(f"Goodbye Ms. {name}. Have a good day.") + else: + print(f"Bye {name}!") + + +if __name__ == "__main__": + app() +``` + +And that will: + +* Explicitly create a `typer.Typer` app. + * The previous `typer.run` actually creates one implicitly for you. +* Add two subcommands with `@app.command()`. +* Execute the `app()` itself, as if it was a function (instead of `typer.run`). + +### Run the upgraded example + +Check the new help: + +
+ +```console +$ python main.py --help + + Usage: main.py [OPTIONS] COMMAND [ARGS]... + +╭─ Options ─────────────────────────────────────────╮ +│ --install-completion Install completion │ +│ for the current │ +│ shell. │ +│ --show-completion Show completion for │ +│ the current shell, │ +│ to copy it or │ +│ customize the │ +│ installation. │ +│ --help Show this message │ +│ and exit. │ +╰───────────────────────────────────────────────────╯ +╭─ Commands ────────────────────────────────────────╮ +│ goodbye │ +│ hello │ +╰───────────────────────────────────────────────────╯ + +// When you create a package you get ✨ auto-completion ✨ for free, installed with --install-completion + +// You have 2 subcommands (the 2 functions): goodbye and hello +``` + +
+ +Now check the help for the `hello` command: + +
+ +```console +$ python main.py hello --help + + Usage: main.py hello [OPTIONS] NAME + +╭─ Arguments ───────────────────────────────────────╮ +│ * name TEXT [default: None] [required] │ +╰───────────────────────────────────────────────────╯ +╭─ Options ─────────────────────────────────────────╮ +│ --help Show this message and exit. │ +╰───────────────────────────────────────────────────╯ +``` + +
+ +And now check the help for the `goodbye` command: + +
+ +```console +$ python main.py goodbye --help + + Usage: main.py goodbye [OPTIONS] NAME + +╭─ Arguments ───────────────────────────────────────╮ +│ * name TEXT [default: None] [required] │ +╰───────────────────────────────────────────────────╯ +╭─ Options ─────────────────────────────────────────╮ +│ --formal --no-formal [default: no-formal] │ +│ --help Show this message │ +│ and exit. │ +╰───────────────────────────────────────────────────╯ + +// Automatic --formal and --no-formal for the bool option 🎉 +``` + +
+ +Now you can try out the new command line application: + +
+ +```console +// Use it with the hello command + +$ python main.py hello Camila + +Hello Camila + +// And with the goodbye command + +$ python main.py goodbye Camila + +Bye Camila! + +// And with --formal + +$ python main.py goodbye --formal Camila + +Goodbye Ms. Camila. Have a good day. +``` + +
+ +**Note**: If your app only has one command, by default the command name is **omitted** in usage: `python main.py Camila`. However, when there are multiple commands, you must **explicitly include the command name**: `python main.py hello Camila`. See [One or Multiple Commands](https://typer.tiangolo.com/tutorial/commands/one-or-multiple/) for more details. + +### Recap + +In summary, you declare **once** the types of parameters (*CLI arguments* and *CLI options*) as function parameters. + +You do that with standard modern Python types. + +You don't have to learn a new syntax, the methods or classes of a specific library, etc. + +Just standard **Python**. + +For example, for an `int`: + +```Python +total: int +``` + +or for a `bool` flag: + +```Python +force: bool +``` + +And similarly for **files**, **paths**, **enums** (choices), etc. And there are tools to create **groups of subcommands**, add metadata, extra **validation**, etc. + +**You get**: great editor support, including **completion** and **type checks** everywhere. + +**Your users get**: automatic **`--help`**, **auto-completion** in their terminal (Bash, Zsh, Fish, PowerShell) when they install your package or when using the `typer` command. + +For a more complete example including more features, see the Tutorial - User Guide. + +## Dependencies + +**Typer** stands on the shoulders of giants. It has three required dependencies: + +* Click: a popular tool for building CLIs in Python. Typer is based on it. +* rich: to show nicely formatted errors automatically. +* shellingham: to automatically detect the current shell when installing completion. + +### `typer-slim` + +There used to be a slimmed-down version of Typer called `typer-slim`, which didn't include the dependencies `rich` and `shellingham`, nor the `typer` command. + +However, since version 0.22.0, we have stopped supporting this, and `typer-slim` now simply installs (all of) Typer. + +If you want to disable Rich globally, you can set an environmental variable `TYPER_USE_RICH` to `False` or `0`. + +## License + +This project is licensed under the terms of the MIT license. diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/RECORD b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..a10ad524dd547b2cc1d7a070fba0f3abbd11ca3c --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/RECORD @@ -0,0 +1,40 @@ +../../Scripts/typer.exe,sha256=VCNhqRQo0rDFgUnE60jLa_tVKJ2-kqhwH-UVdhkevKY,108372 +typer-0.24.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +typer-0.24.1.dist-info/METADATA,sha256=V4OWoWjBhPNcoIaOxhr1cszo69nePKOHMRXERkMscKs,16057 +typer-0.24.1.dist-info/RECORD,, +typer-0.24.1.dist-info/WHEEL,sha256=Wb0ASbVj8JvWHpOiIpPi7ucfIgJeCi__PzivviEAQFc,90 +typer-0.24.1.dist-info/entry_points.txt,sha256=YO13ByiqWeuas9V0JADLUARZFUe_cwU_7wmTNvxBYQ8,57 +typer-0.24.1.dist-info/licenses/LICENSE,sha256=WJks68-N-25AxOIRLtEhJsJDZm3KORKj14t-ysSFnUk,1086 +typer/__init__.py,sha256=WOelHJu4PW0hk9nfjEX0Qxssb58NCh1km_Xq5LY_33s,1596 +typer/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30 +typer/__pycache__/__init__.cpython-312.pyc,, +typer/__pycache__/__main__.cpython-312.pyc,, +typer/__pycache__/_completion_classes.cpython-312.pyc,, +typer/__pycache__/_completion_shared.cpython-312.pyc,, +typer/__pycache__/_types.cpython-312.pyc,, +typer/__pycache__/_typing.cpython-312.pyc,, +typer/__pycache__/cli.cpython-312.pyc,, +typer/__pycache__/colors.cpython-312.pyc,, +typer/__pycache__/completion.cpython-312.pyc,, +typer/__pycache__/core.cpython-312.pyc,, +typer/__pycache__/main.cpython-312.pyc,, +typer/__pycache__/models.cpython-312.pyc,, +typer/__pycache__/params.cpython-312.pyc,, +typer/__pycache__/rich_utils.cpython-312.pyc,, +typer/__pycache__/testing.cpython-312.pyc,, +typer/__pycache__/utils.cpython-312.pyc,, +typer/_completion_classes.py,sha256=R9v4D8pJ_-n8fLOuyxrRSu7sP5lpXIy5fsLUW8zwsDU,7039 +typer/_completion_shared.py,sha256=-uhCUIMc2S1ywdB-fBSSccH70mIBEsVTxHomcmy-klE,9129 +typer/_types.py,sha256=0lcBDLcsxqr1sxTsqObj_u0Dfa37lWJYUY4PNkX4QlA,974 +typer/_typing.py,sha256=QOw5o-B2L--C3ly2DQH6aUwag6x5brV5FhVaBZ5gzMg,1727 +typer/cli.py,sha256=icRbazvdRdbYeaidPZOmJDOzrP3RAa7vj2INVV9Zb8Q,10183 +typer/colors.py,sha256=e42j8uB520hLpX5C_0fiR3OOoIFMbhO3ADZvv6hlAV8,430 +typer/completion.py,sha256=FRTR9hP_IPdJp-4GXPOq0btXo5SvgAtLVfS3ZkAMpgQ,4793 +typer/core.py,sha256=O5NywSwHPyYbLhZkPYSfwIj7Za2hPnoPP4xPXRa97a0,27947 +typer/main.py,sha256=xyNex-QfGUi-enu9j9rl-_wofApxs5VwdpCthAUAAkk,69005 +typer/models.py,sha256=OwPG3MAXiUD5ih3p8eNVciXUsL07UIJfNWy3JiNpDfg,19843 +typer/params.py,sha256=AovViRtl-VvUIXnmKKpnxoWK9_gHUbyQgXxxv3h_7lI,59713 +typer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +typer/rich_utils.py,sha256=RTyeoxwz16ZZXYbwoEixB_LSEnqpoStG_TGCRTz6zFQ,25424 +typer/testing.py,sha256=-ovLNjUNNEFCJoau-41iTJIobsjPbqyTrRq7-8ac4z4,871 +typer/utils.py,sha256=wnJ1DWXBFMnxLHaMN_HDYntxLRby0K-rux63aokHInI,7599 diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/WHEEL b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..18c430c1f6411c0532096b13de4384ab50a79abd --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: pdm-backend (2.4.7) +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/entry_points.txt b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..ca44c05a071b87fe02a3724bd895838305fe4e5d --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer-0.24.1.dist-info/entry_points.txt @@ -0,0 +1,5 @@ +[console_scripts] +typer = typer.cli:main + +[gui_scripts] + diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/__init__.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cb0921c06c9c0eddcb32ef016236ea98c2a42375 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/__init__.py @@ -0,0 +1,39 @@ +"""Typer, build great CLIs. Easy to code. Based on Python type hints.""" + +__version__ = "0.24.1" + +from shutil import get_terminal_size as get_terminal_size + +from click.exceptions import Abort as Abort +from click.exceptions import BadParameter as BadParameter +from click.exceptions import Exit as Exit +from click.termui import clear as clear +from click.termui import confirm as confirm +from click.termui import echo_via_pager as echo_via_pager +from click.termui import edit as edit +from click.termui import getchar as getchar +from click.termui import pause as pause +from click.termui import progressbar as progressbar +from click.termui import prompt as prompt +from click.termui import secho as secho +from click.termui import style as style +from click.termui import unstyle as unstyle +from click.utils import echo as echo +from click.utils import format_filename as format_filename +from click.utils import get_app_dir as get_app_dir +from click.utils import get_binary_stream as get_binary_stream +from click.utils import get_text_stream as get_text_stream +from click.utils import open_file as open_file + +from . import colors as colors +from .main import Typer as Typer +from .main import launch as launch +from .main import run as run +from .models import CallbackParam as CallbackParam +from .models import Context as Context +from .models import FileBinaryRead as FileBinaryRead +from .models import FileBinaryWrite as FileBinaryWrite +from .models import FileText as FileText +from .models import FileTextWrite as FileTextWrite +from .params import Argument as Argument +from .params import Option as Option diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/__main__.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..4e28416e104515e90fca4b69cc60d0c61fd15d61 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/__main__.py @@ -0,0 +1,3 @@ +from .cli import main + +main() diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/_completion_classes.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/_completion_classes.py new file mode 100644 index 0000000000000000000000000000000000000000..8548fb4d6a3e2e274811b0935276e1c0e6f2a9a0 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/_completion_classes.py @@ -0,0 +1,199 @@ +import importlib.util +import os +import re +import sys +from typing import Any + +import click +import click.parser +import click.shell_completion +from click.shell_completion import split_arg_string as click_split_arg_string + +from ._completion_shared import ( + COMPLETION_SCRIPT_BASH, + COMPLETION_SCRIPT_FISH, + COMPLETION_SCRIPT_POWER_SHELL, + COMPLETION_SCRIPT_ZSH, + Shells, +) + + +def _sanitize_help_text(text: str) -> str: + """Sanitizes the help text by removing rich tags""" + if not importlib.util.find_spec("rich"): + return text + from . import rich_utils + + return rich_utils.rich_render_text(text) + + +class BashComplete(click.shell_completion.BashComplete): + name = Shells.bash.value + source_template = COMPLETION_SCRIPT_BASH + + def source_vars(self) -> dict[str, Any]: + return { + "complete_func": self.func_name, + "autocomplete_var": self.complete_var, + "prog_name": self.prog_name, + } + + def get_completion_args(self) -> tuple[list[str], str]: + cwords = click_split_arg_string(os.environ["COMP_WORDS"]) + cword = int(os.environ["COMP_CWORD"]) + args = cwords[1:cword] + + try: + incomplete = cwords[cword] + except IndexError: + incomplete = "" + + return args, incomplete + + def format_completion(self, item: click.shell_completion.CompletionItem) -> str: + # TODO: Explore replicating the new behavior from Click, with item types and + # triggering completion for files and directories + # return f"{item.type},{item.value}" + return f"{item.value}" + + def complete(self) -> str: + args, incomplete = self.get_completion_args() + completions = self.get_completions(args, incomplete) + out = [self.format_completion(item) for item in completions] + return "\n".join(out) + + +class ZshComplete(click.shell_completion.ZshComplete): + name = Shells.zsh.value + source_template = COMPLETION_SCRIPT_ZSH + + def source_vars(self) -> dict[str, Any]: + return { + "complete_func": self.func_name, + "autocomplete_var": self.complete_var, + "prog_name": self.prog_name, + } + + def get_completion_args(self) -> tuple[list[str], str]: + completion_args = os.getenv("_TYPER_COMPLETE_ARGS", "") + cwords = click_split_arg_string(completion_args) + args = cwords[1:] + if args and not completion_args.endswith(" "): + incomplete = args[-1] + args = args[:-1] + else: + incomplete = "" + return args, incomplete + + def format_completion(self, item: click.shell_completion.CompletionItem) -> str: + def escape(s: str) -> str: + return ( + s.replace('"', '""') + .replace("'", "''") + .replace("$", "\\$") + .replace("`", "\\`") + .replace(":", r"\\:") + ) + + # TODO: Explore replicating the new behavior from Click, pay attention to + # the difference with and without escape + # return f"{item.type}\n{item.value}\n{item.help if item.help else '_'}" + if item.help: + return f'"{escape(item.value)}":"{_sanitize_help_text(escape(item.help))}"' + else: + return f'"{escape(item.value)}"' + + def complete(self) -> str: + args, incomplete = self.get_completion_args() + completions = self.get_completions(args, incomplete) + res = [self.format_completion(item) for item in completions] + if res: + args_str = "\n".join(res) + return f"_arguments '*: :(({args_str}))'" + else: + return "_files" + + +class FishComplete(click.shell_completion.FishComplete): + name = Shells.fish.value + source_template = COMPLETION_SCRIPT_FISH + + def source_vars(self) -> dict[str, Any]: + return { + "complete_func": self.func_name, + "autocomplete_var": self.complete_var, + "prog_name": self.prog_name, + } + + def get_completion_args(self) -> tuple[list[str], str]: + completion_args = os.getenv("_TYPER_COMPLETE_ARGS", "") + cwords = click_split_arg_string(completion_args) + args = cwords[1:] + if args and not completion_args.endswith(" "): + incomplete = args[-1] + args = args[:-1] + else: + incomplete = "" + return args, incomplete + + def format_completion(self, item: click.shell_completion.CompletionItem) -> str: + # TODO: Explore replicating the new behavior from Click, pay attention to + # the difference with and without formatted help + # if item.help: + # return f"{item.type},{item.value}\t{item.help}" + + # return f"{item.type},{item.value} + if item.help: + formatted_help = re.sub(r"\s", " ", item.help) + return f"{item.value}\t{_sanitize_help_text(formatted_help)}" + else: + return f"{item.value}" + + def complete(self) -> str: + complete_action = os.getenv("_TYPER_COMPLETE_FISH_ACTION", "") + args, incomplete = self.get_completion_args() + completions = self.get_completions(args, incomplete) + show_args = [self.format_completion(item) for item in completions] + if complete_action == "get-args": + if show_args: + return "\n".join(show_args) + elif complete_action == "is-args": + if show_args: + # Activate complete args (no files) + sys.exit(0) + else: + # Deactivate complete args (allow files) + sys.exit(1) + return "" # pragma: no cover + + +class PowerShellComplete(click.shell_completion.ShellComplete): + name = Shells.powershell.value + source_template = COMPLETION_SCRIPT_POWER_SHELL + + def source_vars(self) -> dict[str, Any]: + return { + "complete_func": self.func_name, + "autocomplete_var": self.complete_var, + "prog_name": self.prog_name, + } + + def get_completion_args(self) -> tuple[list[str], str]: + completion_args = os.getenv("_TYPER_COMPLETE_ARGS", "") + incomplete = os.getenv("_TYPER_COMPLETE_WORD_TO_COMPLETE", "") + cwords = click_split_arg_string(completion_args) + args = cwords[1:-1] if incomplete else cwords[1:] + return args, incomplete + + def format_completion(self, item: click.shell_completion.CompletionItem) -> str: + return f"{item.value}:::{_sanitize_help_text(item.help) if item.help else ' '}" + + +def completion_init() -> None: + click.shell_completion.add_completion_class(BashComplete, Shells.bash.value) + click.shell_completion.add_completion_class(ZshComplete, Shells.zsh.value) + click.shell_completion.add_completion_class(FishComplete, Shells.fish.value) + click.shell_completion.add_completion_class( + PowerShellComplete, Shells.powershell.value + ) + click.shell_completion.add_completion_class(PowerShellComplete, Shells.pwsh.value) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/_completion_shared.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/_completion_shared.py new file mode 100644 index 0000000000000000000000000000000000000000..5a81dcf68cddda410becd393e5cf0d7e9e83042e --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/_completion_shared.py @@ -0,0 +1,252 @@ +import os +import re +import subprocess +from enum import Enum +from pathlib import Path + +import click +import shellingham + + +class Shells(str, Enum): + bash = "bash" + zsh = "zsh" + fish = "fish" + powershell = "powershell" + pwsh = "pwsh" + + +COMPLETION_SCRIPT_BASH = """ +%(complete_func)s() { + local IFS=$'\n' + COMPREPLY=( $( env COMP_WORDS="${COMP_WORDS[*]}" \\ + COMP_CWORD=$COMP_CWORD \\ + %(autocomplete_var)s=complete_bash $1 ) ) + return 0 +} + +complete -o default -F %(complete_func)s %(prog_name)s +""" + +COMPLETION_SCRIPT_ZSH = """ +#compdef %(prog_name)s + +%(complete_func)s() { + eval $(env _TYPER_COMPLETE_ARGS="${words[1,$CURRENT]}" %(autocomplete_var)s=complete_zsh %(prog_name)s) +} + +compdef %(complete_func)s %(prog_name)s +""" + +COMPLETION_SCRIPT_FISH = 'complete --command %(prog_name)s --no-files --arguments "(env %(autocomplete_var)s=complete_fish _TYPER_COMPLETE_FISH_ACTION=get-args _TYPER_COMPLETE_ARGS=(commandline -cp) %(prog_name)s)" --condition "env %(autocomplete_var)s=complete_fish _TYPER_COMPLETE_FISH_ACTION=is-args _TYPER_COMPLETE_ARGS=(commandline -cp) %(prog_name)s"' + +COMPLETION_SCRIPT_POWER_SHELL = """ +Import-Module PSReadLine +Set-PSReadLineKeyHandler -Chord Tab -Function MenuComplete +$scriptblock = { + param($wordToComplete, $commandAst, $cursorPosition) + $Env:%(autocomplete_var)s = "complete_powershell" + $Env:_TYPER_COMPLETE_ARGS = $commandAst.ToString() + $Env:_TYPER_COMPLETE_WORD_TO_COMPLETE = $wordToComplete + %(prog_name)s | ForEach-Object { + $commandArray = $_ -Split ":::" + $command = $commandArray[0] + $helpString = $commandArray[1] + [System.Management.Automation.CompletionResult]::new( + $command, $command, 'ParameterValue', $helpString) + } + $Env:%(autocomplete_var)s = "" + $Env:_TYPER_COMPLETE_ARGS = "" + $Env:_TYPER_COMPLETE_WORD_TO_COMPLETE = "" +} +Register-ArgumentCompleter -Native -CommandName %(prog_name)s -ScriptBlock $scriptblock +""" + +_completion_scripts = { + "bash": COMPLETION_SCRIPT_BASH, + "zsh": COMPLETION_SCRIPT_ZSH, + "fish": COMPLETION_SCRIPT_FISH, + "powershell": COMPLETION_SCRIPT_POWER_SHELL, + "pwsh": COMPLETION_SCRIPT_POWER_SHELL, +} + +# TODO: Probably refactor this, copied from Click 7.x +_invalid_ident_char_re = re.compile(r"[^a-zA-Z0-9_]") + + +def get_completion_script(*, prog_name: str, complete_var: str, shell: str) -> str: + cf_name = _invalid_ident_char_re.sub("", prog_name.replace("-", "_")) + script = _completion_scripts.get(shell) + if script is None: + click.echo(f"Shell {shell} not supported.", err=True) + raise click.exceptions.Exit(1) + return ( + script + % { + "complete_func": f"_{cf_name}_completion", + "prog_name": prog_name, + "autocomplete_var": complete_var, + } + ).strip() + + +def install_bash(*, prog_name: str, complete_var: str, shell: str) -> Path: + # Ref: https://github.com/scop/bash-completion#faq + # It seems bash-completion is the official completion system for bash: + # Ref: https://www.gnu.org/software/bash/manual/html_node/A-Programmable-Completion-Example.html + # But installing in the locations from the docs doesn't seem to have effect + completion_path = Path.home() / ".bash_completions" / f"{prog_name}.sh" + rc_path = Path.home() / ".bashrc" + rc_path.parent.mkdir(parents=True, exist_ok=True) + rc_content = "" + if rc_path.is_file(): + rc_content = rc_path.read_text() + completion_init_lines = [f"source '{completion_path}'"] + for line in completion_init_lines: + if line not in rc_content: # pragma: no cover + rc_content += f"\n{line}" + rc_content += "\n" + rc_path.write_text(rc_content) + # Install completion + completion_path.parent.mkdir(parents=True, exist_ok=True) + script_content = get_completion_script( + prog_name=prog_name, complete_var=complete_var, shell=shell + ) + completion_path.write_text(script_content) + return completion_path + + +def install_zsh(*, prog_name: str, complete_var: str, shell: str) -> Path: + # Setup Zsh and load ~/.zfunc + zshrc_path = Path.home() / ".zshrc" + zshrc_path.parent.mkdir(parents=True, exist_ok=True) + zshrc_content = "" + if zshrc_path.is_file(): + zshrc_content = zshrc_path.read_text() + completion_line = "fpath+=~/.zfunc; autoload -Uz compinit; compinit" + if completion_line not in zshrc_content: + zshrc_content += f"\n{completion_line}\n" + style_line = "zstyle ':completion:*' menu select" + # TODO: consider setting the style only for the current program + # style_line = f"zstyle ':completion:*:*:{prog_name}:*' menu select" + # Install zstyle completion config only if the user doesn't have a customization + if "zstyle" not in zshrc_content: + zshrc_content += f"\n{style_line}\n" + zshrc_content = f"{zshrc_content.strip()}\n" + zshrc_path.write_text(zshrc_content) + # Install completion under ~/.zfunc/ + path_obj = Path.home() / f".zfunc/_{prog_name}" + path_obj.parent.mkdir(parents=True, exist_ok=True) + script_content = get_completion_script( + prog_name=prog_name, complete_var=complete_var, shell=shell + ) + path_obj.write_text(script_content) + return path_obj + + +def install_fish(*, prog_name: str, complete_var: str, shell: str) -> Path: + path_obj = Path.home() / f".config/fish/completions/{prog_name}.fish" + parent_dir: Path = path_obj.parent + parent_dir.mkdir(parents=True, exist_ok=True) + script_content = get_completion_script( + prog_name=prog_name, complete_var=complete_var, shell=shell + ) + path_obj.write_text(f"{script_content}\n") + return path_obj + + +def install_powershell(*, prog_name: str, complete_var: str, shell: str) -> Path: + subprocess.run( + [ + shell, + "-Command", + "Set-ExecutionPolicy", + "Unrestricted", + "-Scope", + "CurrentUser", + ] + ) + result = subprocess.run( + [shell, "-NoProfile", "-Command", "echo", "$profile"], + check=True, + stdout=subprocess.PIPE, + ) + if result.returncode != 0: # pragma: no cover + click.echo("Couldn't get PowerShell user profile", err=True) + raise click.exceptions.Exit(result.returncode) + path_str = "" + if isinstance(result.stdout, str): # pragma: no cover + path_str = result.stdout + if isinstance(result.stdout, bytes): + for encoding in ["windows-1252", "utf8", "cp850"]: + try: + path_str = result.stdout.decode(encoding) + break + except UnicodeDecodeError: # pragma: no cover + pass + if not path_str: # pragma: no cover + click.echo("Couldn't decode the path automatically", err=True) + raise click.exceptions.Exit(1) + path_obj = Path(path_str.strip()) + parent_dir: Path = path_obj.parent + parent_dir.mkdir(parents=True, exist_ok=True) + script_content = get_completion_script( + prog_name=prog_name, complete_var=complete_var, shell=shell + ) + with path_obj.open(mode="a") as f: + f.write(f"{script_content}\n") + return path_obj + + +def install( + shell: str | None = None, + prog_name: str | None = None, + complete_var: str | None = None, +) -> tuple[str, Path]: + prog_name = prog_name or click.get_current_context().find_root().info_name + assert prog_name + if complete_var is None: + complete_var = "_{}_COMPLETE".format(prog_name.replace("-", "_").upper()) + test_disable_detection = os.getenv("_TYPER_COMPLETE_TEST_DISABLE_SHELL_DETECTION") + if shell is None and not test_disable_detection: + shell = _get_shell_name() + if shell == "bash": + installed_path = install_bash( + prog_name=prog_name, complete_var=complete_var, shell=shell + ) + return shell, installed_path + elif shell == "zsh": + installed_path = install_zsh( + prog_name=prog_name, complete_var=complete_var, shell=shell + ) + return shell, installed_path + elif shell == "fish": + installed_path = install_fish( + prog_name=prog_name, complete_var=complete_var, shell=shell + ) + return shell, installed_path + elif shell in {"powershell", "pwsh"}: + installed_path = install_powershell( + prog_name=prog_name, complete_var=complete_var, shell=shell + ) + return shell, installed_path + else: + click.echo(f"Shell {shell} is not supported.") + raise click.exceptions.Exit(1) + + +def _get_shell_name() -> str | None: + """Get the current shell name, if available. + + The name will always be lowercase. If the shell cannot be detected, None is + returned. + """ + name: str | None # N.B. shellingham is untyped + try: + # N.B. detect_shell returns a tuple of (shell name, shell command). + # We only need the name. + name, _cmd = shellingham.detect_shell() # noqa: TID251 + except shellingham.ShellDetectionFailure: # pragma: no cover + name = None + + return name diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/_types.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/_types.py new file mode 100644 index 0000000000000000000000000000000000000000..dc9fc63220d91b5c7ecc16170bb9de7afb135fb4 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/_types.py @@ -0,0 +1,27 @@ +from enum import Enum +from typing import TypeVar + +import click + +ParamTypeValue = TypeVar("ParamTypeValue") + + +class TyperChoice(click.Choice[ParamTypeValue]): + def normalize_choice( + self, choice: ParamTypeValue, ctx: click.Context | None + ) -> str: + # Click 8.2.0 added a new method `normalize_choice` to the `Choice` class + # to support enums, but it uses the enum names, while Typer has always used the + # enum values. + # This class overrides that method to maintain the previous behavior. + # In Click: + # normed_value = choice.name if isinstance(choice, Enum) else str(choice) + normed_value = str(choice.value) if isinstance(choice, Enum) else str(choice) + + if ctx is not None and ctx.token_normalize_func is not None: + normed_value = ctx.token_normalize_func(normed_value) + + if not self.case_sensitive: + normed_value = normed_value.casefold() + + return normed_value diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/_typing.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/_typing.py new file mode 100644 index 0000000000000000000000000000000000000000..218f674c2220589738656294fdd8ec243965376f --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/_typing.py @@ -0,0 +1,73 @@ +# Copied from pydantic 1.9.2 (the latest version to support python 3.6.) +# https://github.com/pydantic/pydantic/blob/v1.9.2/pydantic/typing.py +# Reduced drastically to only include Typer-specific 3.9+ functionality +# mypy: ignore-errors + +import types +from collections.abc import Callable +from typing import ( + Annotated, + Any, + Literal, + Union, + get_args, + get_origin, + get_type_hints, +) + + +def is_union(tp: type[Any] | None) -> bool: + return tp is Union or tp is types.UnionType # noqa: E721 + + +__all__ = ( + "NoneType", + "is_none_type", + "is_callable_type", + "is_literal_type", + "all_literal_values", + "is_union", + "Annotated", + "Literal", + "get_args", + "get_origin", + "get_type_hints", +) + + +NoneType = None.__class__ + + +NONE_TYPES: tuple[Any, Any, Any] = (None, NoneType, Literal[None]) + + +def is_none_type(type_: Any) -> bool: + for none_type in NONE_TYPES: + if type_ is none_type: + return True + return False + + +def is_callable_type(type_: type[Any]) -> bool: + return type_ is Callable or get_origin(type_) is Callable + + +def is_literal_type(type_: type[Any]) -> bool: + return get_origin(type_) is Literal + + +def literal_values(type_: type[Any]) -> tuple[Any, ...]: + return get_args(type_) + + +def all_literal_values(type_: type[Any]) -> tuple[Any, ...]: + """ + This method is used to retrieve all Literal values as + Literal can be used recursively (see https://www.python.org/dev/peps/pep-0586) + e.g. `Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]` + """ + if not is_literal_type(type_): + return (type_,) + + values = literal_values(type_) + return tuple(x for value in values for x in all_literal_values(value)) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/core.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/core.py new file mode 100644 index 0000000000000000000000000000000000000000..3e72d839893185826dfdc9e9d6d8006a279db48d --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/core.py @@ -0,0 +1,821 @@ +import errno +import inspect +import os +import sys +from collections.abc import Callable, MutableMapping, Sequence +from difflib import get_close_matches +from enum import Enum +from gettext import gettext as _ +from typing import ( + Any, + TextIO, + Union, + cast, +) + +import click +import click.core +import click.formatting +import click.shell_completion +import click.types +import click.utils + +from ._typing import Literal +from .utils import parse_boolean_env_var + +MarkupMode = Literal["markdown", "rich", None] +MARKUP_MODE_KEY = "TYPER_RICH_MARKUP_MODE" + +HAS_RICH = parse_boolean_env_var(os.getenv("TYPER_USE_RICH"), default=True) + +if HAS_RICH: + DEFAULT_MARKUP_MODE: MarkupMode = "rich" +else: + DEFAULT_MARKUP_MODE = None + + +# Copy from click.parser._split_opt +def _split_opt(opt: str) -> tuple[str, str]: + first = opt[:1] + if first.isalnum(): + return "", opt + if opt[1:2] == first: + return opt[:2], opt[2:] + return first, opt[1:] + + +def _typer_param_setup_autocompletion_compat( + self: click.Parameter, + *, + autocompletion: Callable[ + [click.Context, list[str], str], list[tuple[str, str] | str] + ] + | None = None, +) -> None: + if self._custom_shell_complete is not None: + import warnings + + warnings.warn( + "In Typer, only the parameter 'autocompletion' is supported. " + "The support for 'shell_complete' is deprecated and will be removed in upcoming versions. ", + DeprecationWarning, + stacklevel=2, + ) + + if autocompletion is not None: + + def compat_autocompletion( + ctx: click.Context, param: click.core.Parameter, incomplete: str + ) -> list["click.shell_completion.CompletionItem"]: + from click.shell_completion import CompletionItem + + out = [] + + for c in autocompletion(ctx, [], incomplete): + if isinstance(c, tuple): + use_completion = CompletionItem(c[0], help=c[1]) + else: + assert isinstance(c, str) + use_completion = CompletionItem(c) + + if use_completion.value.startswith(incomplete): + out.append(use_completion) + + return out + + self._custom_shell_complete = compat_autocompletion + + +def _get_default_string( + obj: Union["TyperArgument", "TyperOption"], + *, + ctx: click.Context, + show_default_is_str: bool, + default_value: list[Any] | tuple[Any, ...] | str | Callable[..., Any] | Any, +) -> str: + # Extracted from click.core.Option.get_help_record() to be reused by + # rich_utils avoiding RegEx hacks + if show_default_is_str: + default_string = f"({obj.show_default})" + elif isinstance(default_value, (list, tuple)): + default_string = ", ".join( + _get_default_string( + obj, ctx=ctx, show_default_is_str=show_default_is_str, default_value=d + ) + for d in default_value + ) + elif isinstance(default_value, Enum): + default_string = str(default_value.value) + elif inspect.isfunction(default_value): + default_string = _("(dynamic)") + elif isinstance(obj, TyperOption) and obj.is_bool_flag and obj.secondary_opts: + # For boolean flags that have distinct True/False opts, + # use the opt without prefix instead of the value. + # Typer override, original commented + # default_string = click.parser.split_opt( + # (self.opts if self.default else self.secondary_opts)[0] + # )[1] + if obj.default: + if obj.opts: + default_string = _split_opt(obj.opts[0])[1] + else: + default_string = str(default_value) + else: + default_string = _split_opt(obj.secondary_opts[0])[1] + # Typer override end + elif ( + isinstance(obj, TyperOption) + and obj.is_bool_flag + and not obj.secondary_opts + and not default_value + ): + default_string = "" + else: + default_string = str(default_value) + return default_string + + +def _extract_default_help_str( + obj: Union["TyperArgument", "TyperOption"], *, ctx: click.Context +) -> Any | Callable[[], Any] | None: + # Extracted from click.core.Option.get_help_record() to be reused by + # rich_utils avoiding RegEx hacks + # Temporarily enable resilient parsing to avoid type casting + # failing for the default. Might be possible to extend this to + # help formatting in general. + resilient = ctx.resilient_parsing + ctx.resilient_parsing = True + + try: + default_value = obj.get_default(ctx, call=False) + finally: + ctx.resilient_parsing = resilient + return default_value + + +def _main( + self: click.Command, + *, + args: Sequence[str] | None = None, + prog_name: str | None = None, + complete_var: str | None = None, + standalone_mode: bool = True, + windows_expand_args: bool = True, + rich_markup_mode: MarkupMode = DEFAULT_MARKUP_MODE, + **extra: Any, +) -> Any: + # Typer override, duplicated from click.main() to handle custom rich exceptions + # Verify that the environment is configured correctly, or reject + # further execution to avoid a broken script. + if args is None: + args = sys.argv[1:] + + # Covered in Click tests + if os.name == "nt" and windows_expand_args: # pragma: no cover + args = click.utils._expand_args(args) + else: + args = list(args) + + if prog_name is None: + prog_name = click.utils._detect_program_name() + + # Process shell completion requests and exit early. + self._main_shell_completion(extra, prog_name, complete_var) + + try: + try: + with self.make_context(prog_name, args, **extra) as ctx: + rv = self.invoke(ctx) + if not standalone_mode: + return rv + # it's not safe to `ctx.exit(rv)` here! + # note that `rv` may actually contain data like "1" which + # has obvious effects + # more subtle case: `rv=[None, None]` can come out of + # chained commands which all returned `None` -- so it's not + # even always obvious that `rv` indicates success/failure + # by its truthiness/falsiness + ctx.exit() + except EOFError as e: + click.echo(file=sys.stderr) + raise click.Abort() from e + except KeyboardInterrupt as e: + raise click.exceptions.Exit(130) from e + except click.ClickException as e: + if not standalone_mode: + raise + # Typer override + if HAS_RICH and rich_markup_mode is not None: + from . import rich_utils + + rich_utils.rich_format_error(e) + else: + e.show() + # Typer override end + sys.exit(e.exit_code) + except OSError as e: + if e.errno == errno.EPIPE: + sys.stdout = cast(TextIO, click.utils.PacifyFlushWrapper(sys.stdout)) + sys.stderr = cast(TextIO, click.utils.PacifyFlushWrapper(sys.stderr)) + sys.exit(1) + else: + raise + except click.exceptions.Exit as e: + if standalone_mode: + sys.exit(e.exit_code) + else: + # in non-standalone mode, return the exit code + # note that this is only reached if `self.invoke` above raises + # an Exit explicitly -- thus bypassing the check there which + # would return its result + # the results of non-standalone execution may therefore be + # somewhat ambiguous: if there are codepaths which lead to + # `ctx.exit(1)` and to `return 1`, the caller won't be able to + # tell the difference between the two + return e.exit_code + except click.Abort: + if not standalone_mode: + raise + # Typer override + if HAS_RICH and rich_markup_mode is not None: + from . import rich_utils + + rich_utils.rich_abort_error() + else: + click.echo(_("Aborted!"), file=sys.stderr) + # Typer override end + sys.exit(1) + + +class TyperArgument(click.core.Argument): + def __init__( + self, + *, + # Parameter + param_decls: list[str], + type: Any | None = None, + required: bool | None = None, + default: Any | None = None, + callback: Callable[..., Any] | None = None, + nargs: int | None = None, + metavar: str | None = None, + expose_value: bool = True, + is_eager: bool = False, + envvar: str | list[str] | None = None, + # Note that shell_complete is not fully supported and will be removed in future versions + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None = None, + autocompletion: Callable[..., Any] | None = None, + # TyperArgument + show_default: bool | str = True, + show_choices: bool = True, + show_envvar: bool = True, + help: str | None = None, + hidden: bool = False, + # Rich settings + rich_help_panel: str | None = None, + ): + self.help = help + self.show_default = show_default + self.show_choices = show_choices + self.show_envvar = show_envvar + self.hidden = hidden + self.rich_help_panel = rich_help_panel + + super().__init__( + param_decls=param_decls, + type=type, + required=required, + default=default, + callback=callback, + nargs=nargs, + metavar=metavar, + expose_value=expose_value, + is_eager=is_eager, + envvar=envvar, + shell_complete=shell_complete, + ) + _typer_param_setup_autocompletion_compat(self, autocompletion=autocompletion) + + def _get_default_string( + self, + *, + ctx: click.Context, + show_default_is_str: bool, + default_value: list[Any] | tuple[Any, ...] | str | Callable[..., Any] | Any, + ) -> str: + return _get_default_string( + self, + ctx=ctx, + show_default_is_str=show_default_is_str, + default_value=default_value, + ) + + def _extract_default_help_str( + self, *, ctx: click.Context + ) -> Any | Callable[[], Any] | None: + return _extract_default_help_str(self, ctx=ctx) + + def get_help_record(self, ctx: click.Context) -> tuple[str, str] | None: + # Modified version of click.core.Option.get_help_record() + # to support Arguments + if self.hidden: + return None + name = self.make_metavar(ctx=ctx) + help = self.help or "" + extra = [] + if self.show_envvar: + envvar = self.envvar + # allow_from_autoenv is currently not supported in Typer for CLI Arguments + if envvar is not None: + var_str = ( + ", ".join(str(d) for d in envvar) + if isinstance(envvar, (list, tuple)) + else envvar + ) + extra.append(f"env var: {var_str}") + + # Typer override: + # Extracted to _extract_default_help_str() to allow re-using it in rich_utils + default_value = self._extract_default_help_str(ctx=ctx) + # Typer override end + + show_default_is_str = isinstance(self.show_default, str) + + if show_default_is_str or ( + default_value is not None and (self.show_default or ctx.show_default) + ): + # Typer override: + # Extracted to _get_default_string() to allow re-using it in rich_utils + default_string = self._get_default_string( + ctx=ctx, + show_default_is_str=show_default_is_str, + default_value=default_value, + ) + # Typer override end + if default_string: + extra.append(_("default: {default}").format(default=default_string)) + if self.required: + extra.append(_("required")) + if extra: + extra_str = "; ".join(extra) + extra_str = f"[{extra_str}]" + rich_markup_mode = None + if hasattr(ctx, "obj") and isinstance(ctx.obj, dict): + rich_markup_mode = ctx.obj.get(MARKUP_MODE_KEY, None) + if HAS_RICH and rich_markup_mode == "rich": + # This is needed for when we want to export to HTML + from . import rich_utils + + extra_str = rich_utils.escape_before_html_export(extra_str) + + help = f"{help} {extra_str}" if help else f"{extra_str}" + return name, help + + def make_metavar(self, ctx: click.Context | None = None) -> str: + # Modified version of click.core.Argument.make_metavar() + # to include Argument name + if self.metavar is not None: + var = self.metavar + if not self.required and not var.startswith("["): + var = f"[{var}]" + return var + var = (self.name or "").upper() + if not self.required: + var = f"[{var}]" + type_var = self.type.get_metavar(self, ctx=ctx) # type: ignore[arg-type] + # type_var = self.type.get_metavar(self, ctx=ctx) + if type_var: + var += f":{type_var}" + if self.nargs != 1: + var += "..." + return var + + def value_is_missing(self, value: Any) -> bool: + return _value_is_missing(self, value) + + +class TyperOption(click.core.Option): + def __init__( + self, + *, + # Parameter + param_decls: list[str], + type: click.types.ParamType | Any | None = None, + required: bool | None = None, + default: Any | None = None, + callback: Callable[..., Any] | None = None, + nargs: int | None = None, + metavar: str | None = None, + expose_value: bool = True, + is_eager: bool = False, + envvar: str | list[str] | None = None, + # Note that shell_complete is not fully supported and will be removed in future versions + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None = None, + autocompletion: Callable[..., Any] | None = None, + # Option + show_default: bool | str = False, + prompt: bool | str = False, + confirmation_prompt: bool | str = False, + prompt_required: bool = True, + hide_input: bool = False, + is_flag: bool | None = None, + multiple: bool = False, + count: bool = False, + allow_from_autoenv: bool = True, + help: str | None = None, + hidden: bool = False, + show_choices: bool = True, + show_envvar: bool = False, + # Rich settings + rich_help_panel: str | None = None, + ): + super().__init__( + param_decls=param_decls, + type=type, + required=required, + default=default, + callback=callback, + nargs=nargs, + metavar=metavar, + expose_value=expose_value, + is_eager=is_eager, + envvar=envvar, + show_default=show_default, + prompt=prompt, + confirmation_prompt=confirmation_prompt, + hide_input=hide_input, + is_flag=is_flag, + multiple=multiple, + count=count, + allow_from_autoenv=allow_from_autoenv, + help=help, + hidden=hidden, + show_choices=show_choices, + show_envvar=show_envvar, + prompt_required=prompt_required, + shell_complete=shell_complete, + ) + _typer_param_setup_autocompletion_compat(self, autocompletion=autocompletion) + self.rich_help_panel = rich_help_panel + + def _get_default_string( + self, + *, + ctx: click.Context, + show_default_is_str: bool, + default_value: list[Any] | tuple[Any, ...] | str | Callable[..., Any] | Any, + ) -> str: + return _get_default_string( + self, + ctx=ctx, + show_default_is_str=show_default_is_str, + default_value=default_value, + ) + + def _extract_default_help_str( + self, *, ctx: click.Context + ) -> Any | Callable[[], Any] | None: + return _extract_default_help_str(self, ctx=ctx) + + def make_metavar(self, ctx: click.Context | None = None) -> str: + return super().make_metavar(ctx=ctx) # type: ignore[arg-type] + + def get_help_record(self, ctx: click.Context) -> tuple[str, str] | None: + # Duplicate all of Click's logic only to modify a single line, to allow boolean + # flags with only names for False values as it's currently supported by Typer + # Ref: https://typer.tiangolo.com/tutorial/parameter-types/bool/#only-names-for-false + if self.hidden: + return None + + any_prefix_is_slash = False + + def _write_opts(opts: Sequence[str]) -> str: + nonlocal any_prefix_is_slash + + rv, any_slashes = click.formatting.join_options(opts) + + if any_slashes: + any_prefix_is_slash = True + + if not self.is_flag and not self.count: + rv += f" {self.make_metavar(ctx=ctx)}" + + return rv + + rv = [_write_opts(self.opts)] + + if self.secondary_opts: + rv.append(_write_opts(self.secondary_opts)) + + help = self.help or "" + extra = [] + + if self.show_envvar: + envvar = self.envvar + + if envvar is None: + if ( + self.allow_from_autoenv + and ctx.auto_envvar_prefix is not None + and self.name is not None + ): + envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}" + + if envvar is not None: + var_str = ( + envvar + if isinstance(envvar, str) + else ", ".join(str(d) for d in envvar) + ) + extra.append(_("env var: {var}").format(var=var_str)) + + # Typer override: + # Extracted to _extract_default() to allow re-using it in rich_utils + default_value = self._extract_default_help_str(ctx=ctx) + # Typer override end + + show_default_is_str = isinstance(self.show_default, str) + + if show_default_is_str or ( + default_value is not None and (self.show_default or ctx.show_default) + ): + # Typer override: + # Extracted to _get_default_string() to allow re-using it in rich_utils + default_string = self._get_default_string( + ctx=ctx, + show_default_is_str=show_default_is_str, + default_value=default_value, + ) + # Typer override end + if default_string: + extra.append(_("default: {default}").format(default=default_string)) + + if isinstance(self.type, click.types._NumberRangeBase): + range_str = self.type._describe_range() + + if range_str: + extra.append(range_str) + + if self.required: + extra.append(_("required")) + + if extra: + extra_str = "; ".join(extra) + extra_str = f"[{extra_str}]" + rich_markup_mode = None + if hasattr(ctx, "obj") and isinstance(ctx.obj, dict): + rich_markup_mode = ctx.obj.get(MARKUP_MODE_KEY, None) + if HAS_RICH and rich_markup_mode == "rich": + # This is needed for when we want to export to HTML + from . import rich_utils + + extra_str = rich_utils.escape_before_html_export(extra_str) + + help = f"{help} {extra_str}" if help else f"{extra_str}" + + return ("; " if any_prefix_is_slash else " / ").join(rv), help + + def value_is_missing(self, value: Any) -> bool: + return _value_is_missing(self, value) + + +def _value_is_missing(param: click.Parameter, value: Any) -> bool: + if value is None: + return True + + # Click 8.3 and beyond + # if value is UNSET: + # return True + + if (param.nargs != 1 or param.multiple) and value == (): + return True # pragma: no cover + + return False + + +def _typer_format_options( + self: click.core.Command, *, ctx: click.Context, formatter: click.HelpFormatter +) -> None: + args = [] + opts = [] + for param in self.get_params(ctx): + rv = param.get_help_record(ctx) + if rv is not None: + if param.param_type_name == "argument": + args.append(rv) + elif param.param_type_name == "option": + opts.append(rv) + + if args: + with formatter.section(_("Arguments")): + formatter.write_dl(args) + if opts: + with formatter.section(_("Options")): + formatter.write_dl(opts) + + +def _typer_main_shell_completion( + self: click.core.Command, + *, + ctx_args: MutableMapping[str, Any], + prog_name: str, + complete_var: str | None = None, +) -> None: + if complete_var is None: + complete_var = f"_{prog_name}_COMPLETE".replace("-", "_").upper() + + instruction = os.environ.get(complete_var) + + if not instruction: + return + + from .completion import shell_complete + + rv = shell_complete(self, ctx_args, prog_name, complete_var, instruction) + sys.exit(rv) + + +class TyperCommand(click.core.Command): + def __init__( + self, + name: str | None, + *, + context_settings: dict[str, Any] | None = None, + callback: Callable[..., Any] | None = None, + params: list[click.Parameter] | None = None, + help: str | None = None, + epilog: str | None = None, + short_help: str | None = None, + options_metavar: str | None = "[OPTIONS]", + add_help_option: bool = True, + no_args_is_help: bool = False, + hidden: bool = False, + deprecated: bool = False, + # Rich settings + rich_markup_mode: MarkupMode = DEFAULT_MARKUP_MODE, + rich_help_panel: str | None = None, + ) -> None: + super().__init__( + name=name, + context_settings=context_settings, + callback=callback, + params=params, + help=help, + epilog=epilog, + short_help=short_help, + options_metavar=options_metavar, + add_help_option=add_help_option, + no_args_is_help=no_args_is_help, + hidden=hidden, + deprecated=deprecated, + ) + self.rich_markup_mode: MarkupMode = rich_markup_mode + self.rich_help_panel = rich_help_panel + + def format_options( + self, ctx: click.Context, formatter: click.HelpFormatter + ) -> None: + _typer_format_options(self, ctx=ctx, formatter=formatter) + + def _main_shell_completion( + self, + ctx_args: MutableMapping[str, Any], + prog_name: str, + complete_var: str | None = None, + ) -> None: + _typer_main_shell_completion( + self, ctx_args=ctx_args, prog_name=prog_name, complete_var=complete_var + ) + + def main( + self, + args: Sequence[str] | None = None, + prog_name: str | None = None, + complete_var: str | None = None, + standalone_mode: bool = True, + windows_expand_args: bool = True, + **extra: Any, + ) -> Any: + return _main( + self, + args=args, + prog_name=prog_name, + complete_var=complete_var, + standalone_mode=standalone_mode, + windows_expand_args=windows_expand_args, + rich_markup_mode=self.rich_markup_mode, + **extra, + ) + + def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None: + if not HAS_RICH or self.rich_markup_mode is None: + if not hasattr(ctx, "obj") or ctx.obj is None: + ctx.ensure_object(dict) + if isinstance(ctx.obj, dict): + ctx.obj[MARKUP_MODE_KEY] = self.rich_markup_mode + return super().format_help(ctx, formatter) + from . import rich_utils + + return rich_utils.rich_format_help( + obj=self, + ctx=ctx, + markup_mode=self.rich_markup_mode, + ) + + +class TyperGroup(click.core.Group): + def __init__( + self, + *, + name: str | None = None, + commands: dict[str, click.Command] | Sequence[click.Command] | None = None, + # Rich settings + rich_markup_mode: MarkupMode = DEFAULT_MARKUP_MODE, + rich_help_panel: str | None = None, + suggest_commands: bool = True, + **attrs: Any, + ) -> None: + super().__init__(name=name, commands=commands, **attrs) + self.rich_markup_mode: MarkupMode = rich_markup_mode + self.rich_help_panel = rich_help_panel + self.suggest_commands = suggest_commands + + def format_options( + self, ctx: click.Context, formatter: click.HelpFormatter + ) -> None: + _typer_format_options(self, ctx=ctx, formatter=formatter) + self.format_commands(ctx, formatter) + + def _main_shell_completion( + self, + ctx_args: MutableMapping[str, Any], + prog_name: str, + complete_var: str | None = None, + ) -> None: + _typer_main_shell_completion( + self, ctx_args=ctx_args, prog_name=prog_name, complete_var=complete_var + ) + + def resolve_command( + self, ctx: click.Context, args: list[str] + ) -> tuple[str | None, click.Command | None, list[str]]: + try: + return super().resolve_command(ctx, args) + except click.UsageError as e: + if self.suggest_commands: + available_commands = list(self.commands.keys()) + if available_commands and args: + typo = args[0] + matches = get_close_matches(typo, available_commands) + if matches: + suggestions = ", ".join(f"{m!r}" for m in matches) + message = e.message.rstrip(".") + e.message = f"{message}. Did you mean {suggestions}?" + raise + + def main( + self, + args: Sequence[str] | None = None, + prog_name: str | None = None, + complete_var: str | None = None, + standalone_mode: bool = True, + windows_expand_args: bool = True, + **extra: Any, + ) -> Any: + return _main( + self, + args=args, + prog_name=prog_name, + complete_var=complete_var, + standalone_mode=standalone_mode, + windows_expand_args=windows_expand_args, + rich_markup_mode=self.rich_markup_mode, + **extra, + ) + + def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None: + if not HAS_RICH or self.rich_markup_mode is None: + return super().format_help(ctx, formatter) + from . import rich_utils + + return rich_utils.rich_format_help( + obj=self, + ctx=ctx, + markup_mode=self.rich_markup_mode, + ) + + def list_commands(self, ctx: click.Context) -> list[str]: + """Returns a list of subcommand names. + Note that in Click's Group class, these are sorted. + In Typer, we wish to maintain the original order of creation (cf Issue #933)""" + return [n for n, c in self.commands.items()] diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/main.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/main.py new file mode 100644 index 0000000000000000000000000000000000000000..f4f21bb8444a80af5ad8ab82822fc972f0207b9c --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/main.py @@ -0,0 +1,2013 @@ +import inspect +import os +import platform +import shutil +import subprocess +import sys +import traceback +from collections.abc import Callable, Sequence +from datetime import datetime +from enum import Enum +from functools import update_wrapper +from pathlib import Path +from traceback import FrameSummary, StackSummary +from types import TracebackType +from typing import Annotated, Any +from uuid import UUID + +import click +from annotated_doc import Doc +from typer._types import TyperChoice + +from ._typing import get_args, get_origin, is_literal_type, is_union, literal_values +from .completion import get_completion_inspect_parameters +from .core import ( + DEFAULT_MARKUP_MODE, + HAS_RICH, + MarkupMode, + TyperArgument, + TyperCommand, + TyperGroup, + TyperOption, +) +from .models import ( + AnyType, + ArgumentInfo, + CommandFunctionType, + CommandInfo, + Default, + DefaultPlaceholder, + DeveloperExceptionConfig, + FileBinaryRead, + FileBinaryWrite, + FileText, + FileTextWrite, + NoneType, + OptionInfo, + ParameterInfo, + ParamMeta, + Required, + TyperInfo, + TyperPath, +) +from .utils import get_params_from_function + +_original_except_hook = sys.excepthook +_typer_developer_exception_attr_name = "__typer_developer_exception__" + + +def except_hook( + exc_type: type[BaseException], exc_value: BaseException, tb: TracebackType | None +) -> None: + exception_config: DeveloperExceptionConfig | None = getattr( + exc_value, _typer_developer_exception_attr_name, None + ) + standard_traceback = os.getenv( + "TYPER_STANDARD_TRACEBACK", os.getenv("_TYPER_STANDARD_TRACEBACK") + ) + if ( + standard_traceback + or not exception_config + or not exception_config.pretty_exceptions_enable + ): + _original_except_hook(exc_type, exc_value, tb) + return + typer_path = os.path.dirname(__file__) + click_path = os.path.dirname(click.__file__) + internal_dir_names = [typer_path, click_path] + exc = exc_value + if HAS_RICH: + from . import rich_utils + + rich_tb = rich_utils.get_traceback(exc, exception_config, internal_dir_names) + console_stderr = rich_utils._get_rich_console(stderr=True) + console_stderr.print(rich_tb) + return + tb_exc = traceback.TracebackException.from_exception(exc) + stack: list[FrameSummary] = [] + for frame in tb_exc.stack: + if any(frame.filename.startswith(path) for path in internal_dir_names): + if not exception_config.pretty_exceptions_short: + # Hide the line for internal libraries, Typer and Click + stack.append( + traceback.FrameSummary( + filename=frame.filename, + lineno=frame.lineno, + name=frame.name, + line="", + ) + ) + else: + stack.append(frame) + # Type ignore ref: https://github.com/python/typeshed/pull/8244 + final_stack_summary = StackSummary.from_list(stack) + tb_exc.stack = final_stack_summary + for line in tb_exc.format(): + print(line, file=sys.stderr) + return + + +def get_install_completion_arguments() -> tuple[click.Parameter, click.Parameter]: + install_param, show_param = get_completion_inspect_parameters() + click_install_param, _ = get_click_param(install_param) + click_show_param, _ = get_click_param(show_param) + return click_install_param, click_show_param + + +class Typer: + """ + `Typer` main class, the main entrypoint to use Typer. + + Read more in the + [Typer docs for First Steps](https://typer.tiangolo.com/tutorial/typer-app/). + + ## Example + + ```python + import typer + + app = typer.Typer() + ``` + """ + + def __init__( + self, + *, + name: Annotated[ + str | None, + Doc( + """ + The name of this application. + Mostly used to set the name for [subcommands](https://typer.tiangolo.com/tutorial/subcommands/), in which case it can be overridden by `add_typer(name=...)`. + + **Example** + + ```python + import typer + + app = typer.Typer(name="users") + ``` + """ + ), + ] = Default(None), + cls: Annotated[ + type[TyperGroup] | None, + Doc( + """ + The class of this app. Mainly used when [using the Click library underneath](https://typer.tiangolo.com/tutorial/using-click/). Can usually be left at the default value `None`. + Otherwise, should be a subtype of `TyperGroup`. + + **Example** + + ```python + import typer + + app = typer.Typer(cls=TyperGroup) + ``` + """ + ), + ] = Default(None), + invoke_without_command: Annotated[ + bool, + Doc( + """ + By setting this to `True`, you can make sure a callback is executed even when no subcommand is provided. + + **Example** + + ```python + import typer + + app = typer.Typer(invoke_without_command=True) + ``` + """ + ), + ] = Default(False), + no_args_is_help: Annotated[ + bool, + Doc( + """ + If this is set to `True`, running a command without any arguments will automatically show the help page. + + **Example** + + ```python + import typer + + app = typer.Typer(no_args_is_help=True) + ``` + """ + ), + ] = Default(False), + subcommand_metavar: Annotated[ + str | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + How to represent the subcommand argument in help. + """ + ), + ] = Default(None), + chain: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + Allow passing more than one subcommand argument. + """ + ), + ] = Default(False), + result_callback: Annotated[ + Callable[..., Any] | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + A function to call after the group's and subcommand's callbacks. + """ + ), + ] = Default(None), + # Command + context_settings: Annotated[ + dict[Any, Any] | None, + Doc( + """ + Pass configurations for the [context](https://typer.tiangolo.com/tutorial/commands/context/). + Available configurations can be found in the docs for Click's `Context` [here](https://click.palletsprojects.com/en/stable/api/#context). + + **Example** + + ```python + import typer + + app = typer.Typer(context_settings={"help_option_names": ["-h", "--help"]}) + ``` + """ + ), + ] = Default(None), + callback: Annotated[ + Callable[..., Any] | None, + Doc( + """ + Add a callback to the main Typer app. Can be overridden with `@app.callback()`. + See [the tutorial about callbacks](https://typer.tiangolo.com/tutorial/commands/callback/) for more details. + + **Example** + + ```python + import typer + + def callback(): + print("Running a command") + + app = typer.Typer(callback=callback) + ``` + """ + ), + ] = Default(None), + help: Annotated[ + str | None, + Doc( + """ + Help text for the main Typer app. + See [the tutorial about name and help](https://typer.tiangolo.com/tutorial/subcommands/name-and-help) for different ways of setting a command's help, + and which one takes priority. + + **Example** + + ```python + import typer + + app = typer.Typer(help="Some help.") + ``` + """ + ), + ] = Default(None), + epilog: Annotated[ + str | None, + Doc( + """ + Text that will be printed right after the help text. + + **Example** + + ```python + import typer + + app = typer.Typer(epilog="May the force be with you") + ``` + """ + ), + ] = Default(None), + short_help: Annotated[ + str | None, + Doc( + """ + A shortened version of the help text that can be used e.g. in the help table listing subcommands. + When not defined, the normal `help` text will be used instead. + + **Example** + + ```python + import typer + + app = typer.Typer(help="A lot of explanation about user management", short_help="user management") + ``` + """ + ), + ] = Default(None), + options_metavar: Annotated[ + str, + Doc( + """ + In the example usage string of the help text for a command, the default placeholder for various arguments is `[OPTIONS]`. + Set `options_metavar` to change this into a different string. + + **Example** + + ```python + import typer + + app = typer.Typer(options_metavar="[OPTS]") + ``` + """ + ), + ] = Default("[OPTIONS]"), + add_help_option: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + By default each command registers a `--help` option. This can be disabled by this parameter. + """ + ), + ] = Default(True), + hidden: Annotated[ + bool, + Doc( + """ + Hide this command from help outputs. `False` by default. + + **Example** + + ```python + import typer + + app = typer.Typer(hidden=True) + ``` + """ + ), + ] = Default(False), + deprecated: Annotated[ + bool, + Doc( + """ + Mark this command as being deprecated in the help text. `False` by default. + + **Example** + + ```python + import typer + + app = typer.Typer(deprecated=True) + ``` + """ + ), + ] = Default(False), + add_completion: Annotated[ + bool, + Doc( + """ + Toggle whether or not to add the `--install-completion` and `--show-completion` options to the app. + Set to `True` by default. + + **Example** + + ```python + import typer + + app = typer.Typer(add_completion=False) + ``` + """ + ), + ] = True, + # Rich settings + rich_markup_mode: Annotated[ + MarkupMode, + Doc( + """ + Enable markup text if you have Rich installed. This can be set to `"markdown"`, `"rich"`, or `None`. + By default, `rich_markup_mode` is `None` if Rich is not installed, and `"rich"` if it is installed. + See [the tutorial on help formatting](https://typer.tiangolo.com/tutorial/commands/help/#rich-markdown-and-markup) for more information. + + **Example** + + ```python + import typer + + app = typer.Typer(rich_markup_mode="rich") + ``` + """ + ), + ] = DEFAULT_MARKUP_MODE, + rich_help_panel: Annotated[ + str | None, + Doc( + """ + Set the panel name of the command when the help is printed with Rich. + + **Example** + + ```python + import typer + + app = typer.Typer(rich_help_panel="Utils and Configs") + ``` + """ + ), + ] = Default(None), + suggest_commands: Annotated[ + bool, + Doc( + """ + As of version 0.20.0, Typer provides [support for mistyped command names](https://typer.tiangolo.com/tutorial/commands/help/#suggest-commands) by printing helpful suggestions. + You can turn this setting off with `suggest_commands`: + + **Example** + + ```python + import typer + + app = typer.Typer(suggest_commands=False) + ``` + """ + ), + ] = True, + pretty_exceptions_enable: Annotated[ + bool, + Doc( + """ + If you want to disable [pretty exceptions with Rich](https://typer.tiangolo.com/tutorial/exceptions/#exceptions-with-rich), + you can set `pretty_exceptions_enable` to `False`. When doing so, you will see the usual standard exception trace. + + **Example** + + ```python + import typer + + app = typer.Typer(pretty_exceptions_enable=False) + ``` + """ + ), + ] = True, + pretty_exceptions_show_locals: Annotated[ + bool, + Doc( + """ + If Rich is installed, [error messages](https://typer.tiangolo.com/tutorial/exceptions/#exceptions-and-errors) + will be nicely printed. + + If you set `pretty_exceptions_show_locals=True` it will also include the values of local variables for easy debugging. + + However, if such a variable contains delicate information, you should consider leaving `pretty_exceptions_show_locals=False` + (the default) to `False` to enhance security. + + **Example** + + ```python + import typer + + app = typer.Typer(pretty_exceptions_show_locals=True) + ``` + """ + ), + ] = False, + pretty_exceptions_short: Annotated[ + bool, + Doc( + """ + By default, [pretty exceptions formatted with Rich](https://typer.tiangolo.com/tutorial/exceptions/#exceptions-with-rich) hide the long stack trace. + If you want to show the full trace instead, you can set the parameter `pretty_exceptions_short` to `False`: + + **Example** + + ```python + import typer + + app = typer.Typer(pretty_exceptions_short=False) + ``` + """ + ), + ] = True, + ): + self._add_completion = add_completion + self.rich_markup_mode: MarkupMode = rich_markup_mode + self.rich_help_panel = rich_help_panel + self.suggest_commands = suggest_commands + self.pretty_exceptions_enable = pretty_exceptions_enable + self.pretty_exceptions_show_locals = pretty_exceptions_show_locals + self.pretty_exceptions_short = pretty_exceptions_short + self.info = TyperInfo( + name=name, + cls=cls, + invoke_without_command=invoke_without_command, + no_args_is_help=no_args_is_help, + subcommand_metavar=subcommand_metavar, + chain=chain, + result_callback=result_callback, + context_settings=context_settings, + callback=callback, + help=help, + epilog=epilog, + short_help=short_help, + options_metavar=options_metavar, + add_help_option=add_help_option, + hidden=hidden, + deprecated=deprecated, + ) + self.registered_groups: list[TyperInfo] = [] + self.registered_commands: list[CommandInfo] = [] + self.registered_callback: TyperInfo | None = None + + def callback( + self, + *, + cls: Annotated[ + type[TyperGroup] | None, + Doc( + """ + The class of this app. Mainly used when [using the Click library underneath](https://typer.tiangolo.com/tutorial/using-click/). Can usually be left at the default value `None`. + Otherwise, should be a subtype of `TyperGroup`. + """ + ), + ] = Default(None), + invoke_without_command: Annotated[ + bool, + Doc( + """ + By setting this to `True`, you can make sure a callback is executed even when no subcommand is provided. + """ + ), + ] = Default(False), + no_args_is_help: Annotated[ + bool, + Doc( + """ + If this is set to `True`, running a command without any arguments will automatically show the help page. + """ + ), + ] = Default(False), + subcommand_metavar: Annotated[ + str | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + How to represent the subcommand argument in help. + """ + ), + ] = Default(None), + chain: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + Allow passing more than one subcommand argument. + """ + ), + ] = Default(False), + result_callback: Annotated[ + Callable[..., Any] | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + A function to call after the group's and subcommand's callbacks. + """ + ), + ] = Default(None), + # Command + context_settings: Annotated[ + dict[Any, Any] | None, + Doc( + """ + Pass configurations for the [context](https://typer.tiangolo.com/tutorial/commands/context/). + Available configurations can be found in the docs for Click's `Context` [here](https://click.palletsprojects.com/en/stable/api/#context). + """ + ), + ] = Default(None), + help: Annotated[ + str | None, + Doc( + """ + Help text for the command. + See [the tutorial about name and help](https://typer.tiangolo.com/tutorial/subcommands/name-and-help) for different ways of setting a command's help, + and which one takes priority. + """ + ), + ] = Default(None), + epilog: Annotated[ + str | None, + Doc( + """ + Text that will be printed right after the help text. + """ + ), + ] = Default(None), + short_help: Annotated[ + str | None, + Doc( + """ + A shortened version of the help text that can be used e.g. in the help table listing subcommands. + When not defined, the normal `help` text will be used instead. + """ + ), + ] = Default(None), + options_metavar: Annotated[ + str | None, + Doc( + """ + In the example usage string of the help text for a command, the default placeholder for various arguments is `[OPTIONS]`. + Set `options_metavar` to change this into a different string. When `None`, the default value will be used. + """ + ), + ] = Default(None), + add_help_option: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + By default each command registers a `--help` option. This can be disabled by this parameter. + """ + ), + ] = Default(True), + hidden: Annotated[ + bool, + Doc( + """ + Hide this command from help outputs. `False` by default. + """ + ), + ] = Default(False), + deprecated: Annotated[ + bool, + Doc( + """ + Mark this command as deprecated in the help text. `False` by default. + """ + ), + ] = Default(False), + # Rich settings + rich_help_panel: Annotated[ + str | None, + Doc( + """ + Set the panel name of the command when the help is printed with Rich. + """ + ), + ] = Default(None), + ) -> Callable[[CommandFunctionType], CommandFunctionType]: + """ + Using the decorator `@app.callback`, you can declare the CLI parameters for the main CLI application. + + Read more in the + [Typer docs for Callbacks](https://typer.tiangolo.com/tutorial/commands/callback/). + + ## Example + + ```python + import typer + + app = typer.Typer() + state = {"verbose": False} + + @app.callback() + def main(verbose: bool = False): + if verbose: + print("Will write verbose output") + state["verbose"] = True + + @app.command() + def delete(username: str): + # define subcommand + ... + ``` + """ + + def decorator(f: CommandFunctionType) -> CommandFunctionType: + self.registered_callback = TyperInfo( + cls=cls, + invoke_without_command=invoke_without_command, + no_args_is_help=no_args_is_help, + subcommand_metavar=subcommand_metavar, + chain=chain, + result_callback=result_callback, + context_settings=context_settings, + callback=f, + help=help, + epilog=epilog, + short_help=short_help, + options_metavar=( + options_metavar or self._info_val_str("options_metavar") + ), + add_help_option=add_help_option, + hidden=hidden, + deprecated=deprecated, + rich_help_panel=rich_help_panel, + ) + return f + + return decorator + + def command( + self, + name: Annotated[ + str | None, + Doc( + """ + The name of this command. + """ + ), + ] = None, + *, + cls: Annotated[ + type[TyperCommand] | None, + Doc( + """ + The class of this command. Mainly used when [using the Click library underneath](https://typer.tiangolo.com/tutorial/using-click/). Can usually be left at the default value `None`. + Otherwise, should be a subtype of `TyperCommand`. + """ + ), + ] = None, + context_settings: Annotated[ + dict[Any, Any] | None, + Doc( + """ + Pass configurations for the [context](https://typer.tiangolo.com/tutorial/commands/context/). + Available configurations can be found in the docs for Click's `Context` [here](https://click.palletsprojects.com/en/stable/api/#context). + """ + ), + ] = None, + help: Annotated[ + str | None, + Doc( + """ + Help text for the command. + See [the tutorial about name and help](https://typer.tiangolo.com/tutorial/subcommands/name-and-help) for different ways of setting a command's help, + and which one takes priority. + """ + ), + ] = None, + epilog: Annotated[ + str | None, + Doc( + """ + Text that will be printed right after the help text. + """ + ), + ] = None, + short_help: Annotated[ + str | None, + Doc( + """ + A shortened version of the help text that can be used e.g. in the help table listing subcommands. + When not defined, the normal `help` text will be used instead. + """ + ), + ] = None, + options_metavar: Annotated[ + str | None, + Doc( + """ + In the example usage string of the help text for a command, the default placeholder for various arguments is `[OPTIONS]`. + Set `options_metavar` to change this into a different string. When `None`, the default value will be used. + """ + ), + ] = Default(None), + add_help_option: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + By default each command registers a `--help` option. This can be disabled by this parameter. + """ + ), + ] = True, + no_args_is_help: Annotated[ + bool, + Doc( + """ + If this is set to `True`, running a command without any arguments will automatically show the help page. + """ + ), + ] = False, + hidden: Annotated[ + bool, + Doc( + """ + Hide this command from help outputs. `False` by default. + """ + ), + ] = False, + deprecated: Annotated[ + bool, + Doc( + """ + Mark this command as deprecated in the help outputs. `False` by default. + """ + ), + ] = False, + # Rich settings + rich_help_panel: Annotated[ + str | None, + Doc( + """ + Set the panel name of the command when the help is printed with Rich. + """ + ), + ] = Default(None), + ) -> Callable[[CommandFunctionType], CommandFunctionType]: + """ + Using the decorator `@app.command`, you can define a subcommand of the previously defined Typer app. + + Read more in the + [Typer docs for Commands](https://typer.tiangolo.com/tutorial/commands/). + + ## Example + + ```python + import typer + + app = typer.Typer() + + @app.command() + def create(): + print("Creating user: Hiro Hamada") + + @app.command() + def delete(): + print("Deleting user: Hiro Hamada") + ``` + """ + if cls is None: + cls = TyperCommand + + def decorator(f: CommandFunctionType) -> CommandFunctionType: + self.registered_commands.append( + CommandInfo( + name=name, + cls=cls, + context_settings=context_settings, + callback=f, + help=help, + epilog=epilog, + short_help=short_help, + options_metavar=( + options_metavar or self._info_val_str("options_metavar") + ), + add_help_option=add_help_option, + no_args_is_help=no_args_is_help, + hidden=hidden, + deprecated=deprecated, + # Rich settings + rich_help_panel=rich_help_panel, + ) + ) + return f + + return decorator + + def add_typer( + self, + typer_instance: "Typer", + *, + name: Annotated[ + str | None, + Doc( + """ + The name of this subcommand. + See [the tutorial about name and help](https://typer.tiangolo.com/tutorial/subcommands/name-and-help) for different ways of setting a command's name, + and which one takes priority. + """ + ), + ] = Default(None), + cls: Annotated[ + type[TyperGroup] | None, + Doc( + """ + The class of this subcommand. Mainly used when [using the Click library underneath](https://typer.tiangolo.com/tutorial/using-click/). Can usually be left at the default value `None`. + Otherwise, should be a subtype of `TyperGroup`. + """ + ), + ] = Default(None), + invoke_without_command: Annotated[ + bool, + Doc( + """ + By setting this to `True`, you can make sure a callback is executed even when no subcommand is provided. + """ + ), + ] = Default(False), + no_args_is_help: Annotated[ + bool, + Doc( + """ + If this is set to `True`, running a command without any arguments will automatically show the help page. + """ + ), + ] = Default(False), + subcommand_metavar: Annotated[ + str | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + How to represent the subcommand argument in help. + """ + ), + ] = Default(None), + chain: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + Allow passing more than one subcommand argument. + """ + ), + ] = Default(False), + result_callback: Annotated[ + Callable[..., Any] | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + A function to call after the group's and subcommand's callbacks. + """ + ), + ] = Default(None), + # Command + context_settings: Annotated[ + dict[Any, Any] | None, + Doc( + """ + Pass configurations for the [context](https://typer.tiangolo.com/tutorial/commands/context/). + Available configurations can be found in the docs for Click's `Context` [here](https://click.palletsprojects.com/en/stable/api/#context). + """ + ), + ] = Default(None), + callback: Annotated[ + Callable[..., Any] | None, + Doc( + """ + Add a callback to this app. + See [the tutorial about callbacks](https://typer.tiangolo.com/tutorial/commands/callback/) for more details. + """ + ), + ] = Default(None), + help: Annotated[ + str | None, + Doc( + """ + Help text for the subcommand. + See [the tutorial about name and help](https://typer.tiangolo.com/tutorial/subcommands/name-and-help) for different ways of setting a command's help, + and which one takes priority. + """ + ), + ] = Default(None), + epilog: Annotated[ + str | None, + Doc( + """ + Text that will be printed right after the help text. + """ + ), + ] = Default(None), + short_help: Annotated[ + str | None, + Doc( + """ + A shortened version of the help text that can be used e.g. in the help table listing subcommands. + When not defined, the normal `help` text will be used instead. + """ + ), + ] = Default(None), + options_metavar: Annotated[ + str | None, + Doc( + """ + In the example usage string of the help text for a command, the default placeholder for various arguments is `[OPTIONS]`. + Set `options_metavar` to change this into a different string. When `None`, the default value will be used. + """ + ), + ] = Default(None), + add_help_option: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited + from Click and supported for compatibility. + + --- + + By default each command registers a `--help` option. This can be disabled by this parameter. + """ + ), + ] = Default(True), + hidden: Annotated[ + bool, + Doc( + """ + Hide this command from help outputs. `False` by default. + """ + ), + ] = Default(False), + deprecated: Annotated[ + bool, + Doc( + """ + Mark this command as deprecated in the help outputs. `False` by default. + """ + ), + ] = False, + # Rich settings + rich_help_panel: Annotated[ + str | None, + Doc( + """ + Set the panel name of the command when the help is printed with Rich. + """ + ), + ] = Default(None), + ) -> None: + """ + Add subcommands to the main app using `app.add_typer()`. + Subcommands may be defined in separate modules, ensuring clean separation of code by functionality. + + Read more in the + [Typer docs for SubCommands](https://typer.tiangolo.com/tutorial/subcommands/add-typer/). + + ## Example + + ```python + import typer + + from .add import app as add_app + from .delete import app as delete_app + + app = typer.Typer() + + app.add_typer(add_app) + app.add_typer(delete_app) + ``` + """ + self.registered_groups.append( + TyperInfo( + typer_instance, + name=name, + cls=cls, + invoke_without_command=invoke_without_command, + no_args_is_help=no_args_is_help, + subcommand_metavar=subcommand_metavar, + chain=chain, + result_callback=result_callback, + context_settings=context_settings, + callback=callback, + help=help, + epilog=epilog, + short_help=short_help, + options_metavar=( + options_metavar or self._info_val_str("options_metavar") + ), + add_help_option=add_help_option, + hidden=hidden, + deprecated=deprecated, + rich_help_panel=rich_help_panel, + ) + ) + + def __call__(self, *args: Any, **kwargs: Any) -> Any: + if sys.excepthook != except_hook: + sys.excepthook = except_hook + try: + return get_command(self)(*args, **kwargs) + except Exception as e: + # Set a custom attribute to tell the hook to show nice exceptions for user + # code. An alternative/first implementation was a custom exception with + # raise custom_exc from e + # but that means the last error shown is the custom exception, not the + # actual error. This trick improves developer experience by showing the + # actual error last. + setattr( + e, + _typer_developer_exception_attr_name, + DeveloperExceptionConfig( + pretty_exceptions_enable=self.pretty_exceptions_enable, + pretty_exceptions_show_locals=self.pretty_exceptions_show_locals, + pretty_exceptions_short=self.pretty_exceptions_short, + ), + ) + raise e + + def _info_val_str(self, name: str) -> str: + val = getattr(self.info, name) + val_str = val.value if isinstance(val, DefaultPlaceholder) else val + assert isinstance(val_str, str) + return val_str + + +def get_group(typer_instance: Typer) -> TyperGroup: + group = get_group_from_info( + TyperInfo(typer_instance), + pretty_exceptions_short=typer_instance.pretty_exceptions_short, + rich_markup_mode=typer_instance.rich_markup_mode, + suggest_commands=typer_instance.suggest_commands, + ) + return group + + +def get_command(typer_instance: Typer) -> click.Command: + if typer_instance._add_completion: + click_install_param, click_show_param = get_install_completion_arguments() + if ( + typer_instance.registered_callback + or typer_instance.info.callback + or typer_instance.registered_groups + or len(typer_instance.registered_commands) > 1 + ): + # Create a Group + click_command: click.Command = get_group(typer_instance) + if typer_instance._add_completion: + click_command.params.append(click_install_param) + click_command.params.append(click_show_param) + return click_command + elif len(typer_instance.registered_commands) == 1: + # Create a single Command + single_command = typer_instance.registered_commands[0] + + if not single_command.context_settings and not isinstance( + typer_instance.info.context_settings, DefaultPlaceholder + ): + single_command.context_settings = typer_instance.info.context_settings + + click_command = get_command_from_info( + single_command, + pretty_exceptions_short=typer_instance.pretty_exceptions_short, + rich_markup_mode=typer_instance.rich_markup_mode, + ) + if typer_instance._add_completion: + click_command.params.append(click_install_param) + click_command.params.append(click_show_param) + return click_command + raise RuntimeError( + "Could not get a command for this Typer instance" + ) # pragma: no cover + + +def solve_typer_info_help(typer_info: TyperInfo) -> str: + # Priority 1: Explicit value was set in app.add_typer() + if not isinstance(typer_info.help, DefaultPlaceholder): + return inspect.cleandoc(typer_info.help or "") + # Priority 2: Explicit value was set in sub_app.callback() + if typer_info.typer_instance and typer_info.typer_instance.registered_callback: + callback_help = typer_info.typer_instance.registered_callback.help + if not isinstance(callback_help, DefaultPlaceholder): + return inspect.cleandoc(callback_help or "") + # Priority 3: Explicit value was set in sub_app = typer.Typer() + if typer_info.typer_instance and typer_info.typer_instance.info: + instance_help = typer_info.typer_instance.info.help + if not isinstance(instance_help, DefaultPlaceholder): + return inspect.cleandoc(instance_help or "") + # Priority 4: Implicit inference from callback docstring in app.add_typer() + if typer_info.callback: + doc = inspect.getdoc(typer_info.callback) + if doc: + return doc + # Priority 5: Implicit inference from callback docstring in @app.callback() + if typer_info.typer_instance and typer_info.typer_instance.registered_callback: + callback = typer_info.typer_instance.registered_callback.callback + if not isinstance(callback, DefaultPlaceholder): + doc = inspect.getdoc(callback or "") + if doc: + return doc + # Priority 6: Implicit inference from callback docstring in typer.Typer() + if typer_info.typer_instance and typer_info.typer_instance.info: + instance_callback = typer_info.typer_instance.info.callback + if not isinstance(instance_callback, DefaultPlaceholder): + doc = inspect.getdoc(instance_callback) + if doc: + return doc + # Value not set, use the default + return typer_info.help.value + + +def solve_typer_info_defaults(typer_info: TyperInfo) -> TyperInfo: + values: dict[str, Any] = {} + for name, value in typer_info.__dict__.items(): + # Priority 1: Value was set in app.add_typer() + if not isinstance(value, DefaultPlaceholder): + values[name] = value + continue + # Priority 2: Value was set in @subapp.callback() + try: + callback_value = getattr( + typer_info.typer_instance.registered_callback, # type: ignore + name, + ) + if not isinstance(callback_value, DefaultPlaceholder): + values[name] = callback_value + continue + except AttributeError: + pass + # Priority 3: Value set in subapp = typer.Typer() + try: + instance_value = getattr( + typer_info.typer_instance.info, # type: ignore + name, + ) + if not isinstance(instance_value, DefaultPlaceholder): + values[name] = instance_value + continue + except AttributeError: + pass + # Value not set, use the default + values[name] = value.value + values["help"] = solve_typer_info_help(typer_info) + return TyperInfo(**values) + + +def get_group_from_info( + group_info: TyperInfo, + *, + pretty_exceptions_short: bool, + suggest_commands: bool, + rich_markup_mode: MarkupMode, +) -> TyperGroup: + assert group_info.typer_instance, ( + "A Typer instance is needed to generate a Click Group" + ) + commands: dict[str, click.Command] = {} + for command_info in group_info.typer_instance.registered_commands: + command = get_command_from_info( + command_info=command_info, + pretty_exceptions_short=pretty_exceptions_short, + rich_markup_mode=rich_markup_mode, + ) + if command.name: + commands[command.name] = command + for sub_group_info in group_info.typer_instance.registered_groups: + sub_group = get_group_from_info( + sub_group_info, + pretty_exceptions_short=pretty_exceptions_short, + rich_markup_mode=rich_markup_mode, + suggest_commands=suggest_commands, + ) + if sub_group.name: + commands[sub_group.name] = sub_group + else: + if sub_group.callback: + import warnings + + warnings.warn( + "The 'callback' parameter is not supported by Typer when using `add_typer` without a name", + stacklevel=5, + ) + for sub_command_name, sub_command in sub_group.commands.items(): + commands[sub_command_name] = sub_command + solved_info = solve_typer_info_defaults(group_info) + ( + params, + convertors, + context_param_name, + ) = get_params_convertors_ctx_param_name_from_function(solved_info.callback) + cls = solved_info.cls or TyperGroup + assert issubclass(cls, TyperGroup), f"{cls} should be a subclass of {TyperGroup}" + group = cls( + name=solved_info.name or "", + commands=commands, + invoke_without_command=solved_info.invoke_without_command, + no_args_is_help=solved_info.no_args_is_help, + subcommand_metavar=solved_info.subcommand_metavar, + chain=solved_info.chain, + result_callback=solved_info.result_callback, + context_settings=solved_info.context_settings, + callback=get_callback( + callback=solved_info.callback, + params=params, + convertors=convertors, + context_param_name=context_param_name, + pretty_exceptions_short=pretty_exceptions_short, + ), + params=params, + help=solved_info.help, + epilog=solved_info.epilog, + short_help=solved_info.short_help, + options_metavar=solved_info.options_metavar, + add_help_option=solved_info.add_help_option, + hidden=solved_info.hidden, + deprecated=solved_info.deprecated, + rich_markup_mode=rich_markup_mode, + # Rich settings + rich_help_panel=solved_info.rich_help_panel, + suggest_commands=suggest_commands, + ) + return group + + +def get_command_name(name: str) -> str: + return name.lower().replace("_", "-") + + +def get_params_convertors_ctx_param_name_from_function( + callback: Callable[..., Any] | None, +) -> tuple[list[click.Argument | click.Option], dict[str, Any], str | None]: + params = [] + convertors = {} + context_param_name = None + if callback: + parameters = get_params_from_function(callback) + for param_name, param in parameters.items(): + if lenient_issubclass(param.annotation, click.Context): + context_param_name = param_name + continue + click_param, convertor = get_click_param(param) + if convertor: + convertors[param_name] = convertor + params.append(click_param) + return params, convertors, context_param_name + + +def get_command_from_info( + command_info: CommandInfo, + *, + pretty_exceptions_short: bool, + rich_markup_mode: MarkupMode, +) -> click.Command: + assert command_info.callback, "A command must have a callback function" + name = command_info.name or get_command_name(command_info.callback.__name__) # ty:ignore[unresolved-attribute] + use_help = command_info.help + if use_help is None: + use_help = inspect.getdoc(command_info.callback) + else: + use_help = inspect.cleandoc(use_help) + ( + params, + convertors, + context_param_name, + ) = get_params_convertors_ctx_param_name_from_function(command_info.callback) + cls = command_info.cls or TyperCommand + command = cls( + name=name, + context_settings=command_info.context_settings, + callback=get_callback( + callback=command_info.callback, + params=params, + convertors=convertors, + context_param_name=context_param_name, + pretty_exceptions_short=pretty_exceptions_short, + ), + params=params, # type: ignore + help=use_help, + epilog=command_info.epilog, + short_help=command_info.short_help, + options_metavar=command_info.options_metavar, + add_help_option=command_info.add_help_option, + no_args_is_help=command_info.no_args_is_help, + hidden=command_info.hidden, + deprecated=command_info.deprecated, + rich_markup_mode=rich_markup_mode, + # Rich settings + rich_help_panel=command_info.rich_help_panel, + ) + return command + + +def determine_type_convertor(type_: Any) -> Callable[[Any], Any] | None: + convertor: Callable[[Any], Any] | None = None + if lenient_issubclass(type_, Path): + convertor = param_path_convertor + if lenient_issubclass(type_, Enum): + convertor = generate_enum_convertor(type_) + return convertor + + +def param_path_convertor(value: str | None = None) -> Path | None: + if value is not None: + # allow returning any subclass of Path created by an annotated parser without converting + # it back to a Path + return value if isinstance(value, Path) else Path(value) + return None + + +def generate_enum_convertor(enum: type[Enum]) -> Callable[[Any], Any]: + val_map = {str(val.value): val for val in enum} + + def convertor(value: Any) -> Any: + if value is not None: + val = str(value) + if val in val_map: + key = val_map[val] + return enum(key) + + return convertor + + +def generate_list_convertor( + convertor: Callable[[Any], Any] | None, default_value: Any | None +) -> Callable[[Sequence[Any] | None], list[Any] | None]: + def internal_convertor(value: Sequence[Any] | None) -> list[Any] | None: + if (value is None) or (default_value is None and len(value) == 0): + return None + return [convertor(v) if convertor else v for v in value] + + return internal_convertor + + +def generate_tuple_convertor( + types: Sequence[Any], +) -> Callable[[tuple[Any, ...] | None], tuple[Any, ...] | None]: + convertors = [determine_type_convertor(type_) for type_ in types] + + def internal_convertor( + param_args: tuple[Any, ...] | None, + ) -> tuple[Any, ...] | None: + if param_args is None: + return None + return tuple( + convertor(arg) if convertor else arg + for (convertor, arg) in zip(convertors, param_args, strict=False) + ) + + return internal_convertor + + +def get_callback( + *, + callback: Callable[..., Any] | None = None, + params: Sequence[click.Parameter] = [], + convertors: dict[str, Callable[[str], Any]] | None = None, + context_param_name: str | None = None, + pretty_exceptions_short: bool, +) -> Callable[..., Any] | None: + use_convertors = convertors or {} + if not callback: + return None + parameters = get_params_from_function(callback) + use_params: dict[str, Any] = {} + for param_name in parameters: + use_params[param_name] = None + for param in params: + if param.name: + use_params[param.name] = param.default + + def wrapper(**kwargs: Any) -> Any: + _rich_traceback_guard = pretty_exceptions_short # noqa: F841 + for k, v in kwargs.items(): + if k in use_convertors: + use_params[k] = use_convertors[k](v) + else: + use_params[k] = v + if context_param_name: + use_params[context_param_name] = click.get_current_context() + return callback(**use_params) + + update_wrapper(wrapper, callback) + return wrapper + + +def get_click_type( + *, annotation: Any, parameter_info: ParameterInfo +) -> click.ParamType: + if parameter_info.click_type is not None: + return parameter_info.click_type + + elif parameter_info.parser is not None: + return click.types.FuncParamType(parameter_info.parser) + + elif annotation is str: + return click.STRING + elif annotation is int: + if parameter_info.min is not None or parameter_info.max is not None: + min_ = None + max_ = None + if parameter_info.min is not None: + min_ = int(parameter_info.min) + if parameter_info.max is not None: + max_ = int(parameter_info.max) + return click.IntRange(min=min_, max=max_, clamp=parameter_info.clamp) + else: + return click.INT + elif annotation is float: + if parameter_info.min is not None or parameter_info.max is not None: + return click.FloatRange( + min=parameter_info.min, + max=parameter_info.max, + clamp=parameter_info.clamp, + ) + else: + return click.FLOAT + elif annotation is bool: + return click.BOOL + elif annotation == UUID: + return click.UUID + elif annotation == datetime: + return click.DateTime(formats=parameter_info.formats) + elif ( + annotation == Path + or parameter_info.allow_dash + or parameter_info.path_type + or parameter_info.resolve_path + ): + return TyperPath( + exists=parameter_info.exists, + file_okay=parameter_info.file_okay, + dir_okay=parameter_info.dir_okay, + writable=parameter_info.writable, + readable=parameter_info.readable, + resolve_path=parameter_info.resolve_path, + allow_dash=parameter_info.allow_dash, + path_type=parameter_info.path_type, + ) + elif lenient_issubclass(annotation, FileTextWrite): + return click.File( + mode=parameter_info.mode or "w", + encoding=parameter_info.encoding, + errors=parameter_info.errors, + lazy=parameter_info.lazy, + atomic=parameter_info.atomic, + ) + elif lenient_issubclass(annotation, FileText): + return click.File( + mode=parameter_info.mode or "r", + encoding=parameter_info.encoding, + errors=parameter_info.errors, + lazy=parameter_info.lazy, + atomic=parameter_info.atomic, + ) + elif lenient_issubclass(annotation, FileBinaryRead): + return click.File( + mode=parameter_info.mode or "rb", + encoding=parameter_info.encoding, + errors=parameter_info.errors, + lazy=parameter_info.lazy, + atomic=parameter_info.atomic, + ) + elif lenient_issubclass(annotation, FileBinaryWrite): + return click.File( + mode=parameter_info.mode or "wb", + encoding=parameter_info.encoding, + errors=parameter_info.errors, + lazy=parameter_info.lazy, + atomic=parameter_info.atomic, + ) + elif lenient_issubclass(annotation, Enum): + # The custom TyperChoice is only needed for Click < 8.2.0, to parse the + # command line values matching them to the enum values. Click 8.2.0 added + # support for enum values but reading enum names. + # Passing here the list of enum values (instead of just the enum) accounts for + # Click < 8.2.0. + return TyperChoice( + [item.value for item in annotation], + case_sensitive=parameter_info.case_sensitive, + ) + elif is_literal_type(annotation): + return click.Choice( + literal_values(annotation), + case_sensitive=parameter_info.case_sensitive, + ) + raise RuntimeError(f"Type not yet supported: {annotation}") # pragma: no cover + + +def lenient_issubclass(cls: Any, class_or_tuple: AnyType | tuple[AnyType, ...]) -> bool: + return isinstance(cls, type) and issubclass(cls, class_or_tuple) + + +def get_click_param( + param: ParamMeta, +) -> tuple[click.Argument | click.Option, Any]: + # First, find out what will be: + # * ParamInfo (ArgumentInfo or OptionInfo) + # * default_value + # * required + default_value = None + required = False + if isinstance(param.default, ParameterInfo): + parameter_info = param.default + if parameter_info.default == Required: + required = True + else: + default_value = parameter_info.default + elif param.default == Required or param.default is param.empty: + required = True + parameter_info = ArgumentInfo() + else: + default_value = param.default + parameter_info = OptionInfo() + annotation: Any + if param.annotation is not param.empty: + annotation = param.annotation + else: + annotation = str + main_type = annotation + is_list = False + is_tuple = False + parameter_type: Any = None + is_flag = None + origin = get_origin(main_type) + + if origin is not None: + # Handle SomeType | None and Optional[SomeType] + if is_union(origin): + types = [] + for type_ in get_args(main_type): + if type_ is NoneType: + continue + types.append(type_) + assert len(types) == 1, "Typer Currently doesn't support Union types" + main_type = types[0] + origin = get_origin(main_type) + # Handle Tuples and Lists + if lenient_issubclass(origin, list): + main_type = get_args(main_type)[0] + assert not get_origin(main_type), ( + "List types with complex sub-types are not currently supported" + ) + is_list = True + elif lenient_issubclass(origin, tuple): + types = [] + for type_ in get_args(main_type): + assert not get_origin(type_), ( + "Tuple types with complex sub-types are not currently supported" + ) + types.append( + get_click_type(annotation=type_, parameter_info=parameter_info) + ) + parameter_type = tuple(types) + is_tuple = True + if parameter_type is None: + parameter_type = get_click_type( + annotation=main_type, parameter_info=parameter_info + ) + convertor = determine_type_convertor(main_type) + if is_list: + convertor = generate_list_convertor( + convertor=convertor, default_value=default_value + ) + if is_tuple: + convertor = generate_tuple_convertor(get_args(main_type)) + if isinstance(parameter_info, OptionInfo): + if main_type is bool: + is_flag = True + # Click doesn't accept a flag of type bool, only None, and then it sets it + # to bool internally + parameter_type = None + default_option_name = get_command_name(param.name) + if is_flag: + default_option_declaration = ( + f"--{default_option_name}/--no-{default_option_name}" + ) + else: + default_option_declaration = f"--{default_option_name}" + param_decls = [param.name] + if parameter_info.param_decls: + param_decls.extend(parameter_info.param_decls) + else: + param_decls.append(default_option_declaration) + return ( + TyperOption( + # Option + param_decls=param_decls, + show_default=parameter_info.show_default, + prompt=parameter_info.prompt, + confirmation_prompt=parameter_info.confirmation_prompt, + prompt_required=parameter_info.prompt_required, + hide_input=parameter_info.hide_input, + is_flag=is_flag, + multiple=is_list, + count=parameter_info.count, + allow_from_autoenv=parameter_info.allow_from_autoenv, + type=parameter_type, + help=parameter_info.help, + hidden=parameter_info.hidden, + show_choices=parameter_info.show_choices, + show_envvar=parameter_info.show_envvar, + # Parameter + required=required, + default=default_value, + callback=get_param_callback( + callback=parameter_info.callback, convertor=convertor + ), + metavar=parameter_info.metavar, + expose_value=parameter_info.expose_value, + is_eager=parameter_info.is_eager, + envvar=parameter_info.envvar, + shell_complete=parameter_info.shell_complete, + autocompletion=get_param_completion(parameter_info.autocompletion), + # Rich settings + rich_help_panel=parameter_info.rich_help_panel, + ), + convertor, + ) + elif isinstance(parameter_info, ArgumentInfo): + param_decls = [param.name] + nargs = None + if is_list: + nargs = -1 + return ( + TyperArgument( + # Argument + param_decls=param_decls, + type=parameter_type, + required=required, + nargs=nargs, + # TyperArgument + show_default=parameter_info.show_default, + show_choices=parameter_info.show_choices, + show_envvar=parameter_info.show_envvar, + help=parameter_info.help, + hidden=parameter_info.hidden, + # Parameter + default=default_value, + callback=get_param_callback( + callback=parameter_info.callback, convertor=convertor + ), + metavar=parameter_info.metavar, + expose_value=parameter_info.expose_value, + is_eager=parameter_info.is_eager, + envvar=parameter_info.envvar, + shell_complete=parameter_info.shell_complete, + autocompletion=get_param_completion(parameter_info.autocompletion), + # Rich settings + rich_help_panel=parameter_info.rich_help_panel, + ), + convertor, + ) + raise AssertionError("A click.Parameter should be returned") # pragma: no cover + + +def get_param_callback( + *, + callback: Callable[..., Any] | None = None, + convertor: Callable[..., Any] | None = None, +) -> Callable[..., Any] | None: + if not callback: + return None + parameters = get_params_from_function(callback) + ctx_name = None + click_param_name = None + value_name = None + untyped_names: list[str] = [] + for param_name, param_sig in parameters.items(): + if lenient_issubclass(param_sig.annotation, click.Context): + ctx_name = param_name + elif lenient_issubclass(param_sig.annotation, click.Parameter): + click_param_name = param_name + else: + untyped_names.append(param_name) + # Extract value param name first + if untyped_names: + value_name = untyped_names.pop() + # If context and Click param were not typed (old/Click callback style) extract them + if untyped_names: + if ctx_name is None: + ctx_name = untyped_names.pop(0) + if click_param_name is None: + if untyped_names: + click_param_name = untyped_names.pop(0) + if untyped_names: + raise click.ClickException( + "Too many CLI parameter callback function parameters" + ) + + def wrapper(ctx: click.Context, param: click.Parameter, value: Any) -> Any: + use_params: dict[str, Any] = {} + if ctx_name: + use_params[ctx_name] = ctx + if click_param_name: + use_params[click_param_name] = param + if value_name: + if convertor: + use_value = convertor(value) + else: + use_value = value + use_params[value_name] = use_value + return callback(**use_params) + + update_wrapper(wrapper, callback) + return wrapper + + +def get_param_completion( + callback: Callable[..., Any] | None = None, +) -> Callable[..., Any] | None: + if not callback: + return None + parameters = get_params_from_function(callback) + ctx_name = None + args_name = None + incomplete_name = None + unassigned_params = list(parameters.values()) + for param_sig in unassigned_params[:]: + origin = get_origin(param_sig.annotation) + if lenient_issubclass(param_sig.annotation, click.Context): + ctx_name = param_sig.name + unassigned_params.remove(param_sig) + elif lenient_issubclass(origin, list): + args_name = param_sig.name + unassigned_params.remove(param_sig) + elif lenient_issubclass(param_sig.annotation, str): + incomplete_name = param_sig.name + unassigned_params.remove(param_sig) + # If there are still unassigned parameters (not typed), extract by name + for param_sig in unassigned_params[:]: + if ctx_name is None and param_sig.name == "ctx": + ctx_name = param_sig.name + unassigned_params.remove(param_sig) + elif args_name is None and param_sig.name == "args": + args_name = param_sig.name + unassigned_params.remove(param_sig) + elif incomplete_name is None and param_sig.name == "incomplete": + incomplete_name = param_sig.name + unassigned_params.remove(param_sig) + # Extract value param name first + if unassigned_params: + show_params = " ".join([param.name for param in unassigned_params]) + raise click.ClickException( + f"Invalid autocompletion callback parameters: {show_params}" + ) + + def wrapper(ctx: click.Context, args: list[str], incomplete: str | None) -> Any: + use_params: dict[str, Any] = {} + if ctx_name: + use_params[ctx_name] = ctx + if args_name: + use_params[args_name] = args + if incomplete_name: + use_params[incomplete_name] = incomplete + return callback(**use_params) + + update_wrapper(wrapper, callback) + return wrapper + + +def run( + function: Annotated[ + Callable[..., Any], + Doc( + """ + The function that should power this CLI application. + """ + ), + ], +) -> None: + """ + This function converts a given function to a CLI application with `Typer()` and executes it. + + ## Example + + ```python + import typer + + def main(name: str): + print(f"Hello {name}") + + if __name__ == "__main__": + typer.run(main) + ``` + """ + app = Typer(add_completion=False) + app.command()(function) + app() + + +def _is_macos() -> bool: + return platform.system() == "Darwin" + + +def _is_linux_or_bsd() -> bool: + if platform.system() == "Linux": + return True + + return "BSD" in platform.system() + + +def launch( + url: Annotated[ + str, + Doc( + """ + URL or filename of the thing to launch. + """ + ), + ], + wait: Annotated[ + bool, + Doc( + """ + Wait for the program to exit before returning. This only works if the launched program blocks. + In particular, `xdg-open` on Linux does not block. + """ + ), + ] = False, + locate: Annotated[ + bool, + Doc( + """ + If this is set to `True`, then instead of launching the application associated with the URL, it will attempt to + launch a file manager with the file located. This might have weird effects if the URL does not point to the filesystem. + """ + ), + ] = False, +) -> int: + """ + This function launches the given URL (or filename) in the default + viewer application for this file type. If this is an executable, it + might launch the executable in a new session. The return value is + the exit code of the launched application. Usually, `0` indicates + success. + + This function handles url in different operating systems separately: + - On macOS (Darwin), it uses the `open` command. + - On Linux and BSD, it uses `xdg-open` if available. + - On Windows (and other OSes), it uses the standard webbrowser module. + + The function avoids, when possible, using the webbrowser module on Linux and macOS + to prevent spammy terminal messages from some browsers (e.g., Chrome). + + ## Examples + ```python + import typer + + typer.launch("https://typer.tiangolo.com/") + ``` + + ```python + import typer + + typer.launch("/my/downloaded/file", locate=True) + ``` + """ + + if url.startswith("http://") or url.startswith("https://"): + if _is_macos(): + return subprocess.Popen( + ["open", url], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT + ).wait() + + has_xdg_open = _is_linux_or_bsd() and shutil.which("xdg-open") is not None + + if has_xdg_open: + return subprocess.Popen( + ["xdg-open", url], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT + ).wait() + + import webbrowser + + webbrowser.open(url) + + return 0 + + else: + return click.launch(url) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/models.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/models.py new file mode 100644 index 0000000000000000000000000000000000000000..3285a96a2433176a22c11c2402116e5f7562218e --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/models.py @@ -0,0 +1,651 @@ +import inspect +import io +from collections.abc import Callable, Sequence +from typing import ( + TYPE_CHECKING, + Any, + Optional, + TypeVar, +) + +import click +import click.shell_completion + +if TYPE_CHECKING: # pragma: no cover + from .core import TyperCommand, TyperGroup + from .main import Typer + + +NoneType = type(None) + +AnyType = type[Any] + +Required = ... + + +class Context(click.Context): + """ + The [`Context`](https://click.palletsprojects.com/en/stable/api/#click.Context) has some additional data about the current execution of your program. + When declaring it in a [callback](https://typer.tiangolo.com/tutorial/options/callback-and-context/) function, + you can access this additional information. + """ + + pass + + +class FileText(io.TextIOWrapper): + """ + Gives you a file-like object for reading text, and you will get a `str` data from it. + The default mode of this class is `mode="r"`. + + **Example** + + ```python + from typing import Annotated + + import typer + + app = typer.Typer() + + @app.command() + def main(config: Annotated[typer.FileText, typer.Option()]): + for line in config: + print(f"Config line: {line}") + + if __name__ == "__main__": + app() + ``` + """ + + pass + + +class FileTextWrite(FileText): + """ + You can use this class for writing text. Alternatively, you can use `FileText` with `mode="w"`. + The default mode of this class is `mode="w"`. + + **Example** + + ```python + from typing import Annotated + + import typer + + app = typer.Typer() + + @app.command() + def main(config: Annotated[typer.FileTextWrite, typer.Option()]): + config.write("Some config written by the app") + print("Config written") + + if __name__ == "__main__": + app() + ``` + """ + + pass + + +class FileBinaryRead(io.BufferedReader): + """ + You can use this class to read binary data, receiving `bytes`. + The default mode of this class is `mode="rb"`. + It is useful for reading binary files like images: + + **Example** + + ```python + from typing import Annotated + + import typer + + app = typer.Typer() + + @app.command() + def main(file: Annotated[typer.FileBinaryRead, typer.Option()]): + processed_total = 0 + for bytes_chunk in file: + # Process the bytes in bytes_chunk + processed_total += len(bytes_chunk) + print(f"Processed bytes total: {processed_total}") + + if __name__ == "__main__": + app() + ``` + """ + + pass + + +class FileBinaryWrite(io.BufferedWriter): + """ + You can use this class to write binary data: you pass `bytes` to it instead of strings. + The default mode of this class is `mode="wb"`. + It is useful for writing binary files like images: + + **Example** + + ```python + from typing import Annotated + + import typer + + app = typer.Typer() + + @app.command() + def main(file: Annotated[typer.FileBinaryWrite, typer.Option()]): + first_line_str = "some settings\\n" + # You cannot write str directly to a binary file; encode it first + first_line_bytes = first_line_str.encode("utf-8") + # Then you can write the bytes + file.write(first_line_bytes) + # This is already bytes, it starts with b" + second_line = b"la cig\xc3\xbce\xc3\xb1a trae al ni\xc3\xb1o" + file.write(second_line) + print("Binary file written") + + if __name__ == "__main__": + app() + ``` + """ + + pass + + +class CallbackParam(click.Parameter): + """ + In a callback function, you can declare a function parameter with type `CallbackParam` + to access the specific Click [`Parameter`](https://click.palletsprojects.com/en/stable/api/#click.Parameter) object. + """ + + pass + + +class DefaultPlaceholder: + """ + You shouldn't use this class directly. + + It's used internally to recognize when a default value has been overwritten, even + if the new value is `None`. + """ + + def __init__(self, value: Any): + self.value = value + + def __bool__(self) -> bool: + return bool(self.value) + + +DefaultType = TypeVar("DefaultType") + +CommandFunctionType = TypeVar("CommandFunctionType", bound=Callable[..., Any]) + + +def Default(value: DefaultType) -> DefaultType: + """ + You shouldn't use this function directly. + + It's used internally to recognize when a default value has been overwritten, even + if the new value is `None`. + """ + return DefaultPlaceholder(value) # type: ignore + + +class CommandInfo: + def __init__( + self, + name: str | None = None, + *, + cls: type["TyperCommand"] | None = None, + context_settings: dict[Any, Any] | None = None, + callback: Callable[..., Any] | None = None, + help: str | None = None, + epilog: str | None = None, + short_help: str | None = None, + options_metavar: str = "[OPTIONS]", + add_help_option: bool = True, + no_args_is_help: bool = False, + hidden: bool = False, + deprecated: bool = False, + # Rich settings + rich_help_panel: str | None = None, + ): + self.name = name + self.cls = cls + self.context_settings = context_settings + self.callback = callback + self.help = help + self.epilog = epilog + self.short_help = short_help + self.options_metavar = options_metavar + self.add_help_option = add_help_option + self.no_args_is_help = no_args_is_help + self.hidden = hidden + self.deprecated = deprecated + # Rich settings + self.rich_help_panel = rich_help_panel + + +class TyperInfo: + def __init__( + self, + typer_instance: Optional["Typer"] = Default(None), + *, + name: str | None = Default(None), + cls: type["TyperGroup"] | None = Default(None), + invoke_without_command: bool = Default(False), + no_args_is_help: bool = Default(False), + subcommand_metavar: str | None = Default(None), + chain: bool = Default(False), + result_callback: Callable[..., Any] | None = Default(None), + # Command + context_settings: dict[Any, Any] | None = Default(None), + callback: Callable[..., Any] | None = Default(None), + help: str | None = Default(None), + epilog: str | None = Default(None), + short_help: str | None = Default(None), + options_metavar: str = Default("[OPTIONS]"), + add_help_option: bool = Default(True), + hidden: bool = Default(False), + deprecated: bool = Default(False), + # Rich settings + rich_help_panel: str | None = Default(None), + ): + self.typer_instance = typer_instance + self.name = name + self.cls = cls + self.invoke_without_command = invoke_without_command + self.no_args_is_help = no_args_is_help + self.subcommand_metavar = subcommand_metavar + self.chain = chain + self.result_callback = result_callback + self.context_settings = context_settings + self.callback = callback + self.help = help + self.epilog = epilog + self.short_help = short_help + self.options_metavar = options_metavar + self.add_help_option = add_help_option + self.hidden = hidden + self.deprecated = deprecated + self.rich_help_panel = rich_help_panel + + +class ParameterInfo: + def __init__( + self, + *, + default: Any | None = None, + param_decls: Sequence[str] | None = None, + callback: Callable[..., Any] | None = None, + metavar: str | None = None, + expose_value: bool = True, + is_eager: bool = False, + envvar: str | list[str] | None = None, + # Note that shell_complete is not fully supported and will be removed in future versions + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None = None, + autocompletion: Callable[..., Any] | None = None, + default_factory: Callable[[], Any] | None = None, + # Custom type + parser: Callable[[str], Any] | None = None, + click_type: click.ParamType | None = None, + # TyperArgument + show_default: bool | str = True, + show_choices: bool = True, + show_envvar: bool = True, + help: str | None = None, + hidden: bool = False, + # Choice + case_sensitive: bool = True, + # Numbers + min: int | float | None = None, + max: int | float | None = None, + clamp: bool = False, + # DateTime + formats: list[str] | None = None, + # File + mode: str | None = None, + encoding: str | None = None, + errors: str | None = "strict", + lazy: bool | None = None, + atomic: bool = False, + # Path + exists: bool = False, + file_okay: bool = True, + dir_okay: bool = True, + writable: bool = False, + readable: bool = True, + resolve_path: bool = False, + allow_dash: bool = False, + path_type: None | type[str] | type[bytes] = None, + # Rich settings + rich_help_panel: str | None = None, + ): + # Check if user has provided multiple custom parsers + if parser and click_type: + raise ValueError( + "Multiple custom type parsers provided. " + "`parser` and `click_type` may not both be provided." + ) + + self.default = default + self.param_decls = param_decls + self.callback = callback + self.metavar = metavar + self.expose_value = expose_value + self.is_eager = is_eager + self.envvar = envvar + self.shell_complete = shell_complete + self.autocompletion = autocompletion + self.default_factory = default_factory + # Custom type + self.parser = parser + self.click_type = click_type + # TyperArgument + self.show_default = show_default + self.show_choices = show_choices + self.show_envvar = show_envvar + self.help = help + self.hidden = hidden + # Choice + self.case_sensitive = case_sensitive + # Numbers + self.min = min + self.max = max + self.clamp = clamp + # DateTime + self.formats = formats + # File + self.mode = mode + self.encoding = encoding + self.errors = errors + self.lazy = lazy + self.atomic = atomic + # Path + self.exists = exists + self.file_okay = file_okay + self.dir_okay = dir_okay + self.writable = writable + self.readable = readable + self.resolve_path = resolve_path + self.allow_dash = allow_dash + self.path_type = path_type + # Rich settings + self.rich_help_panel = rich_help_panel + + +class OptionInfo(ParameterInfo): + def __init__( + self, + *, + # ParameterInfo + default: Any | None = None, + param_decls: Sequence[str] | None = None, + callback: Callable[..., Any] | None = None, + metavar: str | None = None, + expose_value: bool = True, + is_eager: bool = False, + envvar: str | list[str] | None = None, + # Note that shell_complete is not fully supported and will be removed in future versions + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None = None, + autocompletion: Callable[..., Any] | None = None, + default_factory: Callable[[], Any] | None = None, + # Custom type + parser: Callable[[str], Any] | None = None, + click_type: click.ParamType | None = None, + # Option + show_default: bool | str = True, + prompt: bool | str = False, + confirmation_prompt: bool = False, + prompt_required: bool = True, + hide_input: bool = False, + # TODO: remove is_flag and flag_value in a future release + is_flag: bool | None = None, + flag_value: Any | None = None, + count: bool = False, + allow_from_autoenv: bool = True, + help: str | None = None, + hidden: bool = False, + show_choices: bool = True, + show_envvar: bool = True, + # Choice + case_sensitive: bool = True, + # Numbers + min: int | float | None = None, + max: int | float | None = None, + clamp: bool = False, + # DateTime + formats: list[str] | None = None, + # File + mode: str | None = None, + encoding: str | None = None, + errors: str | None = "strict", + lazy: bool | None = None, + atomic: bool = False, + # Path + exists: bool = False, + file_okay: bool = True, + dir_okay: bool = True, + writable: bool = False, + readable: bool = True, + resolve_path: bool = False, + allow_dash: bool = False, + path_type: None | type[str] | type[bytes] = None, + # Rich settings + rich_help_panel: str | None = None, + ): + super().__init__( + default=default, + param_decls=param_decls, + callback=callback, + metavar=metavar, + expose_value=expose_value, + is_eager=is_eager, + envvar=envvar, + shell_complete=shell_complete, + autocompletion=autocompletion, + default_factory=default_factory, + # Custom type + parser=parser, + click_type=click_type, + # TyperArgument + show_default=show_default, + show_choices=show_choices, + show_envvar=show_envvar, + help=help, + hidden=hidden, + # Choice + case_sensitive=case_sensitive, + # Numbers + min=min, + max=max, + clamp=clamp, + # DateTime + formats=formats, + # File + mode=mode, + encoding=encoding, + errors=errors, + lazy=lazy, + atomic=atomic, + # Path + exists=exists, + file_okay=file_okay, + dir_okay=dir_okay, + writable=writable, + readable=readable, + resolve_path=resolve_path, + allow_dash=allow_dash, + path_type=path_type, + # Rich settings + rich_help_panel=rich_help_panel, + ) + if is_flag is not None or flag_value is not None: + import warnings + + warnings.warn( + "The 'is_flag' and 'flag_value' parameters are not supported by Typer " + "and will be removed entirely in a future release.", + DeprecationWarning, + stacklevel=2, + ) + self.prompt = prompt + self.confirmation_prompt = confirmation_prompt + self.prompt_required = prompt_required + self.hide_input = hide_input + self.count = count + self.allow_from_autoenv = allow_from_autoenv + + +class ArgumentInfo(ParameterInfo): + def __init__( + self, + *, + # ParameterInfo + default: Any | None = None, + param_decls: Sequence[str] | None = None, + callback: Callable[..., Any] | None = None, + metavar: str | None = None, + expose_value: bool = True, + is_eager: bool = False, + envvar: str | list[str] | None = None, + # Note that shell_complete is not fully supported and will be removed in future versions + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None = None, + autocompletion: Callable[..., Any] | None = None, + default_factory: Callable[[], Any] | None = None, + # Custom type + parser: Callable[[str], Any] | None = None, + click_type: click.ParamType | None = None, + # TyperArgument + show_default: bool | str = True, + show_choices: bool = True, + show_envvar: bool = True, + help: str | None = None, + hidden: bool = False, + # Choice + case_sensitive: bool = True, + # Numbers + min: int | float | None = None, + max: int | float | None = None, + clamp: bool = False, + # DateTime + formats: list[str] | None = None, + # File + mode: str | None = None, + encoding: str | None = None, + errors: str | None = "strict", + lazy: bool | None = None, + atomic: bool = False, + # Path + exists: bool = False, + file_okay: bool = True, + dir_okay: bool = True, + writable: bool = False, + readable: bool = True, + resolve_path: bool = False, + allow_dash: bool = False, + path_type: None | type[str] | type[bytes] = None, + # Rich settings + rich_help_panel: str | None = None, + ): + super().__init__( + default=default, + param_decls=param_decls, + callback=callback, + metavar=metavar, + expose_value=expose_value, + is_eager=is_eager, + envvar=envvar, + shell_complete=shell_complete, + autocompletion=autocompletion, + default_factory=default_factory, + # Custom type + parser=parser, + click_type=click_type, + # TyperArgument + show_default=show_default, + show_choices=show_choices, + show_envvar=show_envvar, + help=help, + hidden=hidden, + # Choice + case_sensitive=case_sensitive, + # Numbers + min=min, + max=max, + clamp=clamp, + # DateTime + formats=formats, + # File + mode=mode, + encoding=encoding, + errors=errors, + lazy=lazy, + atomic=atomic, + # Path + exists=exists, + file_okay=file_okay, + dir_okay=dir_okay, + writable=writable, + readable=readable, + resolve_path=resolve_path, + allow_dash=allow_dash, + path_type=path_type, + # Rich settings + rich_help_panel=rich_help_panel, + ) + + +class ParamMeta: + empty = inspect.Parameter.empty + + def __init__( + self, + *, + name: str, + default: Any = inspect.Parameter.empty, + annotation: Any = inspect.Parameter.empty, + ) -> None: + self.name = name + self.default = default + self.annotation = annotation + + +class DeveloperExceptionConfig: + def __init__( + self, + *, + pretty_exceptions_enable: bool = True, + pretty_exceptions_show_locals: bool = True, + pretty_exceptions_short: bool = True, + ) -> None: + self.pretty_exceptions_enable = pretty_exceptions_enable + self.pretty_exceptions_show_locals = pretty_exceptions_show_locals + self.pretty_exceptions_short = pretty_exceptions_short + + +class TyperPath(click.Path): + # Overwrite Click's behaviour to be compatible with Typer's autocompletion system + def shell_complete( + self, ctx: click.Context, param: click.Parameter, incomplete: str + ) -> list[click.shell_completion.CompletionItem]: + """Return an empty list so that the autocompletion functionality + will work properly from the commandline. + """ + return [] diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/params.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/params.py new file mode 100644 index 0000000000000000000000000000000000000000..b325b273c43860f79f598c11e971f60f2c95676f --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/params.py @@ -0,0 +1,1831 @@ +from collections.abc import Callable +from typing import TYPE_CHECKING, Annotated, Any, overload + +import click +from annotated_doc import Doc + +from .models import ArgumentInfo, OptionInfo + +if TYPE_CHECKING: # pragma: no cover + import click.shell_completion + + +# Overload for Option created with custom type 'parser' +@overload +def Option( + # Parameter + default: Any | None = ..., + *param_decls: str, + callback: Callable[..., Any] | None = None, + metavar: str | None = None, + expose_value: bool = True, + is_eager: bool = False, + envvar: str | list[str] | None = None, + # Note that shell_complete is not fully supported and will be removed in future versions + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None = None, + autocompletion: Callable[..., Any] | None = None, + default_factory: Callable[[], Any] | None = None, + # Custom type + parser: Callable[[str], Any] | None = None, + # Option + show_default: bool | str = True, + prompt: bool | str = False, + confirmation_prompt: bool = False, + prompt_required: bool = True, + hide_input: bool = False, + # TODO: remove is_flag and flag_value in a future release + is_flag: bool | None = None, + flag_value: Any | None = None, + count: bool = False, + allow_from_autoenv: bool = True, + help: str | None = None, + hidden: bool = False, + show_choices: bool = True, + show_envvar: bool = True, + # Choice + case_sensitive: bool = True, + # Numbers + min: int | float | None = None, + max: int | float | None = None, + clamp: bool = False, + # DateTime + formats: list[str] | None = None, + # File + mode: str | None = None, + encoding: str | None = None, + errors: str | None = "strict", + lazy: bool | None = None, + atomic: bool = False, + # Path + exists: bool = False, + file_okay: bool = True, + dir_okay: bool = True, + writable: bool = False, + readable: bool = True, + resolve_path: bool = False, + allow_dash: bool = False, + path_type: None | type[str] | type[bytes] = None, + # Rich settings + rich_help_panel: str | None = None, +) -> Any: ... + + +# Overload for Option created with custom type 'click_type' +@overload +def Option( + # Parameter + default: Any | None = ..., + *param_decls: str, + callback: Callable[..., Any] | None = None, + metavar: str | None = None, + expose_value: bool = True, + is_eager: bool = False, + envvar: str | list[str] | None = None, + # Note that shell_complete is not fully supported and will be removed in future versions + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None = None, + autocompletion: Callable[..., Any] | None = None, + default_factory: Callable[[], Any] | None = None, + # Custom type + click_type: click.ParamType | None = None, + # Option + show_default: bool | str = True, + prompt: bool | str = False, + confirmation_prompt: bool = False, + prompt_required: bool = True, + hide_input: bool = False, + # TODO: remove is_flag and flag_value in a future release + is_flag: bool | None = None, + flag_value: Any | None = None, + count: bool = False, + allow_from_autoenv: bool = True, + help: str | None = None, + hidden: bool = False, + show_choices: bool = True, + show_envvar: bool = True, + # Choice + case_sensitive: bool = True, + # Numbers + min: int | float | None = None, + max: int | float | None = None, + clamp: bool = False, + # DateTime + formats: list[str] | None = None, + # File + mode: str | None = None, + encoding: str | None = None, + errors: str | None = "strict", + lazy: bool | None = None, + atomic: bool = False, + # Path + exists: bool = False, + file_okay: bool = True, + dir_okay: bool = True, + writable: bool = False, + readable: bool = True, + resolve_path: bool = False, + allow_dash: bool = False, + path_type: None | type[str] | type[bytes] = None, + # Rich settings + rich_help_panel: str | None = None, +) -> Any: ... + + +def Option( + # Parameter + default: Annotated[ + Any | None, + Doc( + """ + Usually, [CLI options](https://typer.tiangolo.com/tutorial/options/) are optional and have a default value, passed on like this: + + **Example** + + ```python + @app.command() + def main(network: str = typer.Option("CNN")): + print(f"Training neural network of type: {network}") + ``` + + Note that this usage is deprecated, and we recommend to use `Annotated` instead: + ``` + @app.command() + def main(network: Annotated[str, typer.Option()] = "CNN"): + print(f"Hello {name}!") + ``` + + You can also use `...` ([Ellipsis](https://docs.python.org/3/library/constants.html#Ellipsis)) as the "default" value to clarify that this is a required CLI option. + """ + ), + ] = ..., + *param_decls: Annotated[ + str, + Doc( + """ + Positional argument that defines how users can call this option on the command line. This may be one or multiple aliases, all strings. + If not defined, Typer will automatically use the function parameter as default name. + See [the tutorial about CLI Option Names](https://typer.tiangolo.com/tutorial/options/name/) for more details. + + **Example** + + ```python + @app.command() + def main(user_name: Annotated[str, typer.Option("--user", "-u", "-x")]): + print(f"Hello {user_name}") + ``` + """ + ), + ], + callback: Annotated[ + Callable[..., Any] | None, + Doc( + """ + Add a callback to this CLI Option, to execute additional logic after its value was received from the terminal. + See [the tutorial about callbacks](https://typer.tiangolo.com/tutorial/options/callback-and-context/) for more details. + + **Example** + + ```python + def name_callback(value: str): + if value != "Deadpool": + raise typer.BadParameter("Only Deadpool is allowed") + return value + + @app.command() + def main(name: Annotated[str, typer.Option(callback=name_callback)]): + print(f"Hello {name}") + ``` + """ + ), + ] = None, + metavar: Annotated[ + str | None, + Doc( + """ + Customize the name displayed in the [help text](https://typer.tiangolo.com/tutorial/options/help/) to represent this CLI option. + Note that this doesn't influence the way the option must be called. + + **Example** + + ```python + @app.command() + def main(user: Annotated[str, typer.Option(metavar="User name")]): + print(f"Hello {user}") + ``` + """ + ), + ] = None, + expose_value: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + + --- + + If this is `True` then the value is passed onwards to the command callback and stored on the context, otherwise it’s skipped. + """ + ), + ] = True, + is_eager: Annotated[ + bool, + Doc( + """ + Mark a CLI Option to be "eager", ensuring it gets processed before other CLI parameters. This could be relevant when there are other parameters with callbacks that could exit the program early. + For more information and an extended example, see the documentation [here](https://typer.tiangolo.com/tutorial/options/version/#fix-with-is_eager). + """ + ), + ] = False, + envvar: Annotated[ + str | list[str] | None, + Doc( + """ + Configure a CLI Option to read its value from an environment variable if it is not provided in the command line. + For more information, see the [documentation on Environment Variables](https://typer.tiangolo.com/tutorial/arguments/envvar/). + + **Example** + + ```python + @app.command() + def main(user: Annotated[str, typer.Option(envvar="ME")]): + print(f"Hello {user}") + ``` + """ + ), + ] = None, + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Annotated[ + Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + It is however not fully functional, and will likely be removed in future versions. + """ + ), + ] = None, + autocompletion: Annotated[ + Callable[..., Any] | None, + Doc( + """ + Provide a custom function that helps to autocomplete the values of this CLI Option. + See [the tutorial on parameter autocompletion](https://typer.tiangolo.com/tutorial/options-autocompletion) for more details. + + **Example** + + ```python + def complete(): + return ["Me", "Myself", "I"] + + @app.command() + def main(name: Annotated[str, typer.Option(autocompletion=complete)]): + print(f"Hello {name}") + ``` + """ + ), + ] = None, + default_factory: Annotated[ + Callable[[], Any] | None, + Doc( + """ + Provide a custom function that dynamically generates a [default](https://typer.tiangolo.com/tutorial/arguments/default) for this CLI Option. + + **Example** + + ```python + def get_name(): + return random.choice(["Me", "Myself", "I"]) + + @app.command() + def main(name: Annotated[str, typer.Option(default_factory=get_name)]): + print(f"Hello {name}") + ``` + """ + ), + ] = None, + # Custom type + parser: Annotated[ + Callable[[str], Any] | None, + Doc( + """ + Use your own custom types in Typer applications by defining a `parser` function that parses input into your own types: + + **Example** + + ```python + class CustomClass: + def __init__(self, value: str): + self.value = value + + def __str__(self): + return f"" + + def my_parser(value: str): + return CustomClass(value * 2) + + @app.command() + def main(opt: Annotated[CustomClass, typer.Option(parser=my_parser)] = "Foo"): + print(f"--opt is {opt}") + ``` + """ + ), + ] = None, + click_type: Annotated[ + click.ParamType | None, + Doc( + """ + Define this parameter to use a [custom Click type](https://click.palletsprojects.com/en/stable/parameters/#implementing-custom-types) in your Typer applications. + + **Example** + + ```python + class MyClass: + def __init__(self, value: str): + self.value = value + + def __str__(self): + return f"" + + class MyParser(click.ParamType): + name = "MyClass" + + def convert(self, value, param, ctx): + return MyClass(value * 3) + + @app.command() + def main(opt: Annotated[MyClass, typer.Option(click_type=MyParser())] = "Foo"): + print(f"--opt is {opt}") + ``` + """ + ), + ] = None, + # Option + show_default: Annotated[ + bool | str, + Doc( + """ + When set to `False`, don't show the default value of this CLI Option in the [help text](https://typer.tiangolo.com/tutorial/options/help/). + + **Example** + + ```python + @app.command() + def main(name: Annotated[str, typer.Option(show_default=False)] = "Rick"): + print(f"Hello {name}") + ``` + """ + ), + ] = True, + prompt: Annotated[ + bool | str, + Doc( + """ + When set to `True`, a prompt will appear to ask for the value of this CLI Option if it was not provided: + + **Example** + + ```python + @app.command() + def main(name: str, lastname: Annotated[str, typer.Option(prompt=True)]): + print(f"Hello {name} {lastname}") + ``` + """ + ), + ] = False, + confirmation_prompt: Annotated[ + bool, + Doc( + """ + When set to `True`, a user will need to type a prompted value twice (may be useful for passwords etc.). + + **Example** + + ```python + @app.command() + def main(project: Annotated[str, typer.Option(prompt=True, confirmation_prompt=True)]): + print(f"Deleting project {project}") + ``` + """ + ), + ] = False, + prompt_required: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + + --- + + If this is `False` then a prompt is only shown if the option's flag is given without a value. + """ + ), + ] = True, + hide_input: Annotated[ + bool, + Doc( + """ + When you've configured a prompt, for instance for [querying a password](https://typer.tiangolo.com/tutorial/options/password/), + don't show anything on the screen while the user is typing the value. + + **Example** + + ```python + @app.command() + def login( + name: str, + password: Annotated[str, typer.Option(prompt=True, hide_input=True)], + ): + print(f"Hello {name}. Doing something very secure with password.") + ``` + """ + ), + ] = False, + # TODO: remove is_flag and flag_value in a future release + is_flag: Annotated[ + bool | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + It is however not fully functional, and will likely be removed in future versions. + """ + ), + ] = None, + flag_value: Annotated[ + Any | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + It is however not fully functional, and will likely be removed in future versions. + """ + ), + ] = None, + count: Annotated[ + bool, + Doc( + """ + Make a CLI Option work as a [counter](https://typer.tiangolo.com/tutorial/parameter-types/number/#counter-cli-options). + The CLI option will have the `int` value representing the number of times the option was used on the command line. + + **Example** + + ```python + @app.command() + def main(verbose: Annotated[int, typer.Option("--verbose", "-v", count=True)] = 0): + print(f"Verbose level is {verbose}") + ``` + """ + ), + ] = False, + allow_from_autoenv: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + + --- + + If this is enabled then the value of this parameter will be pulled from an environment variable in case a prefix is defined on the context. + """ + ), + ] = True, + help: Annotated[ + str | None, + Doc( + """ + Help text for this CLI Option. + See [the tutorial about CLI Options with help](https://typer.tiangolo.com/tutorial/options/help/) for more dedails. + + **Example** + + ```python + @app.command() + def greet(name: Annotated[str, typer.Option(help="Person to greet")] = "Deadpool"): + print(f"Hello {name}") + ``` + """ + ), + ] = None, + hidden: Annotated[ + bool, + Doc( + """ + Hide this CLI Option from [help outputs](https://typer.tiangolo.com/tutorial/options/help). `False` by default. + + **Example** + + ```python + @app.command() + def greet(name: Annotated[str, typer.Option(hidden=True)] = "Deadpool"): + print(f"Hello {name}") + ``` + """ + ), + ] = False, + show_choices: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + + --- + + When set to `False`, this suppresses choices from being displayed inline when `prompt` is used. + """ + ), + ] = True, + show_envvar: Annotated[ + bool, + Doc( + """ + When an ["envvar"](https://typer.tiangolo.com/tutorial/arguments/envvar) is defined, prevent it from showing up in the help text: + + **Example** + + ```python + @app.command() + def main(user: Annotated[str, typer.Option(envvar="ME", show_envvar=False)]): + print(f"Hello {user}") + ``` + """ + ), + ] = True, + # Choice + case_sensitive: Annotated[ + bool, + Doc( + """ + For a CLI Option representing an [Enum (choice)](https://typer.tiangolo.com/tutorial/parameter-types/enum), + you can allow case-insensitive matching with this parameter: + + **Example** + + ```python + from enum import Enum + + class NeuralNetwork(str, Enum): + simple = "simple" + conv = "conv" + lstm = "lstm" + + @app.command() + def main( + network: Annotated[NeuralNetwork, typer.Option(case_sensitive=False)]): + print(f"Training neural network of type: {network.value}") + ``` + + With this setting, "LSTM" or "lstm" will both be valid values that will be resolved to `NeuralNetwork.lstm`. + """ + ), + ] = True, + # Numbers + min: Annotated[ + int | float | None, + Doc( + """ + For a CLI Option representing a [number](https://typer.tiangolo.com/tutorial/parameter-types/number/) (`int` or `float`), + you can define numeric validations with `min` and `max` values: + + **Example** + + ```python + @app.command() + def main( + user: Annotated[str, typer.Argument()], + user_id: Annotated[int, typer.Option(min=1, max=1000)], + ): + print(f"ID for {user} is {user_id}") + ``` + + If the user attempts to input an invalid number, an error will be shown, explaining why the value is invalid. + """ + ), + ] = None, + max: Annotated[ + int | float | None, + Doc( + """ + For a CLI Option representing a [number](https://typer.tiangolo.com/tutorial/parameter-types/number/) (`int` or `float`), + you can define numeric validations with `min` and `max` values: + + **Example** + + ```python + @app.command() + def main( + user: Annotated[str, typer.Argument()], + user_id: Annotated[int, typer.Option(min=1, max=1000)], + ): + print(f"ID for {user} is {user_id}") + ``` + + If the user attempts to input an invalid number, an error will be shown, explaining why the value is invalid. + """ + ), + ] = None, + clamp: Annotated[ + bool, + Doc( + """ + For a CLI Option representing a [number](https://typer.tiangolo.com/tutorial/parameter-types/number/) and that is bounded by using `min` and/or `max`, + you can opt to use the closest minimum or maximum value instead of raising an error when the value is out of bounds. This is done by setting `clamp` to `True`. + + **Example** + + ```python + @app.command() + def main( + user: Annotated[str, typer.Argument()], + user_id: Annotated[int, typer.Option(min=1, max=1000, clamp=True)], + ): + print(f"ID for {user} is {user_id}") + ``` + + If the user attempts to input 3420 for `user_id`, this will internally be converted to `1000`. + """ + ), + ] = False, + # DateTime + formats: Annotated[ + list[str] | None, + Doc( + """ + For a CLI Option representing a [DateTime object](https://typer.tiangolo.com/tutorial/parameter-types/datetime), + you can customize the formats that can be parsed automatically: + + **Example** + + ```python + from datetime import datetime + + @app.command() + def main( + birthday: Annotated[ + datetime, + typer.Option( + formats=["%Y-%m-%d", "%Y-%m-%d %H:%M:%S", "%m/%d/%Y"] + ), + ], + ): + print(f"Birthday defined at: {birthday}") + ``` + """ + ), + ] = None, + # File + mode: Annotated[ + str | None, + Doc( + """ + For a CLI Option representing a [File object](https://typer.tiangolo.com/tutorial/parameter-types/file/), + you can customize the mode to open the file with. If unset, Typer will set a [sensible value by default](https://typer.tiangolo.com/tutorial/parameter-types/file/#advanced-mode). + + **Example** + + ```python + @app.command() + def main(config: Annotated[typer.FileText, typer.Option(mode="a")]): + config.write("This is a single line\\n") + print("Config line written") + ``` + """ + ), + ] = None, + encoding: Annotated[ + str | None, + Doc( + """ + Customize the encoding of this CLI Option represented by a [File object](https://typer.tiangolo.com/tutorial/parameter-types/file/). + + **Example** + + ```python + @app.command() + def main(config: Annotated[typer.FileText, typer.Option(encoding="utf-8")]): + config.write("All the text gets written\\n") + ``` + """ + ), + ] = None, + errors: Annotated[ + str | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + + --- + + The error handling mode. + """ + ), + ] = "strict", + lazy: Annotated[ + bool | None, + Doc( + """ + For a CLI Option representing a [File object](https://typer.tiangolo.com/tutorial/parameter-types/file/), + by default the file will not be created until you actually start writing to it. + You can change this behaviour by setting this parameter. + By default, it's set to `True` for writing and to `False` for reading. + + **Example** + + ```python + @app.command() + def main(config: Annotated[typer.FileText, typer.Option(mode="a", lazy=False)]): + config.write("This is a single line\\n") + print("Config line written") + ``` + """ + ), + ] = None, + atomic: Annotated[ + bool, + Doc( + """ + For a CLI Option representing a [File object](https://typer.tiangolo.com/tutorial/parameter-types/file/), + you can ensure that all write instructions first go into a temporal file, and are only moved to the final destination after completing + by setting `atomic` to `True`. This can be useful for files with potential concurrent access. + + **Example** + + ```python + @app.command() + def main(config: Annotated[typer.FileText, typer.Option(mode="a", atomic=True)]): + config.write("All the text") + ``` + """ + ), + ] = False, + # Path + exists: Annotated[ + bool, + Doc( + """ + When set to `True` for a [`Path` CLI Option](https://typer.tiangolo.com/tutorial/parameter-types/path/), + additional validation is performed to check that the file or directory exists. If not, the value will be invalid. + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Option(exists=True)]): + text = config.read_text() + print(f"Config file contents: {text}") + ``` + """ + ), + ] = False, + file_okay: Annotated[ + bool, + Doc( + """ + Determine whether or not a [`Path` CLI Option](https://typer.tiangolo.com/tutorial/parameter-types/path/) + is allowed to refer to a file. When this is set to `False`, the application will raise a validation error when a path to a file is given. + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Option(exists=True, file_okay=False)]): + print(f"Directory listing: {[x.name for x in config.iterdir()]}") + ``` + """ + ), + ] = True, + dir_okay: Annotated[ + bool, + Doc( + """ + Determine whether or not a [`Path` CLI Option](https://typer.tiangolo.com/tutorial/parameter-types/path/) + is allowed to refer to a directory. When this is set to `False`, the application will raise a validation error when a path to a directory is given. + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Argument(exists=True, dir_okay=False)]): + text = config.read_text() + print(f"Config file contents: {text}") + ``` + """ + ), + ] = True, + writable: Annotated[ + bool, + Doc( + """ + Whether or not to perform a writable check for this [`Path` CLI Option](https://typer.tiangolo.com/tutorial/parameter-types/path/). + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Option(writable=True)]): + config.write_text("All the text") + ``` + """ + ), + ] = False, + readable: Annotated[ + bool, + Doc( + """ + Whether or not to perform a readable check for this [`Path` CLI Option](https://typer.tiangolo.com/tutorial/parameter-types/path/). + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Option(readable=True)]): + config.read_text("All the text") + ``` + """ + ), + ] = True, + resolve_path: Annotated[ + bool, + Doc( + """ + Whether or not to fully resolve the path of this [`Path` CLI Option](https://typer.tiangolo.com/tutorial/parameter-types/path/), + meaning that the path becomes absolute and symlinks are resolved. + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Option(resolve_path=True)]): + config.read_text("All the text") + ``` + """ + ), + ] = False, + allow_dash: Annotated[ + bool, + Doc( + """ + When set to `True`, a single dash for this [`Path` CLI Option](https://typer.tiangolo.com/tutorial/parameter-types/path/) + would be a valid value, indicating standard streams. This is a more advanced use-case. + """ + ), + ] = False, + path_type: Annotated[ + None | type[str] | type[bytes], + Doc( + """ + A string type that will be used to represent this [`Path` argument](https://typer.tiangolo.com/tutorial/parameter-types/path/). + The default is `None` which means the return value will be either bytes or unicode, depending on what makes most sense given the input data. + This is a more advanced use-case. + """ + ), + ] = None, + # Rich settings + rich_help_panel: Annotated[ + str | None, + Doc( + """ + Set the panel name where you want this CLI Option to be shown in the [help text](https://typer.tiangolo.com/tutorial/arguments/help). + + **Example** + + ```python + @app.command() + def main( + name: Annotated[str, typer.Argument(help="Who to greet")], + age: Annotated[str, typer.Option(help="Their age", rich_help_panel="Data")], + ): + print(f"Hello {name} of age {age}") + ``` + """ + ), + ] = None, +) -> Any: + """ + A [CLI Option](https://typer.tiangolo.com/tutorial/options) is a parameter to your command line application that is called with a single or double dash, something like `--verbose` or `-v`. + + Often, CLI Options are optional, meaning that users can omit them from the command. However, you can set them to be required by using `Annotated` + and omitting a default value. + + ## Example + + ```python + @app.command() + def register( + user: Annotated[str, typer.Argument()], + age: Annotated[int, typer.Option(min=18)], + ): + print(f"User is {user}") + print(f"--age is {age}") + ``` + + Note how in this example, `--age` is a required CLI Option. + """ + return OptionInfo( + # Parameter + default=default, + param_decls=param_decls, + callback=callback, + metavar=metavar, + expose_value=expose_value, + is_eager=is_eager, + envvar=envvar, + shell_complete=shell_complete, + autocompletion=autocompletion, + default_factory=default_factory, + # Custom type + parser=parser, + click_type=click_type, + # Option + show_default=show_default, + prompt=prompt, + confirmation_prompt=confirmation_prompt, + prompt_required=prompt_required, + hide_input=hide_input, + is_flag=is_flag, + flag_value=flag_value, + count=count, + allow_from_autoenv=allow_from_autoenv, + help=help, + hidden=hidden, + show_choices=show_choices, + show_envvar=show_envvar, + # Choice + case_sensitive=case_sensitive, + # Numbers + min=min, + max=max, + clamp=clamp, + # DateTime + formats=formats, + # File + mode=mode, + encoding=encoding, + errors=errors, + lazy=lazy, + atomic=atomic, + # Path + exists=exists, + file_okay=file_okay, + dir_okay=dir_okay, + writable=writable, + readable=readable, + resolve_path=resolve_path, + allow_dash=allow_dash, + path_type=path_type, + # Rich settings + rich_help_panel=rich_help_panel, + ) + + +# Overload for Argument created with custom type 'parser' +@overload +def Argument( + # Parameter + default: Any | None = ..., + *, + callback: Callable[..., Any] | None = None, + metavar: str | None = None, + expose_value: bool = True, + is_eager: bool = False, + envvar: str | list[str] | None = None, + # Note that shell_complete is not fully supported and will be removed in future versions + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None = None, + autocompletion: Callable[..., Any] | None = None, + default_factory: Callable[[], Any] | None = None, + # Custom type + parser: Callable[[str], Any] | None = None, + # TyperArgument + show_default: bool | str = True, + show_choices: bool = True, + show_envvar: bool = True, + help: str | None = None, + hidden: bool = False, + # Choice + case_sensitive: bool = True, + # Numbers + min: int | float | None = None, + max: int | float | None = None, + clamp: bool = False, + # DateTime + formats: list[str] | None = None, + # File + mode: str | None = None, + encoding: str | None = None, + errors: str | None = "strict", + lazy: bool | None = None, + atomic: bool = False, + # Path + exists: bool = False, + file_okay: bool = True, + dir_okay: bool = True, + writable: bool = False, + readable: bool = True, + resolve_path: bool = False, + allow_dash: bool = False, + path_type: None | type[str] | type[bytes] = None, + # Rich settings + rich_help_panel: str | None = None, +) -> Any: ... + + +# Overload for Argument created with custom type 'click_type' +@overload +def Argument( + # Parameter + default: Any | None = ..., + *, + callback: Callable[..., Any] | None = None, + metavar: str | None = None, + expose_value: bool = True, + is_eager: bool = False, + envvar: str | list[str] | None = None, + # Note that shell_complete is not fully supported and will be removed in future versions + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None = None, + autocompletion: Callable[..., Any] | None = None, + default_factory: Callable[[], Any] | None = None, + # Custom type + click_type: click.ParamType | None = None, + # TyperArgument + show_default: bool | str = True, + show_choices: bool = True, + show_envvar: bool = True, + help: str | None = None, + hidden: bool = False, + # Choice + case_sensitive: bool = True, + # Numbers + min: int | float | None = None, + max: int | float | None = None, + clamp: bool = False, + # DateTime + formats: list[str] | None = None, + # File + mode: str | None = None, + encoding: str | None = None, + errors: str | None = "strict", + lazy: bool | None = None, + atomic: bool = False, + # Path + exists: bool = False, + file_okay: bool = True, + dir_okay: bool = True, + writable: bool = False, + readable: bool = True, + resolve_path: bool = False, + allow_dash: bool = False, + path_type: None | type[str] | type[bytes] = None, + # Rich settings + rich_help_panel: str | None = None, +) -> Any: ... + + +def Argument( + # Parameter + default: Annotated[ + Any | None, + Doc( + """ + By default, CLI arguments are required. However, by giving them a default value they become [optional](https://typer.tiangolo.com/tutorial/arguments/optional): + + **Example** + + ```python + @app.command() + def main(name: str = typer.Argument("World")): + print(f"Hello {name}!") + ``` + + Note that this usage is deprecated, and we recommend to use `Annotated` instead: + ```python + @app.command() + def main(name: Annotated[str, typer.Argument()] = "World"): + print(f"Hello {name}!") + ``` + """ + ), + ] = ..., + *, + callback: Annotated[ + Callable[..., Any] | None, + Doc( + """ + Add a callback to this CLI Argument, to execute additional logic with the value received from the terminal. + See [the tutorial about callbacks](https://typer.tiangolo.com/tutorial/options/callback-and-context/) for more details. + + **Example** + + ```python + def name_callback(value: str): + if value != "Deadpool": + raise typer.BadParameter("Only Deadpool is allowed") + return value + + @app.command() + def main(name: Annotated[str, typer.Argument(callback=name_callback)]): + print(f"Hello {name}") + ``` + """ + ), + ] = None, + metavar: Annotated[ + str | None, + Doc( + """ + Customize the name displayed in the help text to represent this CLI Argument. + By default, it will be the same name you declared, in uppercase. + See [the tutorial about CLI Arguments with Help](https://typer.tiangolo.com/tutorial/arguments/help/#custom-help-name-metavar) for more details. + + **Example** + + ```python + @app.command() + def main(name: Annotated[str, typer.Argument(metavar="✨username✨")]): + print(f"Hello {name}") + ``` + """ + ), + ] = None, + expose_value: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + + --- + + If this is `True` then the value is passed onwards to the command callback and stored on the context, otherwise it’s skipped. + """ + ), + ] = True, + is_eager: Annotated[ + bool, + Doc( + """ + Set an argument to "eager" to ensure it gets processed before other CLI parameters. This could be relevant when there are other parameters with callbacks that could exit the program early. + For more information and an extended example, see the documentation [here](https://typer.tiangolo.com/tutorial/options/version/#fix-with-is_eager). + """ + ), + ] = False, + envvar: Annotated[ + str | list[str] | None, + Doc( + """ + Configure an argument to read a value from an environment variable if it is not provided in the command line as a CLI argument. + For more information, see the [documentation on Environment Variables](https://typer.tiangolo.com/tutorial/arguments/envvar/). + + **Example** + + ```python + @app.command() + def main(name: Annotated[str, typer.Argument(envvar="ME")]): + print(f"Hello Mr. {name}") + ``` + """ + ), + ] = None, + # TODO: Remove shell_complete in a future version (after 0.16.0) + shell_complete: Annotated[ + Callable[ + [click.Context, click.Parameter, str], + list["click.shell_completion.CompletionItem"] | list[str], + ] + | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + It is however not fully functional, and will likely be removed in future versions. + """ + ), + ] = None, + autocompletion: Annotated[ + Callable[..., Any] | None, + Doc( + """ + Provide a custom function that helps to autocomplete the values of this CLI Argument. + See [the tutorial on parameter autocompletion](https://typer.tiangolo.com/tutorial/options-autocompletion) for more details. + + **Example** + + ```python + def complete(): + return ["Me", "Myself", "I"] + + @app.command() + def main(name: Annotated[str, typer.Argument(autocompletion=complete)]): + print(f"Hello {name}") + ``` + """ + ), + ] = None, + default_factory: Annotated[ + Callable[[], Any] | None, + Doc( + """ + Provide a custom function that dynamically generates a [default](https://typer.tiangolo.com/tutorial/arguments/default) for this CLI Argument. + + **Example** + + ```python + def get_name(): + return random.choice(["Me", "Myself", "I"]) + + @app.command() + def main(name: Annotated[str, typer.Argument(default_factory=get_name)]): + print(f"Hello {name}") + ``` + """ + ), + ] = None, + # Custom type + parser: Annotated[ + Callable[[str], Any] | None, + Doc( + """ + Use your own custom types in Typer applications by defining a `parser` function that parses input into your own types: + + **Example** + + ```python + class CustomClass: + def __init__(self, value: str): + self.value = value + + def __str__(self): + return f"" + + def my_parser(value: str): + return CustomClass(value * 2) + + @app.command() + def main(arg: Annotated[CustomClass, typer.Argument(parser=my_parser): + print(f"arg is {arg}") + ``` + """ + ), + ] = None, + click_type: Annotated[ + click.ParamType | None, + Doc( + """ + Define this parameter to use a [custom Click type](https://click.palletsprojects.com/en/stable/parameters/#implementing-custom-types) in your Typer applications. + + **Example** + + ```python + class MyClass: + def __init__(self, value: str): + self.value = value + + def __str__(self): + return f"" + + class MyParser(click.ParamType): + name = "MyClass" + + def convert(self, value, param, ctx): + return MyClass(value * 3) + + @app.command() + def main(arg: Annotated[MyClass, typer.Argument(click_type=MyParser())]): + print(f"arg is {arg}") + ``` + """ + ), + ] = None, + # TyperArgument + show_default: Annotated[ + bool | str, + Doc( + """ + When set to `False`, don't show the default value of this CLI Argument in the [help text](https://typer.tiangolo.com/tutorial/arguments/help/). + + **Example** + + ```python + @app.command() + def main(name: Annotated[str, typer.Argument(show_default=False)] = "Rick"): + print(f"Hello {name}") + ``` + """ + ), + ] = True, + show_choices: Annotated[ + bool, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + + --- + + When set to `False`, this suppresses choices from being displayed inline when `prompt` is used. + """ + ), + ] = True, + show_envvar: Annotated[ + bool, + Doc( + """ + When an ["envvar"](https://typer.tiangolo.com/tutorial/arguments/envvar) is defined, prevent it from showing up in the help text: + + **Example** + + ```python + @app.command() + def main(name: Annotated[str, typer.Argument(envvar="ME", show_envvar=False)]): + print(f"Hello Mr. {name}") + ``` + """ + ), + ] = True, + help: Annotated[ + str | None, + Doc( + """ + Help text for this CLI Argument. + See [the tutorial about CLI Arguments with help](https://typer.tiangolo.com/tutorial/arguments/help/) for more dedails. + + **Example** + + ```python + @app.command() + def greet(name: Annotated[str, typer.Argument(help="Person to greet")]): + print(f"Hello {name}") + ``` + """ + ), + ] = None, + hidden: Annotated[ + bool, + Doc( + """ + Hide this CLI Argument from [help outputs](https://typer.tiangolo.com/tutorial/arguments/help). `False` by default. + + **Example** + + ```python + @app.command() + def main(name: Annotated[str, typer.Argument(hidden=True)] = "World"): + print(f"Hello {name}") + ``` + """ + ), + ] = False, + # Choice + case_sensitive: Annotated[ + bool, + Doc( + """ + For a CLI Argument representing an [Enum (choice)](https://typer.tiangolo.com/tutorial/parameter-types/enum), + you can allow case-insensitive matching with this parameter: + + **Example** + + ```python + from enum import Enum + + class NeuralNetwork(str, Enum): + simple = "simple" + conv = "conv" + lstm = "lstm" + + @app.command() + def main( + network: Annotated[NeuralNetwork, typer.Argument(case_sensitive=False)]): + print(f"Training neural network of type: {network.value}") + ``` + + With this setting, "LSTM" or "lstm" will both be valid values that will be resolved to `NeuralNetwork.lstm`. + """ + ), + ] = True, + # Numbers + min: Annotated[ + int | float | None, + Doc( + """ + For a CLI Argument representing a [number](https://typer.tiangolo.com/tutorial/parameter-types/number/) (`int` or `float`), + you can define numeric validations with `min` and `max` values: + + **Example** + + ```python + @app.command() + def main( + user: Annotated[str, typer.Argument()], + user_id: Annotated[int, typer.Argument(min=1, max=1000)], + ): + print(f"ID for {user} is {user_id}") + ``` + + If the user attempts to input an invalid number, an error will be shown, explaining why the value is invalid. + """ + ), + ] = None, + max: Annotated[ + int | float | None, + Doc( + """ + For a CLI Argument representing a [number](https://typer.tiangolo.com/tutorial/parameter-types/number/) (`int` or `float`), + you can define numeric validations with `min` and `max` values: + + **Example** + + ```python + @app.command() + def main( + user: Annotated[str, typer.Argument()], + user_id: Annotated[int, typer.Argument(min=1, max=1000)], + ): + print(f"ID for {user} is {user_id}") + ``` + + If the user attempts to input an invalid number, an error will be shown, explaining why the value is invalid. + """ + ), + ] = None, + clamp: Annotated[ + bool, + Doc( + """ + For a CLI Argument representing a [number](https://typer.tiangolo.com/tutorial/parameter-types/number/) and that is bounded by using `min` and/or `max`, + you can opt to use the closest minimum or maximum value instead of raising an error. This is done by setting `clamp` to `True`. + + **Example** + + ```python + @app.command() + def main( + user: Annotated[str, typer.Argument()], + user_id: Annotated[int, typer.Argument(min=1, max=1000, clamp=True)], + ): + print(f"ID for {user} is {user_id}") + ``` + + If the user attempts to input 3420 for `user_id`, this will internally be converted to `1000`. + """ + ), + ] = False, + # DateTime + formats: Annotated[ + list[str] | None, + Doc( + """ + For a CLI Argument representing a [DateTime object](https://typer.tiangolo.com/tutorial/parameter-types/datetime), + you can customize the formats that can be parsed automatically: + + **Example** + + ```python + from datetime import datetime + + @app.command() + def main( + birthday: Annotated[ + datetime, + typer.Argument( + formats=["%Y-%m-%d", "%Y-%m-%d %H:%M:%S", "%m/%d/%Y"] + ), + ], + ): + print(f"Birthday defined at: {birthday}") + ``` + """ + ), + ] = None, + # File + mode: Annotated[ + str | None, + Doc( + """ + For a CLI Argument representing a [File object](https://typer.tiangolo.com/tutorial/parameter-types/file/), + you can customize the mode to open the file with. If unset, Typer will set a [sensible value by default](https://typer.tiangolo.com/tutorial/parameter-types/file/#advanced-mode). + + **Example** + + ```python + @app.command() + def main(config: Annotated[typer.FileText, typer.Argument(mode="a")]): + config.write("This is a single line\\n") + print("Config line written") + ``` + """ + ), + ] = None, + encoding: Annotated[ + str | None, + Doc( + """ + Customize the encoding of this CLI Argument represented by a [File object](https://typer.tiangolo.com/tutorial/parameter-types/file/). + + **Example** + + ```python + @app.command() + def main(config: Annotated[typer.FileText, typer.Argument(encoding="utf-8")]): + config.write("All the text gets written\\n") + ``` + """ + ), + ] = None, + errors: Annotated[ + str | None, + Doc( + """ + **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility. + + --- + + The error handling mode. + """ + ), + ] = "strict", + lazy: Annotated[ + bool | None, + Doc( + """ + For a CLI Argument representing a [File object](https://typer.tiangolo.com/tutorial/parameter-types/file/), + by default the file will not be created until you actually start writing to it. + You can change this behaviour by setting this parameter. + By default, it's set to `True` for writing and to `False` for reading. + + **Example** + + ```python + @app.command() + def main(config: Annotated[typer.FileText, typer.Argument(mode="a", lazy=False)]): + config.write("This is a single line\\n") + print("Config line written") + ``` + """ + ), + ] = None, + atomic: Annotated[ + bool, + Doc( + """ + For a CLI Argument representing a [File object](https://typer.tiangolo.com/tutorial/parameter-types/file/), + you can ensure that all write instructions first go into a temporal file, and are only moved to the final destination after completing + by setting `atomic` to `True`. This can be useful for files with potential concurrent access. + + **Example** + + ```python + @app.command() + def main(config: Annotated[typer.FileText, typer.Argument(mode="a", atomic=True)]): + config.write("All the text") + ``` + """ + ), + ] = False, + # Path + exists: Annotated[ + bool, + Doc( + """ + When set to `True` for a [`Path` argument](https://typer.tiangolo.com/tutorial/parameter-types/path/), + additional validation is performed to check that the file or directory exists. If not, the value will be invalid. + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Argument(exists=True)]): + text = config.read_text() + print(f"Config file contents: {text}") + ``` + """ + ), + ] = False, + file_okay: Annotated[ + bool, + Doc( + """ + Determine whether or not a [`Path` argument](https://typer.tiangolo.com/tutorial/parameter-types/path/) + is allowed to refer to a file. When this is set to `False`, the application will raise a validation error when a path to a file is given. + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Argument(exists=True, file_okay=False)]): + print(f"Directory listing: {[x.name for x in config.iterdir()]}") + ``` + """ + ), + ] = True, + dir_okay: Annotated[ + bool, + Doc( + """ + Determine whether or not a [`Path` argument](https://typer.tiangolo.com/tutorial/parameter-types/path/) + is allowed to refer to a directory. When this is set to `False`, the application will raise a validation error when a path to a directory is given. + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Argument(exists=True, dir_okay=False)]): + text = config.read_text() + print(f"Config file contents: {text}") + ``` + """ + ), + ] = True, + writable: Annotated[ + bool, + Doc( + """ + Whether or not to perform a writable check for this [`Path` argument](https://typer.tiangolo.com/tutorial/parameter-types/path/). + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Argument(writable=True)]): + config.write_text("All the text") + ``` + """ + ), + ] = False, + readable: Annotated[ + bool, + Doc( + """ + Whether or not to perform a readable check for this [`Path` argument](https://typer.tiangolo.com/tutorial/parameter-types/path/). + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Argument(readable=True)]): + config.read_text("All the text") + ``` + """ + ), + ] = True, + resolve_path: Annotated[ + bool, + Doc( + """ + Whether or not to fully resolve the path of this [`Path` argument](https://typer.tiangolo.com/tutorial/parameter-types/path/), + meaning that the path becomes absolute and symlinks are resolved. + + **Example** + + ```python + from pathlib import Path + + @app.command() + def main(config: Annotated[Path, typer.Argument(resolve_path=True)]): + config.read_text("All the text") + ``` + """ + ), + ] = False, + allow_dash: Annotated[ + bool, + Doc( + """ + When set to `True`, a single dash for this [`Path` argument](https://typer.tiangolo.com/tutorial/parameter-types/path/) + would be a valid value, indicating standard streams. This is a more advanced use-case. + """ + ), + ] = False, + path_type: Annotated[ + None | type[str] | type[bytes], + Doc( + """ + A string type that will be used to represent this [`Path` argument](https://typer.tiangolo.com/tutorial/parameter-types/path/). + The default is `None` which means the return value will be either bytes or unicode, depending on what makes most sense given the input data. + This is a more advanced use-case. + """ + ), + ] = None, + # Rich settings + rich_help_panel: Annotated[ + str | None, + Doc( + """ + Set the panel name where you want this CLI Argument to be shown in the [help text](https://typer.tiangolo.com/tutorial/arguments/help). + + **Example** + + ```python + @app.command() + def main( + name: Annotated[str, typer.Argument(help="Who to greet")], + age: Annotated[str, typer.Option(help="Their age", rich_help_panel="Data")], + ): + print(f"Hello {name} of age {age}") + ``` + """ + ), + ] = None, +) -> Any: + """ + A [CLI Argument](https://typer.tiangolo.com/tutorial/arguments) is a positional parameter to your command line application. + + Often, CLI Arguments are required, meaning that users have to specify them. However, you can set them to be optional by defining a default value: + + ## Example + + ```python + @app.command() + def main(name: Annotated[str, typer.Argument()] = "World"): + print(f"Hello {name}!") + ``` + + Note how in this example, if `name` is not specified on the command line, the application will still execute normally and print "Hello World!". + """ + return ArgumentInfo( + # Parameter + default=default, + # Arguments can only have one param declaration + # it will be generated from the param name + param_decls=None, + callback=callback, + metavar=metavar, + expose_value=expose_value, + is_eager=is_eager, + envvar=envvar, + shell_complete=shell_complete, + autocompletion=autocompletion, + default_factory=default_factory, + # Custom type + parser=parser, + click_type=click_type, + # TyperArgument + show_default=show_default, + show_choices=show_choices, + show_envvar=show_envvar, + help=help, + hidden=hidden, + # Choice + case_sensitive=case_sensitive, + # Numbers + min=min, + max=max, + clamp=clamp, + # DateTime + formats=formats, + # File + mode=mode, + encoding=encoding, + errors=errors, + lazy=lazy, + atomic=atomic, + # Path + exists=exists, + file_okay=file_okay, + dir_okay=dir_okay, + writable=writable, + readable=readable, + resolve_path=resolve_path, + allow_dash=allow_dash, + path_type=path_type, + # Rich settings + rich_help_panel=rich_help_panel, + ) diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/py.typed b/TTS/Kokoro/.venv/Lib/site-packages/typer/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/TTS/Kokoro/.venv/Lib/site-packages/typer/rich_utils.py b/TTS/Kokoro/.venv/Lib/site-packages/typer/rich_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d85043238c3d47a89cd6d5127fce198c0564f0b7 --- /dev/null +++ b/TTS/Kokoro/.venv/Lib/site-packages/typer/rich_utils.py @@ -0,0 +1,753 @@ +# Extracted and modified from https://github.com/ewels/rich-click + +import inspect +import io +from collections import defaultdict +from collections.abc import Iterable +from gettext import gettext as _ +from os import getenv +from typing import Any, Literal + +import click +from rich import box +from rich.align import Align +from rich.columns import Columns +from rich.console import Console, RenderableType, group +from rich.emoji import Emoji +from rich.highlighter import RegexHighlighter +from rich.markdown import Markdown +from rich.markup import escape +from rich.padding import Padding +from rich.panel import Panel +from rich.table import Table +from rich.text import Text +from rich.theme import Theme +from rich.traceback import Traceback +from typer.models import DeveloperExceptionConfig + +# Default styles +STYLE_OPTION = "bold cyan" +STYLE_SWITCH = "bold green" +STYLE_NEGATIVE_OPTION = "bold magenta" +STYLE_NEGATIVE_SWITCH = "bold red" +STYLE_METAVAR = "bold yellow" +STYLE_METAVAR_SEPARATOR = "dim" +STYLE_USAGE = "yellow" +STYLE_USAGE_COMMAND = "bold" +STYLE_DEPRECATED = "red" +STYLE_DEPRECATED_COMMAND = "dim" +STYLE_HELPTEXT_FIRST_LINE = "" +STYLE_HELPTEXT = "dim" +STYLE_OPTION_HELP = "" +STYLE_OPTION_DEFAULT = "dim" +STYLE_OPTION_ENVVAR = "dim yellow" +STYLE_REQUIRED_SHORT = "red" +STYLE_REQUIRED_LONG = "dim red" +STYLE_OPTIONS_PANEL_BORDER = "dim" +ALIGN_OPTIONS_PANEL: Literal["left", "center", "right"] = "left" +STYLE_OPTIONS_TABLE_SHOW_LINES = False +STYLE_OPTIONS_TABLE_LEADING = 0 +STYLE_OPTIONS_TABLE_PAD_EDGE = False +STYLE_OPTIONS_TABLE_PADDING = (0, 1) +STYLE_OPTIONS_TABLE_BOX = "" +STYLE_OPTIONS_TABLE_ROW_STYLES = None +STYLE_OPTIONS_TABLE_BORDER_STYLE = None +STYLE_COMMANDS_PANEL_BORDER = "dim" +ALIGN_COMMANDS_PANEL: Literal["left", "center", "right"] = "left" +STYLE_COMMANDS_TABLE_SHOW_LINES = False +STYLE_COMMANDS_TABLE_LEADING = 0 +STYLE_COMMANDS_TABLE_PAD_EDGE = False +STYLE_COMMANDS_TABLE_PADDING = (0, 1) +STYLE_COMMANDS_TABLE_BOX = "" +STYLE_COMMANDS_TABLE_ROW_STYLES = None +STYLE_COMMANDS_TABLE_BORDER_STYLE = None +STYLE_COMMANDS_TABLE_FIRST_COLUMN = "bold cyan" +STYLE_ERRORS_PANEL_BORDER = "red" +ALIGN_ERRORS_PANEL: Literal["left", "center", "right"] = "left" +STYLE_ERRORS_SUGGESTION = "dim" +STYLE_ABORTED = "red" +_TERMINAL_WIDTH = getenv("TERMINAL_WIDTH") +MAX_WIDTH = int(_TERMINAL_WIDTH) if _TERMINAL_WIDTH else None +COLOR_SYSTEM: Literal["auto", "standard", "256", "truecolor", "windows"] | None = ( + "auto" # Set to None to disable colors +) +_TYPER_FORCE_DISABLE_TERMINAL = getenv("_TYPER_FORCE_DISABLE_TERMINAL") +FORCE_TERMINAL = ( + True + if getenv("GITHUB_ACTIONS") or getenv("FORCE_COLOR") or getenv("PY_COLORS") + else None +) +if _TYPER_FORCE_DISABLE_TERMINAL: + FORCE_TERMINAL = False + +# Fixed strings +DEPRECATED_STRING = _("(deprecated) ") +DEFAULT_STRING = _("[default: {}]") +ENVVAR_STRING = _("[env var: {}]") +REQUIRED_SHORT_STRING = "*" +REQUIRED_LONG_STRING = _("[required]") +RANGE_STRING = " [{}]" +ARGUMENTS_PANEL_TITLE = _("Arguments") +OPTIONS_PANEL_TITLE = _("Options") +COMMANDS_PANEL_TITLE = _("Commands") +ERRORS_PANEL_TITLE = _("Error") +ABORTED_TEXT = _("Aborted.") +RICH_HELP = _("Try [blue]'{command_path} {help_option}'[/] for help.") + +MARKUP_MODE_MARKDOWN = "markdown" +MARKUP_MODE_RICH = "rich" +_RICH_HELP_PANEL_NAME = "rich_help_panel" +ANSI_PREFIX = "\033[" + +MarkupModeStrict = Literal["markdown", "rich"] + + +# Rich regex highlighter +class OptionHighlighter(RegexHighlighter): + """Highlights our special options.""" + + highlights = [ + r"(^|\W)(?P\-\w+)(?![a-zA-Z0-9])", + r"(^|\W)(?P