Undo some stuff; make us 3.10+

Author: scotts

examples/decoding/approximate_mode.py

@@ -42,25 +42,21 @@
 
 temp_dir = tempfile.mkdtemp()
 short_video_path = Path(temp_dir) / "short_video.mp4"
-with open(short_video_path, "wb") as f:
+with open(short_video_path, 'wb') as f:
     for chunk in response.iter_content():
         f.write(chunk)
 
 long_video_path = Path(temp_dir) / "long_video.mp4"
 ffmpeg_command = [
     "ffmpeg",
-    "-stream_loop",
-    "99",  # repeat video 100 times
-    "-i",
-    f"{short_video_path}",
-    "-c",
-    "copy",
+    "-stream_loop", "99",  # repeat video 100 times
+    "-i", f"{short_video_path}",
+    "-c", "copy",
     f"{long_video_path}",
 ]
 subprocess.run(ffmpeg_command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
 from torchcodec.decoders import VideoDecoder
-
 print(f"Short video duration: {VideoDecoder(short_video_path).metadata.duration_seconds} seconds")
 print(f"Long video duration: {VideoDecoder(long_video_path).metadata.duration_seconds / 60} minutes")
 
@@ -120,7 +116,10 @@ def bench(f, average_over=50, warmup=2, **f_kwargs):
 
 def sample_clips(seek_mode):
     return samplers.clips_at_random_indices(
-        decoder=VideoDecoder(source=long_video_path, seek_mode=seek_mode),
+        decoder=VideoDecoder(
+            source=long_video_path,
+            seek_mode=seek_mode
+        ),
         num_clips=5,
         num_frames_per_clip=2,
     )
@@ -155,8 +154,7 @@ def sample_clips(seek_mode):
     torch.testing.assert_close(
         exact_decoder.get_frame_at(i).data,
         approx_decoder.get_frame_at(i).data,
-        atol=0,
-        rtol=0,
+        atol=0, rtol=0,
     )
 print("Frame seeking is the same for this video!")
 

examples/decoding/basic_cuda_example.py

@@ -154,7 +154,9 @@ def plot_cpu_and_cuda_frames(cpu_frames: torch.Tensor, cuda_frames: torch.Tensor
 # differences because CUDA math is not bit-exact with respect to CPU math.
 #
 frames_equal = torch.equal(cpu_frames.to("cuda"), cuda_frames)
-mean_abs_diff = torch.mean(torch.abs(cpu_frames.float().to("cuda") - cuda_frames.float()))
+mean_abs_diff = torch.mean(
+    torch.abs(cpu_frames.float().to("cuda") - cuda_frames.float())
+)
 max_abs_diff = torch.max(torch.abs(cpu_frames.to("cuda").float() - cuda_frames.float()))
 print(f"{frames_equal=}")
 print(f"{mean_abs_diff=}")

examples/decoding/basic_example.py

@@ -13,7 +13,6 @@
 :class:`~torchcodec.decoders.VideoDecoder` class.
 """
 
-from __future__ import annotations
 
 # %%
 # First, a bit of boilerplate: we'll download a video from the web, and define a

examples/decoding/custom_frame_mappings.py

@@ -41,25 +41,21 @@
 
 temp_dir = tempfile.mkdtemp()
 short_video_path = Path(temp_dir) / "short_video.mp4"
-with open(short_video_path, "wb") as f:
+with open(short_video_path, 'wb') as f:
     for chunk in response.iter_content():
         f.write(chunk)
 
 long_video_path = Path(temp_dir) / "long_video.mp4"
 ffmpeg_command = [
     "ffmpeg",
-    "-stream_loop",
-    "50",  # repeat video 50 times to get a ~12 min video
-    "-i",
-    f"{short_video_path}",
-    "-c",
-    "copy",
+    "-stream_loop", "50",  # repeat video 50 times to get a ~12 min video
+    "-i", f"{short_video_path}",
+    "-c", "copy",
     f"{long_video_path}",
 ]
 subprocess.run(ffmpeg_command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
 from torchcodec.decoders import VideoDecoder
-
 print(f"Short video duration: {VideoDecoder(short_video_path).metadata.duration_seconds} seconds")
 print(f"Long video duration: {VideoDecoder(long_video_path).metadata.duration_seconds / 60} minutes")
 
@@ -88,15 +84,12 @@
 def generate_frame_mappings(video_path, output_json_path, stream_index):
     ffprobe_cmd = [
         "ffprobe",
-        "-i",
-        f"{video_path}",
-        "-select_streams",
-        f"{stream_index}",
+        "-i", f"{video_path}",
+        "-select_streams", f"{stream_index}",
         "-show_frames",
         "-show_entries",
         "frame=pts,duration,key_frame",
-        "-of",
-        "json",
+        "-of", "json",
     ]
     print(f"Running ffprobe:\n{' '.join(ffprobe_cmd)}\n")
     ffprobe_result = subprocess.run(ffprobe_cmd, check=True, capture_output=True, text=True)
@@ -173,7 +166,11 @@ def bench(f, file_like=False, average_over=50, warmup=2, **f_kwargs):
 
 
 def decode_frames(video_path, seek_mode="exact", custom_frame_mappings=None):
-    decoder = VideoDecoder(source=video_path, seek_mode=seek_mode, custom_frame_mappings=custom_frame_mappings)
+    decoder = VideoDecoder(
+        source=video_path,
+        seek_mode=seek_mode,
+        custom_frame_mappings=custom_frame_mappings
+    )
     decoder.get_frames_in_range(start=0, stop=10)
 
 
@@ -207,8 +204,7 @@ def decode_frames(video_path, seek_mode="exact", custom_frame_mappings=None):
     torch.testing.assert_close(
         exact_decoder.get_frame_at(i).data,
         custom_frame_mappings_decoder.get_frame_at(i).data,
-        atol=0,
-        rtol=0,
+        atol=0, rtol=0,
     )
 print("Frame seeking is the same for this video!")
 

examples/decoding/file_like.py

@@ -158,7 +158,7 @@ def stream_while_decode():
     # session; we need to indicate that we need to trust the environment
     # settings for proxy configuration. Depending on your environment, you may
     # not need this setting.
-    with fsspec.open(nasa_url, client_kwargs={"trust_env": True}) as file_like:
+    with fsspec.open(nasa_url, client_kwargs={'trust_env': True}) as file_like:
         decoder = VideoDecoder(file_like, seek_mode="approximate")
         return decoder[0]
 
@@ -226,20 +226,18 @@ def seek(self, offset: int, whence: int) -> int:
 file_op_counter = FileOpCounter(open(nasa_video_path, "rb"))
 counter_decoder = VideoDecoder(file_op_counter, seek_mode="approximate")
 
-print(
-    "Decoder initialization required " f"{file_op_counter.num_reads} reads and " f"{file_op_counter.num_seeks} seeks."
-)
+print("Decoder initialization required "
+      f"{file_op_counter.num_reads} reads and "
+      f"{file_op_counter.num_seeks} seeks.")
 
 init_reads = file_op_counter.num_reads
 init_seeks = file_op_counter.num_seeks
 
 first_frame = counter_decoder[0]
 
-print(
-    "Decoding the first frame required "
-    f"{file_op_counter.num_reads - init_reads} additional reads and "
-    f"{file_op_counter.num_seeks - init_seeks} additional seeks."
-)
+print("Decoding the first frame required "
+      f"{file_op_counter.num_reads - init_reads} additional reads and "
+      f"{file_op_counter.num_seeks - init_seeks} additional seeks.")
 
 # %%
 # While we defined a simple class primarily for demonstration, it's actually
@@ -301,6 +299,5 @@ def decode_from_existing_open_file_object():
 # %%
 # Finally, let's clean up the local resources we created.
 import shutil
-
 shutil.rmtree(temp_dir)
 # %%

examples/decoding/parallel_decoding.py

@@ -24,7 +24,6 @@
 pool manager.
 """
 
-from __future__ import annotations
 
 # %%
 # Let's first define some utility functions for benchmarking and data
@@ -97,21 +96,17 @@ def generate_long_video(temp_dir: str):
         raise RuntimeError(f"Failed to download video. {response.status_code = }.")
 
     short_video_path = Path(temp_dir) / "short_video.mp4"
-    with open(short_video_path, "wb") as f:
+    with open(short_video_path, 'wb') as f:
         for chunk in response.iter_content():
             f.write(chunk)
 
     # Create a longer video by repeating the short one 50 times
     long_video_path = Path(temp_dir) / "long_video.mp4"
     ffmpeg_command = [
-        "ffmpeg",
-        "-y",
-        "-stream_loop",
-        "49",  # repeat video 50 times
-        "-i",
-        str(short_video_path),
-        "-c",
-        "copy",
+        "ffmpeg", "-y",
+        "-stream_loop", "49",  # repeat video 50 times
+        "-i", str(short_video_path),
+        "-c", "copy",
         str(long_video_path),
     ]
     subprocess.run(ffmpeg_command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -127,9 +122,7 @@ def generate_long_video(temp_dir: str):
 
 short_duration = timedelta(seconds=VideoDecoder(short_video_path).metadata.duration_seconds)
 long_duration = timedelta(seconds=metadata.duration_seconds)
-print(
-    f"Original video duration: {int(short_duration.total_seconds() // 60)}m{int(short_duration.total_seconds() % 60):02d}s"
-)
+print(f"Original video duration: {int(short_duration.total_seconds() // 60)}m{int(short_duration.total_seconds() % 60):02d}s")
 print(f"Long video duration: {int(long_duration.total_seconds() // 60)}m{int(long_duration.total_seconds() % 60):02d}s")
 print(f"Video resolution: {metadata.width}x{metadata.height}")
 print(f"Average FPS: {metadata.average_fps:.1f}")
@@ -182,7 +175,11 @@ def decode_sequentially(indices: list[int], video_path=long_video_path):
 # threads within FFmpeg itself to accelerate decoding operations.
 
 
-def decode_with_ffmpeg_parallelism(indices: list[int], num_threads: int, video_path=long_video_path):
+def decode_with_ffmpeg_parallelism(
+    indices: list[int],
+    num_threads: int,
+    video_path=long_video_path,
+):
     """Decode frames using FFmpeg's internal threading."""
     decoder = VideoDecoder(video_path, num_ffmpeg_threads=num_threads, seek_mode="approximate")
     return decoder.get_frames_at(indices)
@@ -203,7 +200,11 @@ def decode_with_ffmpeg_parallelism(indices: list[int], num_threads: int, video_p
 # Process-based parallelism distributes work across multiple Python processes.
 
 
-def decode_with_multiprocessing(indices: list[int], num_processes: int, video_path=long_video_path):
+def decode_with_multiprocessing(
+    indices: list[int],
+    num_processes: int,
+    video_path=long_video_path,
+):
     """Decode frames using multiple processes with joblib."""
     chunks = split_indices(indices, num_chunks=num_processes)
 
@@ -229,7 +230,11 @@ def decode_with_multiprocessing(indices: list[int], num_processes: int, video_pa
 # TorchCodec releases the GIL, so this can be very effective.
 
 
-def decode_with_multithreading(indices: list[int], num_threads: int, video_path=long_video_path):
+def decode_with_multithreading(
+    indices: list[int],
+    num_threads: int,
+    video_path=long_video_path
+):
     """Decode frames using multiple threads with joblib."""
     chunks = split_indices(indices, num_chunks=num_threads)
 
@@ -260,5 +265,4 @@ def decode_with_multithreading(indices: list[int], num_threads: int, video_path=
 
 # %%
 import shutil
-
 shutil.rmtree(temp_dir)

examples/decoding/sampling.py

@@ -14,7 +14,6 @@
 input to video models.
 """
 
-from __future__ import annotations
 
 # %%
 # First, a bit of boilerplate: we'll download a video from the web, and define a

pyproject.toml

@@ -2,7 +2,7 @@
 name = "torchcodec"
 description = "A video decoder for PyTorch"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license-files = ["LICENSE"]
 authors = [
     { name = "PyTorch Team", email = "[email protected]" },
@@ -32,7 +32,7 @@ dev = [
 first_party_detection = false
 
 [tool.black]
-target-version = ["py38"]
+target-version = ["py310"]
 
 [tool.ufmt]
 

src/torchcodec/_core/_metadata.py

@@ -4,7 +4,6 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-from __future__ import annotations
 
 import dataclasses
 import json

src/torchcodec/_core/ops.py

@@ -4,7 +4,6 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-from __future__ import annotations
 
 import io
 import json