fix: Reorganize folders in latest implementation

- Update test references and imports accordingly

Author: gs-olive

py/torch_tensorrt/_Input.py

@@ -68,6 +68,17 @@ def __init__(self, *args, **kwargs):
             - Input(shape=(1,3,32,32), dtype=torch_tensorrt.dtype.int32, format=torch_tensorrt.TensorFormat.NCHW)
             - Input(min_shape=(1,3,32,32), opt_shape=[2,3,32,32], max_shape=(3,3,32,32)) #Implicitly dtype=torch_tensorrt.dtype.float32, format=torch_tensorrt.TensorFormat.NCHW
         """
+        # Compatibility code for switching over from InputTensorSpec
+        if "shape" in kwargs and "shape_ranges" in kwargs:
+            assert (
+                len(kwargs["shape_ranges"]) == 1 and len(kwargs["shape_ranges"][0]) == 3
+            )
+            del kwargs["shape"]
+
+            kwargs["min_shape"] = kwargs["shape_ranges"][0][0]
+            kwargs["opt_shape"] = kwargs["shape_ranges"][0][1]
+            kwargs["max_shape"] = kwargs["shape_ranges"][0][2]
+
         if len(args) == 1:
             if not Input._supported_input_size_type(args[0]):
                 raise TypeError(

py/torch_tensorrt/dynamo/__init__.py

@@ -2,8 +2,8 @@
 from torch_tensorrt._util import sanitized_torch_version
 
 if version.parse(sanitized_torch_version()) >= version.parse("2.1.dev"):
-    from .converters import *
     from ._settings import *
+    from .conversion import *
     from .aten_tracer import trace
     from .converter_registry import (
         DYNAMO_CONVERTERS,

py/torch_tensorrt/dynamo/converters/SourceIR.py renamed to py/torch_tensorrt/dynamo/conversion/SourceIR.py

@@ -1,3 +1,5 @@
+from .SourceIR import SourceIR
+from .aten_ops_converters import *
 from .trt_interpreter import *
 from .conversion import *
 from .truncate_long_and_double import repair_long_or_double_inputs

py/torch_tensorrt/dynamo/conversion/__init__.py

@@ -1,13 +1,13 @@
 import logging
 from typing import Dict, Sequence, Tuple, Union
 import torch
+import tensorrt as trt
 from torch_tensorrt.fx.converters import acc_ops_converters
 from ..converter_registry import dynamo_tensorrt_converter
 from torch.fx.node import Argument, Target
 
 from torch_tensorrt.fx.types import TRTNetwork, TRTTensor
-from torch_tensorrt.dynamo.converters import SourceIR
-from torch_tensorrt.dynamo.converters import impl
+from torch_tensorrt.dynamo.conversion import SourceIR, impl
 
 _LOGGER: logging.Logger = logging.getLogger(__name__)
 

py/torch_tensorrt/dynamo/converters/aten_ops_converters.py renamed to py/torch_tensorrt/dynamo/conversion/aten_ops_converters.py

@@ -1,5 +1,11 @@
 import torch
 
+from torch_tensorrt.fx.types import (
+    TRTDataType,
+    TRTNetwork,
+    TRTTensor,
+)
+
 
 def dynamic_unsupported(node: torch.fx.Node) -> bool:
     # Validate that none of the inputs to the node have Dynamic shapes
@@ -28,3 +34,63 @@ def dynamic_unsupported(node: torch.fx.Node) -> bool:
         return False
 
     return True
+
+
+def cast_trt_tensor(
+    network: TRTNetwork,
+    input_val: TRTTensor,
+    dtype: TRTDataType,
+    name: str,
+) -> TRTTensor:
+    """
+    Given a TRT Tensor, convert that Tensor to the specified dtype
+    Adds an Identity layer to the network which performs the conversion
+    Args:
+        network (TRTNetwork): A TensorRT network
+        input_val (TRTTensor): A TRT Tensor to cast to a new data type
+        dtype (TRTDataType): The TRTDataType to cast the input Tensor to
+        name (str): Name of the calling layer
+    Returns:
+        A TensorRT ITensor which has been casted to the specified dtype
+    """
+    #
+    if input_val.dtype != dtype:
+        identity_layer = network.add_identity(input_val)
+        identity_layer.set_output_type(0, dtype)
+        identity_layer.name = (
+            f"Cast ITensor {input_val.name} from {input_val.dtype} to {dtype} - {name}"
+        )
+        return identity_layer.get_output(0)
+    else:
+        return input_val
+
+
+def broadcastable(
+    a: TRTTensor,
+    b: TRTTensor,
+) -> bool:
+    "Check if two tensors are broadcastable according to torch rules"
+    a_shape = tuple(a.shape)
+    b_shape = tuple(b.shape)
+    # check from the trailing
+    diff = len(a_shape) - len(b_shape)
+    if diff == 0:
+        return True
+    if diff > 0:
+        max = len(a_shape)
+        min = len(b_shape)
+        greater_tensor = a_shape
+        lesser_tensor = b_shape
+    elif diff < 0:
+        max = len(b_shape)
+        min = len(a_shape)
+        greater_tensor = b_shape
+        lesser_tensor = a_shape
+    j = min - 1
+    for i in range(max - 1, diff - 1, -1):
+        if not (
+            greater_tensor[i] != lesser_tensor[j]
+            and (greater_tensor[i] == 1 or lesser_tensor[i] == 1)
+        ):
+            return False
+    return True

py/torch_tensorrt/dynamo/conversion/converter_utils.py

@@ -12,7 +12,7 @@
     set_layer_name,
     get_trt_plugin,
 )
-from torch_tensorrt.dynamo.converters import SourceIR
+from torch_tensorrt.dynamo.conversion import SourceIR
 
 from torch_tensorrt.fx.types import (
     TRTNetwork,

py/torch_tensorrt/dynamo/converters/impl/__init__.py renamed to py/torch_tensorrt/dynamo/conversion/impl/__init__.py

@@ -6,14 +6,14 @@
 from torch.fx.node import Target
 
 from torch_tensorrt.fx.types import TRTNetwork, TRTTensor
-from torch_tensorrt.dynamo.converters import SourceIR
-from torch_tensorrt.dynamo.converters.converter_utils import broadcastable
+from torch_tensorrt.dynamo.conversion import SourceIR
+from torch_tensorrt.dynamo.conversion.converter_utils import broadcastable
 from torch_tensorrt.fx.converters.converter_utils import (
     broadcast,
     get_trt_tensor,
     set_layer_name,
 )
-from torch_tensorrt.dynamo.converters.impl.slice import expand
+from torch_tensorrt.dynamo.conversion.impl.slice import expand
 
 
 def where(