Remove manual installation of nvjpeg, nvjpeg2k and nvtiff

Signed-off-by: Joaquin Anton Guirao <janton@nvidia.com>

Author: jantonguirao

dali/operators/imgcodec/peek_image_shape.cc

@@ -25,9 +25,14 @@ DALI_SCHEMA(PeekImageShape)
 This operator returns the shape that an image would have after decoding.
 
 .. note::
-    This operator is not recommended for use with the dynamic executor (`exec_dynamic=True` in the
-    pipeline constructor).
-    Use :meth:`nvidia.dali.pipeline.DataNode.shape()` instead on the decoded images.
+    This operator is specifically designed to peek at the shape of encoded images before decoding them.
+
+    For already decoded images, you could instead use either:
+
+    * The ``shape`` operator
+    * The :meth:`nvidia.dali.pipeline.DataNode.shape()` method
+
+    When using the dynamic executor, the shape output will always be a CPU tensor, regardless of the input device location.
 )")
   .NumInput(1)
   .NumOutput(1)

dali/test/python/checkpointing/test_dali_checkpointing.py

@@ -973,27 +973,17 @@ def test_noise_shot(device):
     check_single_input_operator(fn.noise.shot, device, factor=100)
 
 
-@params("cpu", "mixed")
-@random_signed_off("image_decoder_random_crop", "decoders.image_random_crop")
-def test_image_random_crop(device):
-    @pipeline_def
-    def pipeline():
-        data, _ = fn.readers.file(name="Reader", file_root=images_dir)
-        image = fn.decoders.image_random_crop(data, device=device)
-        return image
-
-    check_pipeline_checkpointing_native(pipeline)
-
-
 @params("cpu", "mixed")
 @random_signed_off(
-    "experimental.image_decoder_random_crop", "experimental.decoders.image_random_crop"
+    "image_decoder_random_crop",
+    "decoders.image_random_crop",
+    "experimental.decoders.image_random_crop",
 )
-def test_experimental_image_random_crop(device):
+def test_image_random_crop(device):
     @pipeline_def
     def pipeline():
         data, _ = fn.readers.file(name="Reader", file_root=images_dir)
-        image = fn.experimental.decoders.image_random_crop(data, device=device)
+        image = fn.decoders.image_random_crop(data, device=device)
         return image
 
     check_pipeline_checkpointing_native(pipeline)

dali/test/python/checkpointing/test_dali_stateless_operators.py

@@ -815,16 +815,11 @@ def pipeline():
     check_is_pipeline_stateless(pipeline)
 
 
-@stateless_signed_off("peek_image_shape")
+@stateless_signed_off("peek_image_shape", "experimental.peek_image_shape")
 def test_peek_image_shape_stateless():
     check_single_encoded_jpeg_input(fn.peek_image_shape, "cpu")
 
 
-@stateless_signed_off("experimental.peek_image_shape")
-def test_imgcodec_peek_image_shape_stateless():
-    check_single_encoded_jpeg_input(fn.experimental.peek_image_shape, "cpu")
-
-
 @stateless_signed_off("decoders.audio", "audio_decoder")
 def test_audio_decoder_stateless():
     def audio_decoder_wrapper(*args, **kwargs):
@@ -834,43 +829,27 @@ def audio_decoder_wrapper(*args, **kwargs):
 
 
 @params("cpu", "mixed")
-@stateless_signed_off("decoders.image", "image_decoder")
+@stateless_signed_off("decoders.image", "image_decoder", "experimental.decoders.image")
 def test_image_decoder_stateless(device):
     check_single_encoded_jpeg_input(fn.decoders.image, device)
 
 
 @params("cpu", "mixed")
