Fix lint issues

Signed-off-by: Victor Chang <vicchang@nvidia.com>

Author: mocsharp

applications/h264/h264_video_encode_decode/python/h264_video_encode_decode.py

@@ -25,10 +25,15 @@
 from holoscan.core import Application, Tracker
 from holoscan.gxf import load_extensions
 from holoscan.operators import FormatConverterOp, GXFCodeletOp, HolovizOp, VideoStreamReplayerOp
-from holoscan.resources import BlockMemoryPool, GXFComponentResource, RMMAllocator, MemoryStorageType
+from holoscan.resources import (
+    BlockMemoryPool,
+    GXFComponentResource,
+    MemoryStorageType,
+    RMMAllocator,
+)
 
-from holohub.tensor_to_video_buffer import TensorToVideoBufferOp
 from holohub.append_timestamp import AppendTimestampOp
+from holohub.tensor_to_video_buffer import TensorToVideoBufferOp
 
 # Import h.264 GXF codelets and components as Holoscan operators and resources
 # Starting with Holoscan SDK v2.1.0, importing GXF codelets/components as Holoscan operators/
@@ -124,6 +129,7 @@ class VideoEncoderRequestOp(GXFCodeletOp):
     def __init__(self, fragment, *args, **kwargs):
         super().__init__(fragment, "nvidia::gxf::VideoEncoderRequest", *args, **kwargs)
 
+
 class H264VideoEncodeDecodeApp(Application):
     def __init__(self, data):
         """Initialize the H264 video decode application"""
@@ -172,9 +178,7 @@ def compose(self):
             self, name="tensor_to_video_buffer", **self.kwargs("tensor_to_video_buffer")
         )
         encoder_async_condition = AsynchronousCondition(self, "encoder_async_condition")
-        video_encoder_context = VideoEncoderContext(
-            self, scheduling_term=encoder_async_condition
-        )
+        video_encoder_context = VideoEncoderContext(self, scheduling_term=encoder_async_condition)
 
         video_encoder_request = VideoEncoderRequestOp(
             self,
@@ -257,8 +261,12 @@ def compose(self):
 
         self.add_flow(source, format_converter, {("output", "source_video")})
         self.add_flow(format_converter, tensor_to_video_buffer, {("tensor", "in_tensor")})
-        self.add_flow(tensor_to_video_buffer, video_encoder_request, {("out_video_buffer", "input_frame")})
-        self.add_flow(video_encoder_response, append_timestamp, {("output_transmitter", "in_tensor")})
+        self.add_flow(
+            tensor_to_video_buffer, video_encoder_request, {("out_video_buffer", "input_frame")}
+        )
+        self.add_flow(
+            video_encoder_response, append_timestamp, {("output_transmitter", "in_tensor")}
+        )
         self.add_flow(append_timestamp, video_decoder_request, {("out_tensor", "input_frame")})
         self.add_flow(
             video_decoder_response,
@@ -306,6 +314,3 @@ def compose(self):
     with Tracker(app) as trackers:
         app.run()
         trackers.print()
-
-
-

applications/nvidia_video_codec/python/nvidia_video_codec.py

@@ -18,16 +18,12 @@
 
 from holoscan.core import Application, Operator, Tracker
 from holoscan.operators import FormatConverterOp, HolovizOp, VideoStreamReplayerOp
-from holoscan.resources import (
-    BlockMemoryPool,
-    CudaStreamPool,
-    MemoryStorageType,
-    RMMAllocator,
-)
+from holoscan.resources import BlockMemoryPool, CudaStreamPool, MemoryStorageType, RMMAllocator
 
 from holohub.nv_video_decoder import NvVideoDecoderOp
 from holohub.nv_video_encoder import NvVideoEncoderOp
 
+
 class StatsOp(Operator):
     def __init__(self, app, *args, **kwargs):
         self.encode_latency = []
@@ -51,10 +47,18 @@ def compute(self, op_input, op_output, context):
         self.jitter_time.append(self.metadata["jitter_time"])
         self.fps.append(self.metadata["fps"])
 
-        print(f"Encode Latency (min, max, avg): {min(self.encode_latency):.3f}, {max(self.encode_latency):.3f}, {sum(self.encode_latency) / len(self.encode_latency):.3f}")
-        print(f"Decode Latency (min, max, avg): {min(self.decode_latency):.3f}, {max(self.decode_latency):.3f}, {sum(self.decode_latency) / len(self.decode_latency):.3f}")
-        print(f"Jitter Time (min, max, avg): {min(self.jitter_time):.3f}, {max(self.jitter_time):.3f}, {sum(self.jitter_time) / len(self.jitter_time):.3f}")
-        print(f"FPS (min, max, avg): {min(self.fps):.3f}, {max(self.fps):.3f}, {sum(self.fps) / len(self.fps):.3f}")
+        print(
+            f"Encode Latency (min, max, avg): {min(self.encode_latency):.3f}, {max(self.encode_latency):.3f}, {sum(self.encode_latency) / len(self.encode_latency):.3f}"
+        )
+        print(
+            f"Decode Latency (min, max, avg): {min(self.decode_latency):.3f}, {max(self.decode_latency):.3f}, {sum(self.decode_latency) / len(self.decode_latency):.3f}"
+        )
+        print(
+            f"Jitter Time (min, max, avg): {min(self.jitter_time):.3f}, {max(self.jitter_time):.3f}, {sum(self.jitter_time) / len(self.jitter_time):.3f}"
+        )
+        print(
+            f"FPS (min, max, avg): {min(self.fps):.3f}, {max(self.fps):.3f}, {sum(self.fps) / len(self.fps):.3f}"
+        )
 
 
 class NVIDIAVideoCodecApp(Application):
@@ -191,4 +195,3 @@ def compose(self):
     with Tracker(app) as tracker:
         app.run()
         tracker.print()
-