[lint] Use proper Path type hints rather than str | bytes

Author: Breakthrough

scenedetect/__init__.py

@@ -40,6 +40,7 @@
     TimecodeLike,
     Interpolation,
 )
+from scenedetect.platform import StrPath
 from scenedetect.video_stream import VideoStream, VideoOpenFailure
 from scenedetect.output import (
     save_images,
@@ -80,7 +81,7 @@
 
 
 def open_video(
-    path: str,
+    path: StrPath,
     framerate: float | None = None,
     backend: str = "opencv",
     **kwargs,
@@ -133,9 +134,9 @@ def open_video(
 
 
 def detect(
-    video_path: str,
+    video_path: StrPath,
     detector: SceneDetector,
-    stats_file_path: str | None = None,
+    stats_file_path: StrPath | None = None,
     show_progress: bool = False,
     start_time: TimecodeLike | None = None,
     end_time: TimecodeLike | None = None,

scenedetect/_cli/__init__.py

@@ -319,10 +319,10 @@ def print_command_help(ctx: click.Context, command: click.Command):
 @click.pass_context
 def scenedetect(
     ctx: click.Context,
-    input: ty.AnyStr | None,
-    output: ty.AnyStr | None,
-    stats: ty.AnyStr | None,
-    config: ty.AnyStr | None,
+    input: str | None,
+    output: str | None,
+    stats: str | None,
+    config: str | None,
     framerate: float | None,
     min_scene_len: str | None,
     drop_short_scenes: bool | None,
@@ -332,7 +332,7 @@ def scenedetect(
     downscale: int | None,
     frame_skip: int | None,
     verbosity: str | None,
-    logfile: ty.AnyStr | None,
+    logfile: str | None,
     quiet: bool,
 ):
     ctx = ctx.obj
@@ -1052,7 +1052,7 @@ def load_scenes_command(ctx: click.Context, input: str | None, start_col_name: s
 @click.pass_context
 def save_html_command(
     ctx: click.Context,
-    filename: ty.AnyStr | None,
+    filename: str | None,
     no_images: bool,
     image_width: int | None,
     image_height: int | None,
@@ -1144,8 +1144,8 @@ def save_html_command(
 @click.pass_context
 def list_scenes_command(
     ctx: click.Context,
-    output: ty.AnyStr | None,
-    filename: ty.AnyStr | None,
+    output: str | None,
+    filename: str | None,
     no_output_file: bool | None,
     quiet: bool | None,
     skip_cuts: bool | None,
@@ -1280,8 +1280,8 @@ def list_scenes_command(
 @click.pass_context
 def split_video_command(
     ctx: click.Context,
-    output: ty.AnyStr | None,
-    filename: ty.AnyStr | None,
+    output: str | None,
+    filename: str | None,
     quiet: bool,
     copy: bool,
     high_quality: bool,
@@ -1487,8 +1487,8 @@ def split_video_command(
 @click.pass_context
 def save_images_command(
     ctx: click.Context,
-    output: ty.AnyStr | None = None,
-    filename: ty.AnyStr | None = None,
+    output: str | None = None,
+    filename: str | None = None,
     num_images: int | None = None,
     jpeg: bool = False,
     webp: bool = False,
@@ -1603,10 +1603,10 @@ def save_images_command(
 @click.pass_context
 def save_edl_command(
     ctx: click.Context,
-    filename: ty.AnyStr | None,
-    title: ty.AnyStr | None,
-    reel: ty.AnyStr | None,
-    output: ty.AnyStr | None,
+    filename: str | None,
+    title: str | None,
+    reel: str | None,
+    output: str | None,
 ):
     ctx = ctx.obj
     assert isinstance(ctx, CliContext)
@@ -1657,8 +1657,8 @@ def save_edl_command(
 @click.pass_context
 def save_qp_command(
     ctx: click.Context,
-    filename: ty.AnyStr | None,
-    output: ty.AnyStr | None,
+    filename: str | None,
+    output: str | None,
     disable_shift: bool | None,
 ):
     ctx = ctx.obj
@@ -1706,9 +1706,9 @@ def save_qp_command(
 @click.pass_context
 def save_fcp_command(
     ctx: click.Context,
-    filename: ty.AnyStr | None,
-    format: ty.AnyStr | None,
-    output: ty.AnyStr | None,
+    filename: str | None,
+    format: str | None,
+    output: str | None,
 ):
     ctx = ctx.obj
     assert isinstance(ctx, CliContext)
@@ -1767,9 +1767,9 @@ def save_fcp_command(
 @click.pass_context
 def save_otio_command(
     ctx: click.Context,
-    filename: ty.AnyStr | None,
-    name: ty.AnyStr | None,
-    output: ty.AnyStr | None,
+    filename: str | None,
+    name: str | None,
+    output: str | None,
     audio: bool,
     no_audio: bool,
 ):

scenedetect/_cli/config.py

@@ -318,11 +318,11 @@ class FcpFormat(Enum):
 ConfigValue = bool | int | float | str
 ConfigDict = dict[str, dict[str, ConfigValue]]
 
-_CONFIG_FILE_NAME: ty.AnyStr = "scenedetect.cfg"
-_CONFIG_FILE_DIR: ty.AnyStr = user_config_dir("PySceneDetect", False)
+_CONFIG_FILE_NAME: str = "scenedetect.cfg"
+_CONFIG_FILE_DIR: str = user_config_dir("PySceneDetect", False)
 _PLACEHOLDER = 0  # Placeholder for image quality default, as the value depends on output format
 
-CONFIG_FILE_PATH: ty.AnyStr = os.path.join(_CONFIG_FILE_DIR, _CONFIG_FILE_NAME)
+CONFIG_FILE_PATH: str = os.path.join(_CONFIG_FILE_DIR, _CONFIG_FILE_NAME)
 DEFAULT_JPG_QUALITY = 95
 DEFAULT_WEBP_QUALITY = 100
 

scenedetect/_cli/context.py

@@ -159,21 +159,21 @@ def parse_timecode(self, value: str | None, correct_pts: bool = False) -> FrameT
 
     def handle_options(
         self,
-        input_path: ty.AnyStr,
-        output: ty.AnyStr | None,
-        framerate: float,
-        stats_file: ty.AnyStr | None,
-        frame_skip: int,
-        min_scene_len: str,
+        input_path: str | None,
+        output: str | None,
+        framerate: float | None,
+        stats_file: str | None,
+        frame_skip: int | None,
+        min_scene_len: str | None,
         drop_short_scenes: bool | None,
         merge_last_scene: bool | None,
         backend: str | None,
         crop: tuple[int, int, int, int] | None,
         downscale: int | None,
         quiet: bool,
-        logfile: ty.AnyStr | None,
-        config: ty.AnyStr | None,
-        stats: ty.AnyStr | None,
+        logfile: str | None,
+        config: str | None,
+        stats: str | None,
         verbosity: str | None,
     ):
         """Parse all global options/arguments passed to the main scenedetect command,
@@ -496,7 +496,7 @@ def _initialize_logging(
         self,
         quiet: bool | None = None,
         verbosity: str | None = None,
-        logfile: ty.AnyStr | None = None,
+        logfile: str | None = None,
     ):
         """Setup logging based on CLI args and user configuration settings."""
         if quiet is not None:
@@ -527,7 +527,7 @@ def _initialize_logging(
 
     def _open_video_stream(
         self,
-        input_path: ty.AnyStr,
+        input_path: str,
         framerate: float | None,
         backend: str | None,
     ):

scenedetect/backends/moviepy.py

@@ -16,6 +16,7 @@
 image sequences or AviSynth scripts are supported as inputs.
 """
 
+import os
 import time
 import typing as ty
 from fractions import Fraction
@@ -26,8 +27,13 @@
 from moviepy.video.io.ffmpeg_reader import FFMPEG_VideoReader
 
 from scenedetect.backends.opencv import VideoStreamCv2
-from scenedetect.common import FrameTimecode, Timecode, TimecodeLike, framerate_to_fraction
-from scenedetect.platform import get_file_name
+from scenedetect.common import (
+    FrameTimecode,
+    Timecode,
+    TimecodeLike,
+    framerate_to_fraction,
+)
+from scenedetect.platform import StrPath, get_file_name
 from scenedetect.video_stream import SeekError, VideoOpenFailure, VideoStream
 
 logger = getLogger("pyscenedetect")
@@ -63,7 +69,7 @@ def _retry_on_oserror(op_name: str, fn: ty.Callable):
 class VideoStreamMoviePy(VideoStream):
     """MoviePy `FFMPEG_VideoReader` backend."""
 
-    def __init__(self, path: ty.AnyStr, framerate: float | None = None, print_infos: bool = False):
+    def __init__(self, path: StrPath, framerate: float | None = None, print_infos: bool = False):
         """Open a video or device.
 
         Arguments:
@@ -84,13 +90,13 @@ def __init__(self, path: ty.AnyStr, framerate: float | None = None, print_infos:
                 "VideoStreamMoviePy does not support the `framerate` argument yet."
             )
 
-        self._path = path
+        self._path: str = os.fspath(path)
         # TODO: Need to map errors based on the strings, since several failure
         # cases return IOErrors (e.g. could not read duration/video resolution). These
         # should be mapped to specific errors, e.g. write a function to map MoviePy
         # exceptions to a new set of equivalents.
         self._reader = _retry_on_oserror(
-            "open", lambda: FFMPEG_VideoReader(path, print_infos=print_infos)
+            "open", lambda: FFMPEG_VideoReader(self._path, print_infos=print_infos)
         )
         # This will always be one behind self._reader.lastread when we finally call read()
         # as MoviePy caches the first frame when opening the video. Thus self._last_frame
@@ -117,7 +123,7 @@ def frame_rate(self) -> Fraction:
         return framerate_to_fraction(self._reader.fps)
 
     @property
-    def path(self) -> bytes | str:
+    def path(self) -> str:
         """Video path."""
         return self._path
 

scenedetect/backends/opencv.py

@@ -18,6 +18,7 @@
 """
 
 import math
+import os
 import os.path
 import typing as ty
 import warnings
@@ -34,7 +35,7 @@
     TimecodeLike,
     framerate_to_fraction,
 )
-from scenedetect.platform import get_file_name
+from scenedetect.platform import StrPath, get_file_name
 from scenedetect.video_stream import (
     FrameRateUnavailable,
     SeekError,
@@ -71,10 +72,10 @@ class VideoStreamCv2(VideoStream):
 
     def __init__(
         self,
-        path: ty.AnyStr | None = None,
+        path: StrPath | None = None,
         framerate: float | None = None,
         max_decode_attempts: int = 5,
-        path_or_device: bytes | str | int | None = None,
+        path_or_device: StrPath | int | None = None,
     ):
         """Open a video file, image sequence, or network stream.
 
@@ -103,15 +104,19 @@ def __init__(
                 DeprecationWarning,
                 stacklevel=2,
             )
-            path = path_or_device
-        if path is None:
+            resolved: str | int = (
+                path_or_device if isinstance(path_or_device, int) else os.fspath(path_or_device)
+            )
+        elif path is None:
             raise ValueError("Path must be specified!")
+        else:
+            resolved = os.fspath(path)
         if framerate is not None and framerate < MAX_FPS_DELTA:
             raise ValueError(f"Specified framerate ({framerate:f}) is invalid!")
         if max_decode_attempts < 0:
             raise ValueError("Maximum decode attempts must be >= 0!")
 
-        self._path_or_device = path
+        self._path_or_device: str | int = resolved
         self._is_device = isinstance(self._path_or_device, int)
 
         # Initialized in _open_capture:
@@ -156,11 +161,11 @@ def frame_rate(self) -> Fraction:
         return self._frame_rate
 
     @property
-    def path(self) -> bytes | str:
+    def path(self) -> str:
         if self._is_device:
-            assert isinstance(self._path_or_device, (int))
+            assert isinstance(self._path_or_device, int)
             return f"Device {self._path_or_device}"
-        assert isinstance(self._path_or_device, (bytes, str))
+        assert isinstance(self._path_or_device, str)
         return self._path_or_device
 
     @property
@@ -316,15 +321,21 @@ def read(self, decode: bool = True) -> np.ndarray | bool:
 
     def _open_capture(self, framerate: float | None = None):
         """Opens capture referenced by this object and resets internal state."""
-        if self._is_device and self._path_or_device < 0:
-            raise ValueError("Invalid/negative device ID specified.")
-        input_is_video_file = not self._is_device and not any(
-            identifier in self._path_or_device for identifier in NON_VIDEO_FILE_INPUT_IDENTIFIERS
-        )
-        # We don't have a way of querying why opening a video fails (errors are logged at least),
-        # so provide a better error message if we try to open a file that doesn't exist.
-        if input_is_video_file and not os.path.exists(self._path_or_device):
-            raise OSError("Video file not found.")
+        if self._is_device:
+            assert isinstance(self._path_or_device, int)
+            if self._path_or_device < 0:
+                raise ValueError("Invalid/negative device ID specified.")
+            input_is_video_file = False
+        else:
+            assert isinstance(self._path_or_device, str)
+            input_is_video_file = not any(
+                identifier in self._path_or_device
+                for identifier in NON_VIDEO_FILE_INPUT_IDENTIFIERS
+            )
+            # We don't have a way of querying why opening a video fails (errors are logged at
+            # least), so provide a better error message if we try to open a missing file.
+            if input_is_video_file and not os.path.exists(self._path_or_device):
+                raise OSError("Video file not found.")
 
         cap = cv2.VideoCapture(self._path_or_device)
         if not cap.isOpened():