[general] Cleanup unused properties

Author: Breakthrough

scenedetect/_cli/config.py

@@ -739,23 +739,23 @@ def get_init_log(self):
         self._init_log = []
         return init_log
 
-    def _log(self, log_level, log_str):
+    def _log(self, log_level: int, log_str: str) -> None:
         self._init_log.append((log_level, log_str))
 
     def _load_from_disk(self, path=None):
         # Validate `path`, or if not provided, use CONFIG_FILE_PATH if it exists.
         if path:
-            self._init_log.append((logging.INFO, f"Loading config from file:\n  {path}"))
+            self._log(logging.INFO, f"Loading config from file:\n  {path}")
             if not os.path.exists(path):
-                self._init_log.append((logging.ERROR, f"File not found: {path}"))
+                self._log(logging.ERROR, f"File not found: {path}")
                 raise ConfigLoadFailure(self._init_log)
         else:
             # Gracefully handle the case where there isn't a user config file.
             if not os.path.exists(CONFIG_FILE_PATH):
-                self._init_log.append((logging.DEBUG, "User config file not found."))
+                self._log(logging.DEBUG, "User config file not found.")
                 return
             path = CONFIG_FILE_PATH
-            self._init_log.append((logging.INFO, f"Loading user config file:\n  {path}"))
+            self._log(logging.INFO, f"Loading user config file:\n  {path}")
         # Try to load and parse the config file at `path`.
         config = ConfigParser()
         try:
@@ -770,7 +770,7 @@ def _load_from_disk(self, path=None):
         # the parsed options (i.e. that the options have valid values).
         (config, logs) = _parse_config(config)
         for verbosity, message in logs:
-            self._init_log.append((verbosity, message))
+            self._log(verbosity, message)
         if config is None:
             raise ConfigLoadFailure(self._init_log)
         self._config = config

scenedetect/backends/pyav.py

@@ -96,7 +96,6 @@ def __init__(
         self._path = ""
         self._frame: av.VideoFrame | None = None
         self._decoder: ty.Generator | None = None
-        self._decode_count: int = 0
         self._reopened = True
 
         if threading_mode:
@@ -280,7 +279,6 @@ def seek(self, target: TimecodeLike) -> None:
         )
         self._frame = None
         self._decoder = None
-        self._decode_count = 0
         self._container.seek(target_pts, stream=self._video_stream)
         if not beginning:
             self.read(decode=False)
@@ -293,7 +291,6 @@ def reset(self):
         self._container.close()
         self._frame = None
         self._decoder = None
-        self._decode_count = 0
         try:
             self._container = av.open(self._path if self._path else self._io)
         except Exception as ex:
@@ -309,7 +306,6 @@ def read(self, decode: bool = True) -> np.ndarray | bool:
             last_frame = self._frame
             assert self._decoder is not None
             self._frame = next(self._decoder)
-            self._decode_count += 1
         except av.error.EOFError:  # type: ignore[attr-defined]
             self._frame = last_frame
             if self._handle_eof():

scenedetect/common.py

@@ -476,27 +476,6 @@ def _seconds_to_frames(self, seconds: float) -> int:
         assert self._rate is not None
         return round(seconds * self._rate)
 
-    def _parse_timecode_number(self, timecode: int | float) -> int:
-        """Parse a timecode number, storing it as the exact number of frames.
-        Can be passed as frame number (int), seconds (float)
-
-        Raises:
-            TypeError, ValueError
-        """
-        # Process the timecode value, storing it as an exact number of frames.
-        # Exact number of frames N
-        if isinstance(timecode, int):
-            if timecode < 0:
-                raise ValueError("Timecode frame number must be positive and greater than zero.")
-            return timecode
-        # Number of seconds S
-        elif isinstance(timecode, float):
-            if timecode < 0.0:
-                raise ValueError("Timecode value must be positive and greater than zero.")
-            return self._seconds_to_frames(timecode)
-        else:
-            raise TypeError("Timecode format/type unrecognized.")
-
     def _timecode_to_seconds(self, input: str) -> float:
         """Parses a string based on the three possible forms (in timecode format, as an integer
         number of frames, or floating-point seconds, ending with 's'). Exact frame numbers (int)

scenedetect/detectors/content_detector.py

@@ -127,7 +127,6 @@ def __init__(
         """
         super().__init__()
         self._threshold: float = threshold
-        self._last_above_threshold: int | None = None
         self._last_frame: ContentDetector._FrameData | None = None
         self._weights: ContentDetector.Components = weights
         if luma_only:

scenedetect/detectors/threshold_detector.py

@@ -93,7 +93,6 @@ def __init__(
             "type": None,  # type of fade, can be either 'in' or 'out'
         }
         self._metric_keys = [ThresholdDetector.THRESHOLD_VALUE_KEY]
-        self._time_base = None
 
     def get_metrics(self) -> list[str]:
         return self._metric_keys

scenedetect/scene_manager.py

@@ -226,8 +226,6 @@ def __init__(
         # Interpolation method to use when downscaling. Defaults to linear interpolation
         # as a good balance between quality and performance.
         self._interpolation: Interpolation = Interpolation.LINEAR
-        # Boolean indicating if we have only seen EventType.CUT events so far.
-        self._only_cuts: bool = True
         # Set by decode thread when an exception occurs.
         self._exception_info = None
         self._stop = threading.Event()