-@stateless_signed_off("experimental.decoders.image")
-def test_experimental_image_decoder_stateless(device):
-    check_single_encoded_jpeg_input(fn.experimental.decoders.image, device)
-
-
-@params("cpu", "mixed")
-@stateless_signed_off("decoders.image_crop", "image_decoder_crop")
+@stateless_signed_off(
+    "decoders.image_crop", "image_decoder_crop", "experimental.decoders.image_crop"
+)
 def test_image_decoder_crop_stateless(device):
     check_single_encoded_jpeg_input(fn.decoders.image_crop, device, crop=(20, 50))
 
 
 @params("cpu", "mixed")
-@stateless_signed_off("experimental.decoders.image_crop")
-def test_experimental_image_decoder_crop_stateless(device):
-    check_single_encoded_jpeg_input(fn.experimental.decoders.image_crop, device, crop=(20, 50))
-
-
-@params("cpu", "mixed")
-@stateless_signed_off("decoders.image_slice", "image_decoder_slice")
+@stateless_signed_off(
+    "decoders.image_slice", "image_decoder_slice", "experimental.decoders.image_slice"
+)
 def test_image_decoder_slice_stateless(device):
     check_single_encoded_jpeg_input(fn.decoders.image_slice, device, start=(5, 5), end=(45, 45))
 
 
-@params("cpu", "mixed")
-@stateless_signed_off("experimental.decoders.image_slice")
-def test_experimental_image_decoder_slice_stateless(device):
-    check_single_encoded_jpeg_input(
-        fn.experimental.decoders.image_slice, device, start=(5, 5), end=(45, 45)
-    )
-
-
 @params("cpu", "gpu")
 @stateless_signed_off("coord_flip")
 def test_coord_flip_stateless(device):

dali/test/python/decoder/test_imgcodec.py

@@ -51,7 +51,7 @@ def get_img_files(data_path, subdir="*", ext=None):
 @pipeline_def
 def decoder_pipe(data_path, device, use_fast_idct=False, jpeg_fancy_upsampling=False):
     inputs, labels = fn.readers.file(file_root=data_path, shard_id=0, num_shards=1, name="Reader")
