style: modernize typing imports

Author: osolmaz

src/manim_voiceover/_typing.py

@@ -1,7 +1,8 @@
-from typing import Dict, List, Mapping, TypedDict, Union
+import typing as t
+from collections.abc import Mapping
 
-JsonScalar = Union[str, int, float, bool, None]
-JsonValue = Union[JsonScalar, Dict[str, "JsonValue"], List["JsonValue"]]
+JsonScalar = str | int | float | bool | None
+JsonValue = JsonScalar | dict[str, "JsonValue"] | list["JsonValue"]
 
 
 def json_value(value: object) -> JsonValue:
@@ -10,7 +11,7 @@ def json_value(value: object) -> JsonValue:
     if isinstance(value, list):
         return [json_value(item) for item in value]
     if isinstance(value, dict):
-        output: Dict[str, JsonValue] = {}
+        output: dict[str, JsonValue] = {}
         for key, item in value.items():
             if not isinstance(key, str):
                 raise TypeError("JSON object keys must be strings")
@@ -19,25 +20,25 @@ def json_value(value: object) -> JsonValue:
     raise TypeError("value must be JSON-compatible")
 
 
-def json_object(value: Mapping[str, object]) -> Dict[str, JsonValue]:
-    output: Dict[str, JsonValue] = {}
+def json_object(value: Mapping[str, object]) -> dict[str, JsonValue]:
+    output: dict[str, JsonValue] = {}
     for key, item in value.items():
         if not isinstance(key, str):
             raise TypeError("JSON object keys must be strings")
         output[key] = json_value(item)
     return output
 
 
-class WordTimestamp(TypedDict):
+class WordTimestamp(t.TypedDict):
     word: str
     start: float
 
 
-class TranscriptionSegment(TypedDict):
-    words: List[WordTimestamp]
+class TranscriptionSegment(t.TypedDict):
+    words: list[WordTimestamp]
 
 
-class WordBoundary(TypedDict, total=False):
+class WordBoundary(t.TypedDict, total=False):
     audio_offset: int
     duration_milliseconds: int
     text_offset: int
@@ -46,11 +47,11 @@ class WordBoundary(TypedDict, total=False):
     boundary_type: str
 
 
-class VoiceoverData(TypedDict, total=False):
+class VoiceoverData(t.TypedDict, total=False):
     input_text: str
     input_data: Mapping[str, JsonValue]
     ssml: str
-    word_boundaries: List[WordBoundary]
+    word_boundaries: list[WordBoundary]
     original_audio: str
     final_audio: str
     json_path: str

src/manim_voiceover/helper.py

@@ -4,20 +4,18 @@
 import re
 import sys
 import textwrap
+import typing as t
+from collections.abc import Iterator, Mapping, Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, Iterator, List, Mapping, Optional, Sequence, TypeVar, Union
 
 import pip
 from manim import logger
 from pydub import AudioSegment
 
 from manim_voiceover._typing import JsonValue, VoiceoverData
 
-T = TypeVar("T")
-if TYPE_CHECKING:
-    PathLike = Union[str, os.PathLike[str]]
-else:
-    PathLike = Union[str, os.PathLike]
+T = t.TypeVar("T")
+PathLike = str | os.PathLike[str]
 
 
 def chunks(lst: Sequence[T], n: int) -> Iterator[Sequence[T]]:
@@ -32,7 +30,7 @@ def remove_bookmarks(input: str) -> str:
 
 def wav2mp3(
     wav_path: PathLike,
-    mp3_path: Optional[PathLike] = None,
+    mp3_path: PathLike | None = None,
     remove_wav: bool = True,
     bitrate: str = "312k",
 ) -> None:
@@ -50,7 +48,7 @@ def wav2mp3(
     logger.info(f"Saved {mp3_path}")
 
 
-def msg_box(msg: str, indent: int = 1, width: Optional[int] = None, title: Optional[str] = None) -> str:
+def msg_box(msg: str, indent: int = 1, width: int | None = None, title: str | None = None) -> str:
     """Print message-box with optional title."""
     raw_lines = msg.splitlines() or [""]
     space = " " * indent
@@ -108,7 +106,7 @@ def trim_silence(
     return trimmed_sound
 
 
-def append_to_json_file(json_file: PathLike, data: Union[Mapping[str, JsonValue], VoiceoverData]) -> None:
+def append_to_json_file(json_file: PathLike, data: Mapping[str, JsonValue] | VoiceoverData) -> None:
     """Append data to json file"""
     json_path = Path(json_file)
     if not json_path.exists():
@@ -142,7 +140,7 @@ def prompt_ask_missing_package(target_module: str, package_name: str) -> None:
 
 
 def prompt_ask_missing_extras(
-    target_module: Union[str, List[str]],
+    target_module: str | list[str],
     extras: str,
     dependent_item: str,
 ) -> None:

src/manim_voiceover/modify_audio.py

@@ -1,21 +1,21 @@
 import os
+import typing as t
 import uuid
 from pathlib import Path
-from typing import Optional, Protocol, Union
 
 import sox
 from mutagen.mp3 import MP3
 from mutagen.wave import WAVE
 
-PathLike = Union[str, Path]
+PathLike = str | Path
 
 
-class _AudioInfo(Protocol):
+class _AudioInfo(t.Protocol):
     length: float
 
 
-class _AudioFile(Protocol):
-    info: Optional[_AudioInfo]
+class _AudioFile(t.Protocol):
+    info: _AudioInfo | None
 
 
 def _read_wave(path: PathLike) -> _AudioFile:

src/manim_voiceover/services/azure.py

@@ -1,7 +1,8 @@
 import os
 import sys
+import typing as t
+from collections.abc import Mapping
 from pathlib import Path
-from typing import Dict, List, Mapping, Optional, Protocol, Tuple
 
 from dotenv import find_dotenv, load_dotenv
 from manim import logger
@@ -23,12 +24,12 @@
 load_dotenv(find_dotenv(usecwd=True))
 
 
-class CancellationDetailsProtocol(Protocol):
+class CancellationDetailsProtocol(t.Protocol):
     reason: object
-    error_details: Optional[str]
+    error_details: str | None
 
 
-class SpeechSynthesisResultProtocol(Protocol):
+class SpeechSynthesisResultProtocol(t.Protocol):
     reason: object
     cancellation_details: CancellationDetailsProtocol
 
@@ -51,15 +52,15 @@ def _json_value(value: object) -> JsonValue:
     return json_value(value)
 
 
-def _normalize_prosody(value: object) -> Optional[Dict[str, JsonValue]]:
+def _normalize_prosody(value: object) -> dict[str, JsonValue] | None:
     if value is None:
         return None
     if not isinstance(value, dict):
         raise ValueError(
             "The prosody argument must be a dict that contains at least one of the following keys: "
             "'pitch', 'contour', 'range', 'rate', 'volume'."
         )
-    prosody: Dict[str, JsonValue] = {}
+    prosody: dict[str, JsonValue] = {}
     for key, item in value.items():
         if not isinstance(key, str):
             raise TypeError("prosody must map string keys to JSON-compatible values")
@@ -98,7 +99,7 @@ def create_dotenv_azure() -> None:
     sys.exit()
 
 
-def _get_azure_credentials() -> Tuple[str, str]:
+def _get_azure_credentials() -> tuple[str, str]:
     try:
         return os.environ["AZURE_SUBSCRIPTION_KEY"], os.environ["AZURE_SERVICE_REGION"]
     except KeyError:
@@ -118,9 +119,9 @@ def __init__(
         self,
         voice: str = "en-US-AriaNeural",
         # style="newscast-casual",
-        style: Optional[str] = None,
+        style: str | None = None,
         output_format: str = "Audio48Khz192KBitRateMonoMp3",
-        prosody: Optional[Dict[str, JsonValue]] = None,
+        prosody: dict[str, JsonValue] | None = None,
         **kwargs: object,
     ) -> None:
         """
@@ -139,7 +140,7 @@ def __init__(
         self.prosody = prosody
         initialize_speech_service(self, kwargs)
 
-    def _build_ssml(self, text: str, prosody: Optional[Dict[str, JsonValue]]) -> Tuple[str, int]:
+    def _build_ssml(self, text: str, prosody: dict[str, JsonValue] | None) -> tuple[str, int]:
         ssml_beginning = (
             '<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" '
             'xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="en-US">'
@@ -180,8 +181,8 @@ def _raise_for_canceled_synthesis(self, speech_synthesis_result: SpeechSynthesis
     def generate_from_text(
         self,
         text: str,
-        cache_dir: Optional[PathLike] = None,
-        path: Optional[PathLike] = None,
+        cache_dir: PathLike | None = None,
+        path: PathLike | None = None,
         **kwargs: object,
     ) -> VoiceoverData:
         """"""
@@ -195,7 +196,7 @@ def generate_from_text(
         prosody = _normalize_prosody(kwargs.get("prosody", self.prosody))
         ssml, initial_offset = self._build_ssml(inner, prosody)
 
-        input_data: Dict[str, JsonValue] = {
+        input_data: dict[str, JsonValue] = {
             "input_text": text,
             "ssml": ssml,
             "service": "azure",
@@ -226,7 +227,7 @@ def generate_from_text(
         audio_config = speechsdk.audio.AudioOutputConfig(filename=str(Path(cache_dir) / audio_path))
 
         speech_service = speechsdk.SpeechSynthesizer(speech_config=speech_config, audio_config=audio_config)
-        word_boundaries: List[Mapping[str, object]] = []
+        word_boundaries: list[Mapping[str, object]] = []
         # speech_synthesizer.bookmark_reached.connect(lambda evt: print(
         #     "Bookmark reached: {}, audio offset: {}ms, bookmark text: {}.".format(evt, evt.audio_offset, evt.text)))
 

src/manim_voiceover/services/base.py

@@ -25,23 +25,20 @@
 )
 from manim_voiceover.tracker import AUDIO_OFFSET_RESOLUTION
 
-if t.TYPE_CHECKING:
-    PathLike = t.Union[str, os.PathLike[str]]
-else:
-    PathLike = t.Union[str, os.PathLike]
+PathLike = str | os.PathLike[str]
 
 
 class TranscriptionResult(t.Protocol):
     text: str
 
-    def segments_to_dicts(self) -> t.List[TranscriptionSegment]: ...
+    def segments_to_dicts(self) -> list[TranscriptionSegment]: ...
 
 
 class WhisperModel(t.Protocol):
     def transcribe(self, audio_path: str, **kwargs: object) -> TranscriptionResult: ...
 
 
-def _pop_optional_path(kwargs: t.MutableMapping[str, object], key: str) -> t.Optional[PathLike]:
+def _pop_optional_path(kwargs: t.MutableMapping[str, object], key: str) -> PathLike | None:
     value = kwargs.pop(key, None)
     if value is None:
         return None
@@ -59,7 +56,7 @@ def path_to_string(path: PathLike) -> str:
     raise TypeError("path must resolve to a string path")
 
 
-def _pop_optional_str(kwargs: t.MutableMapping[str, object], key: str) -> t.Optional[str]:
+def _pop_optional_str(kwargs: t.MutableMapping[str, object], key: str) -> str | None:
     value = kwargs.pop(key, None)
     if value is None or isinstance(value, str):
         return value
@@ -73,7 +70,7 @@ def _pop_float(kwargs: t.MutableMapping[str, object], key: str, default: float)
     raise TypeError(f"{key} must be a number")
 
 
-def _pop_optional_dict(kwargs: t.MutableMapping[str, object], key: str) -> t.Optional[t.Dict[str, object]]:
+def _pop_optional_dict(kwargs: t.MutableMapping[str, object], key: str) -> dict[str, object] | None:
     value = kwargs.pop(key, None)
     if value is None:
         return None
@@ -85,7 +82,7 @@ def _pop_optional_dict(kwargs: t.MutableMapping[str, object], key: str) -> t.Opt
 def initialize_speech_service(
     service: "SpeechService",
     kwargs: t.MutableMapping[str, object],
-    transcription_model: t.Optional[str] = None,
+    transcription_model: str | None = None,
 ) -> None:
     model = _pop_optional_str(kwargs, "transcription_model")
     SpeechService.__init__(
@@ -98,8 +95,8 @@ def initialize_speech_service(
     service.additional_kwargs.update(kwargs)
 
 
-def timestamps_to_word_boundaries(segments: t.Sequence[TranscriptionSegment]) -> t.List[WordBoundary]:
-    word_boundaries: t.List[WordBoundary] = []
+def timestamps_to_word_boundaries(segments: t.Sequence[TranscriptionSegment]) -> list[WordBoundary]:
+    word_boundaries: list[WordBoundary] = []
     current_text_offset = 0
     for segment in segments:
         for dict_ in segment["words"]:
@@ -128,9 +125,9 @@ class SpeechService(ABC):
     def __init__(
         self,
         global_speed: float = 1.00,
-        cache_dir: t.Optional[PathLike] = None,
-        transcription_model: t.Optional[str] = None,
-        transcription_kwargs: t.Optional[t.Dict[str, object]] = None,
+        cache_dir: PathLike | None = None,
+        transcription_model: str | None = None,
+        transcription_kwargs: dict[str, object] | None = None,
         **kwargs: object,
     ) -> None:
         """
@@ -155,8 +152,8 @@ def __init__(
         if not os.path.exists(self.cache_dir):
             os.makedirs(self.cache_dir)
 
-        self.transcription_model: t.Optional[str] = None
-        self._whisper_model: t.Optional[WhisperModel] = None
+        self.transcription_model: str | None = None
+        self._whisper_model: WhisperModel | None = None
         self.set_transcription(
             model=transcription_model,
             kwargs={} if transcription_kwargs is None else transcription_kwargs,
@@ -172,7 +169,7 @@ def _wrap_generate_from_text(
         # Replace newlines with lines, reduce multiple consecutive spaces to single
         text = " ".join(text.split())
         raw_path = kwargs.pop("path", None)
-        path: t.Optional[PathLike] = None
+        path: PathLike | None = None
         if raw_path is not None:
             if not isinstance(raw_path, (str, os.PathLike)):
                 raise TypeError("path must be a string or path-like object")
@@ -218,7 +215,7 @@ def _wrap_generate_from_text(
         append_voiceover_cache_entry(Path(self.cache_dir) / DEFAULT_VOICEOVER_CACHE_JSON_FILENAME, dict_)
         return dict_
 
-    def set_transcription(self, model: t.Optional[str] = None, kwargs: t.Optional[t.Dict[str, object]] = None) -> None:
+    def set_transcription(self, model: str | None = None, kwargs: dict[str, object] | None = None) -> None:
         """Set the transcription model and keyword arguments to be passed
         to the transcribe() function.
 
@@ -264,8 +261,8 @@ def get_audio_basename(self, data: t.Mapping[str, JsonValue]) -> str:
     def generate_from_text(
         self,
         text: str,
-        cache_dir: t.Optional[PathLike] = None,
-        path: t.Optional[PathLike] = None,
+        cache_dir: PathLike | None = None,
+        path: PathLike | None = None,
         **kwargs: object,
     ) -> VoiceoverData:
         """Implement this method for each speech service. Refer to `AzureService` for an example.
@@ -284,7 +281,7 @@ def get_cached_result(
         self,
         input_data: t.Mapping[str, JsonValue],
         cache_dir: PathLike,
-    ) -> t.Optional[VoiceoverData]:
+    ) -> VoiceoverData | None:
         json_path = Path(cache_dir) / DEFAULT_VOICEOVER_CACHE_JSON_FILENAME
         requested_input_data = json_object(input_data)
         for entry in load_voiceover_cache(json_path):