-    decoded = fn.experimental.decoders.image(
+    decoded = fn.decoders.image(
         inputs,
         device=device,
         output_type=types.RGB,
@@ -102,11 +102,9 @@ def create_decoder_slice_pipeline(data_path, device):
 
     anchor = fn.random.uniform(range=[0.05, 0.15], shape=(2,))
     shape = fn.random.uniform(range=[0.5, 0.7], shape=(2,))
-    images_sliced_1 = fn.experimental.decoders.image_slice(
-        jpegs, anchor, shape, axes=(0, 1), device=device
-    )
+    images_sliced_1 = fn.decoders.image_slice(jpegs, anchor, shape, axes=(0, 1), device=device)
 
-    images = fn.experimental.decoders.image(jpegs, device=device)
+    images = fn.decoders.image(jpegs, device=device)
     images_sliced_2 = fn.slice(images, anchor, shape, axes=(0, 1))
 
     return images_sliced_1, images_sliced_2
@@ -121,11 +119,11 @@ def create_decoder_crop_pipeline(data_path, device):
     w = 242
     h = 230
 
-    images_crop_1 = fn.experimental.decoders.image_crop(
+    images_crop_1 = fn.decoders.image_crop(
         jpegs, crop=(w, h), crop_pos_x=crop_pos_x, crop_pos_y=crop_pos_y, device=device
     )
 
-    images = fn.experimental.decoders.image(jpegs, device=device)
+    images = fn.decoders.image(jpegs, device=device)
 
     images_crop_2 = fn.crop(images, crop=(w, h), crop_pos_x=crop_pos_x, crop_pos_y=crop_pos_y)
 
@@ -139,12 +137,12 @@ def create_decoder_random_crop_pipeline(data_path, device):
 
     w = 242
     h = 230
-    images_random_crop_1 = fn.experimental.decoders.image_random_crop(
+    images_random_crop_1 = fn.decoders.image_random_crop(
         jpegs, device=device, output_type=types.RGB, seed=seed
     )
     images_random_crop_1 = fn.resize(images_random_crop_1, size=(w, h))
 
-    images = fn.experimental.decoders.image(jpegs, device=device)
+    images = fn.decoders.image(jpegs, device=device)
     images_random_crop_2 = fn.random_resized_crop(images, size=(w, h), seed=seed)
 
     return images_random_crop_1, images_random_crop_2
@@ -299,7 +297,7 @@ def test_fancy_upsampling(batch_size):
 @pipeline_def(batch_size=batch_size_test, device_id=0, num_threads=4)
 def img_decoder_pipe(device, out_type, files):
     encoded, _ = fn.readers.file(files=files)
-    decoded = fn.experimental.decoders.image(encoded, device=device, output_type=out_type)
+    decoded = fn.decoders.image(encoded, device=device, output_type=out_type)
     return decoded
 
 
@@ -338,8 +336,8 @@ def _testimpl_image_decoder_tiff_with_alpha_16bit(device, out_type, path, ext):
     @pipeline_def(batch_size=1, device_id=0, num_threads=1)
     def pipe(device, out_type, files):
         encoded, _ = fn.readers.file(files=files)
-        decoded = fn.experimental.decoders.image(encoded, device=device, output_type=out_type)
-        peeked_shape = fn.experimental.peek_image_shape(encoded)
+        decoded = fn.decoders.image(encoded, device=device, output_type=out_type)
+        peeked_shape = fn.peek_image_shape(encoded)
         return decoded, peeked_shape
 
     files = get_img_files(os.path.join(test_data_root, path), ext=ext, subdir=None)
@@ -367,9 +365,7 @@ def _testimpl_image_decoder_crop_error_oob(device):
     @pipeline_def(batch_size=batch_size_test, device_id=0, num_threads=4)
     def pipe(device):
         encoded, _ = fn.readers.file(file_root=file_root)
-        decoded = fn.experimental.decoders.image_crop(
-            encoded, crop_w=10000, crop_h=100, device=device
-        )
+        decoded = fn.decoders.image_crop(encoded, crop_w=10000, crop_h=100, device=device)
         return decoded
 
     p = pipe(device)
@@ -389,9 +385,7 @@ def _testimpl_image_decoder_slice_error_oob(device):
     @pipeline_def(batch_size=batch_size_test, device_id=0, num_threads=4)
     def pipe(device):
         encoded, _ = fn.readers.file(file_root=file_root)
-        decoded = fn.experimental.decoders.image_slice(
-            encoded, device=device, end=[10000], axes=[1]
-        )
+        decoded = fn.decoders.image_slice(encoded, device=device, end=[10000], axes=[1])
         return decoded
 
     p = pipe(device)
@@ -412,8 +406,8 @@ def test_tiff_palette():
     @pipeline_def(batch_size=2, device_id=0, num_threads=1)
     def pipe():
         encoded, _ = fn.readers.file(files=[normal, palette])
-        peeked_shapes = fn.experimental.peek_image_shape(encoded)
-        decoded = fn.experimental.decoders.image(encoded, device="cpu")
+        peeked_shapes = fn.peek_image_shape(encoded)
+        decoded = fn.decoders.image(encoded, device="cpu")
         return decoded, peeked_shapes
 
     p = pipe()
@@ -434,7 +428,7 @@ def _testimpl_image_decoder_peek_shape(
     @pipeline_def(batch_size=1, device_id=0, num_threads=1)
     def peek_shape_pipeline(file):
         encoded, _ = fn.readers.file(files=[file])
-        return fn.experimental.peek_image_shape(
+        return fn.peek_image_shape(
             encoded, image_type=image_type, adjust_orientation=adjust_orientation
         )
 
@@ -500,9 +494,7 @@ def test_image_decoder_lossless_jpeg(img_name, output_type, dtype, precision):
     @pipeline_def(batch_size=1, device_id=device_id, num_threads=1)
     def pipe(file):
         encoded, _ = fn.readers.file(files=[file])
-        decoded = fn.experimental.decoders.image(
-            encoded, device="mixed", dtype=dtype, output_type=output_type
-        )
+        decoded = fn.decoders.image(encoded, device="mixed", dtype=dtype, output_type=output_type)
         return decoded
 
     p = pipe(data_dir + f"/{img_name}.jpg")
@@ -528,7 +520,7 @@ def test_image_decoder_lossless_jpeg_cpu_not_supported():
     @pipeline_def(batch_size=1, device_id=0, num_threads=1)
     def pipe(file):
         encoded, _ = fn.readers.file(files=[file])
-        decoded = fn.experimental.decoders.image(
+        decoded = fn.decoders.image(
             encoded, device="cpu", dtype=types.UINT16, output_type=types.ANY_DATA
         )
         return decoded

dali/test/python/operator_2/test_filter.py

@@ -70,7 +70,7 @@ def images_pipeline(dev, shapes, border, in_dtype, mode):
     images, _ = fn.readers.file(
         name="Reader", file_root=images_dir, prefetch_queue_depth=2, random_shuffle=True, seed=42
     )
-    images = fn.experimental.decoders.image(
+    images = fn.decoders.image(
         images, device="cpu", output_type=types.RGB, dtype=np_type_to_dali(in_dtype)
     )
     if dev == "gpu":

dali/test/python/test_dali_cpu_only.py

@@ -323,26 +323,14 @@ def test_image_decoder_cpu():
     _test_image_decoder_args_cpu(fn.decoders.image)
 
 
-def test_experimental_image_decoder_cpu():
-    _test_image_decoder_args_cpu(fn.experimental.decoders.image)
-
-
 def test_image_decoder_crop_cpu():
     _test_image_decoder_args_cpu(fn.decoders.image_crop, crop=(10, 10))
 
 
-def test_experimental_image_decoder_crop_cpu():
-    _test_image_decoder_args_cpu(fn.experimental.decoders.image_crop, crop=(10, 10))
-
-
 def test_image_decoder_random_crop_cpu():
     _test_image_decoder_args_cpu(fn.decoders.image_random_crop)
 
 
-def test_experimental_image_decoder_random_crop_cpu():
-    _test_image_decoder_args_cpu(fn.experimental.decoders.image_random_crop)
-
-
 def test_coin_flip_cpu():
     check_no_input(fn.random.coin_flip)
 
@@ -723,10 +711,6 @@ def test_image_decoder_slice_cpu():
     _test_image_decoder_slice_cpu(fn.decoders.image_slice)
 
 
-def test_experimental_image_decoder_slice_cpu():
-    _test_image_decoder_slice_cpu(fn.experimental.decoders.image_slice)
-
-
 def test_pad_cpu():
     pipe = Pipeline(batch_size=batch_size, num_threads=4, device_id=None)
     test_data_shape = [5, 4, 3]
@@ -1220,10 +1204,6 @@ def test_peek_image_shape_cpu():
     _test_peek_image_shape_cpu(fn.peek_image_shape)
 
 
-def test_experimental_peek_image_shape_cpu():
-    _test_peek_image_shape_cpu(fn.experimental.peek_image_shape)
-
-
 def test_separated_exec_setup():
     batch_size = 128
     pipe = Pipeline(
@@ -1408,19 +1388,19 @@ def test_warp_perspective():
     "_conditional.not_",
     "_conditional.validate_logical",
     "audio_decoder",
-    "image_decoder",
-    "image_decoder_slice",
-    "image_decoder_crop",
-    "image_decoder_random_crop",
     "decoders.image",
     "decoders.image_crop",
     "decoders.image_slice",
     "decoders.image_random_crop",
-    "experimental.debayer",
+    "image_decoder",
+    "image_decoder_slice",
+    "image_decoder_crop",
+    "image_decoder_random_crop",
     "experimental.decoders.image",
     "experimental.decoders.image_crop",
     "experimental.decoders.image_slice",
     "experimental.decoders.image_random_crop",
+    "experimental.debayer",
     "experimental.inputs.video",
     "decoders.audio",
     "external_source",