Removes dead code

Author: pranavm-nvidia

tripy/tests/README.md

@@ -74,13 +74,13 @@ detect dead code. *This **will** include false positives for our code, so be car
 You can run it with:
 
 ```bash
-vulture tripy tests --sort-by-size
+vulture . --sort-by-size
 ```
 
 To exclude false positives, use:
 
 ```bash
-vulture tripy tests --sort-by-size --min-confidence=100
+vulture . --sort-by-size --min-confidence=100
 ```
 
 

tripy/tests/backend/api/test_stream.py

@@ -12,11 +12,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import pytest
-import gc, sys
-import tripy as tp
 import cupy as cp
 
+import tripy as tp
+
 
 def test_default_stream_creation():
     default_stream1 = tp.default_stream()

tripy/tests/common/test_utils.py

@@ -16,21 +16,11 @@
 #
 
 import pytest
-import struct
-from collections import ChainMap
-from textwrap import dedent
-
-import cupy as cp
-import torch
+from tests import helper
 
 import tripy.common.datatype
-
-from tests import helper
 from tripy.common.exception import TripyException
-from tripy.common.utils import (
-    convert_list_to_array,
-    get_element_type,
-)
+from tripy.common.utils import convert_list_to_array, get_element_type
 
 
 def test_get_element_type():

tripy/tests/constraints/test_dtypes.py

@@ -36,7 +36,6 @@
 PUBLIC_API_TENSOR_FUNCTIONS = []
 PUBLIC_API_TENSOR_FUNCTION_NAMES = []
 for api in PUBLIC_APIS:
-    is_module = False
     if inspect.isfunction(api.obj):
         funcs = [api.obj]
     elif inspect.isclass(api.obj):

tripy/tripy/backend/mlir/utils.py

@@ -107,41 +107,6 @@ def list_to_dense_attr(data: List, mlir_dtype):
     return attrs
 
 
-def get_mlir_quant_dtype(
-    origin_dtype: "tripy.dtype",
-    quant_dtype: "tripy.dtype",
-    scale: float,
-    zero_point: int,
-    storage_type_min: int,
-    storage_type_max: int,
-):
-    """
-    Converts a tripy data type to an MLIR quantized data type.
-
-    Args:
-        origin_dtype: original data type to be quantized
-        quant_dtype: target data type to quantize
-        dtype: One of int4, int8, float8
-        scale: scale value of quantized tensor
-        zero_point: zero point of quantized tensor
-        storage_type_min: min value of quantized dtype
-        storage_type_max: max value of quantized dtype
-    """
-    from mlir_tensorrt.compiler.dialects import quant
-
-    storage_type = get_mlir_dtype(quant_dtype)
-    expressed_type = get_mlir_dtype(origin_dtype)
-    return quant.UniformQuantizedType.get(
-        quant.UniformQuantizedType.FLAG_SIGNED,
-        storage_type,
-        expressed_type,
-        scale,
-        zero_point,
-        storage_type_min,
-        storage_type_max,
-    )
-
-
 def make_mlir_tensor(
     dtype: "tripy.common.dtype", shape: Optional[Sequence[int]] = None, rank: Optional[int] = None
 ) -> ir.RankedTensorType:

tripy/tripy/flat_ir/flat_ir.py

@@ -177,10 +177,6 @@ def _create_new_function(
         def _get_function_input_types(func: FlatIRFunction, mlir_tensor_map: Dict[str, ir.Value]) -> List[ir.Type]:
             """Get the input types for a function, converting to dynamic tensors if necessary."""
 
-            def convert_to_dynamic_tensor(rtt: ir.RankedTensorType) -> ir.RankedTensorType:
-                dynamic_shape = [ir.ShapedType.get_dynamic_size()] * rtt.rank
-                return ir.RankedTensorType.get(dynamic_shape, rtt.element_type)
-
             # Skip converting to dynamic tensor for Quantize/Dequantize scale operation.
             if "Quantize" in func.name or "Dequantize" in func.name:
                 return [

tripy/tripy/frontend/trace/ops/convolution.py

@@ -19,7 +19,7 @@
 from dataclasses import dataclass
 
 import tripy.frontend.trace.ops.utils as op_utils
-from tripy import constraints, utils
+from tripy import constraints
 from tripy.frontend.trace.ops.base import BaseTraceOp
 
 
@@ -31,35 +31,6 @@ class Convolution(BaseTraceOp):
     lhs_dilation: Sequence[int]
     rhs_dilation: Sequence[int]
 
-    def verify_spatial_rank(self, attr, rank, string):
-        spatial_rank = rank - 2
-        if attr and len(attr) != spatial_rank:
-            utils.raise_error_io_info(
-                self,
-                f"Number of {string} values does not match number of spatial dimensions in the input.",
-                details=[
-                    f"Got {len(attr)} {string} value pairs but the number of spatial dimensions is: {spatial_rank}.",
-                ],
-            )
-
-    def validate_inputs(self, tensor_shape, kernel_shape):
-        if len(tensor_shape) != len(kernel_shape):
-            utils.raise_error_io_info(
-                self,
-                "Input tensor and kernel must have the same rank.",
-                details=[
-                    f"Input tensor for operation: 'convolution' has shape: {tensor_shape} [rank = {len(tensor_shape)}], "
-                    f"but should have the same rank as the kernel of shape: {kernel_shape} [rank = {len(kernel_shape)}]."
-                ],
-            )
-
-        rank = len(tensor_shape)
-
-        self.verify_spatial_rank(self.padding, rank, "padding")
-        self.verify_spatial_rank(self.stride, rank, "stride")
-        self.verify_spatial_rank(self.lhs_dilation, rank, "lhs_dilation")
-        self.verify_spatial_rank(self.rhs_dilation, rank, "rhs_dilation")
-
     infer_rank = op_utils.InferRankPolicies.same_as_input()
 
     def infer_dtypes(self):

tripy/tripy/frontend/trace/ops/utils.py

@@ -43,21 +43,10 @@ def is_minus_one(arg):
 
 
 ##
-## Inferring shape helpers
+## infer_rank helpers
 ##
 
 
-def infer_broadcasted_shape(*input_shapes: Sequence[List[int]]):
-    """
-    Given dynamic input shapes of trace tensors, infers a broadcasted shape.
-    This does not do any error checking since that can be done more reliably
-    later in the compiler.
-    """
-    max_rank = max(len(shape) for shape in input_shapes)
-    input_shapes = [[1] * (max_rank - len(shape)) + shape for shape in input_shapes]
-    return [max(dim) for dim in zip(*input_shapes)]
-
-
 class InferRankPolicies:
     def same_as_input(idx=0):
         def impl(self):
@@ -177,29 +166,6 @@ def reshape_scalar_to_1d(input: "FlatIRTensor"):
 ##
 
 
-def get_broadcast_compatible_shapes(shape1, shape2):
-    # Make the shorter shape the same length as the longer shape by padding with ones
-    if len(shape1) > len(shape2):
-        shape2 = (1,) * (len(shape1) - len(shape2)) + shape2
-    elif len(shape2) > len(shape1):
-        shape1 = (1,) * (len(shape2) - len(shape1)) + shape1
-
-    return shape1, shape2
-
-
-def is_broadcast_compatible(shape1, shape2) -> Result:
-    # Now check each dimension pair
-    for index, (dim1, dim2) in enumerate(zip(shape1, shape2)):
-        if dim1 != dim2 and dim1 != 1 and dim2 != 1:
-            return Result.err(
-                [
-                    f"for tensor shapes: {shape1} and {shape2}, dimensions on axis {index}: '{dim1}' and '{dim2}' are not broadcast compatible"
-                ],
-            )
-
-    return Result.ok()
-
-
 # Given two shapes, compute the shape of the resulting broadcast. Assumes that the shapes are of equal rank
 def compute_shape_of_broadcast(
     shape1, shape2, output_rank: int, shape1_name: Optional[str] = None, shape2_name: Optional[str] = None
@@ -358,10 +324,6 @@ def is_quantized_dtype(dtype: "tripy.common.datatype.dtype") -> bool:
     return dtype in QUANTIZED_DTYPES
 
 
-def is_quantizable_dtype(dtype: "tripy.common.datatype.dtype") -> bool:
-    return dtype in QUANTIZABLE_DTYPES
-
-
 def get_clamp_min_max(element_dtype, quant_dtype):
     QUANT_CLAMP_MIN_MAX = {
         tp_dtype.int8: (-128.0, 127.0),

tripy/tripy/utils/ast.py

@@ -16,9 +16,7 @@
 #
 
 import ast
-import inspect
-import textwrap
-from typing import Callable, List, Optional, Tuple
+from typing import List, Optional, Tuple
 
 from tripy.utils.result import Result
 from tripy.utils.stack_info import SourceInfo
@@ -181,25 +179,3 @@ def check_name_matches():
             candidate_column_offsets.append((indentation + node.col_offset, indentation + node.end_col_offset))
 
     return candidate_column_offsets
-
-
-def find_node_in_method(method, node_finder: Callable) -> List[str]:
-    """
-    Returns a list of source line of code where node is found.
-
-    Args:
-        method: Source function where node is searched.
-        node_finder (Callable): User function that takes (node, source) and returns a bool whether node is found in ast or not.
-
-    Returns:
-        List[str]: List of source line of code
-    """
-    source = textwrap.dedent(inspect.getsource(method))
-    tree = ast.parse(source)
-    source = source.splitlines()
-    nodes_found = []
-    for node in ast.walk(tree):
-        if node_finder(node, source):
-            nodes_found.append(source[node.lineno - 1].strip())
-
-    return nodes_found

tripy/tripy/utils/utils.py

@@ -254,21 +254,6 @@ def custom_setattr(self, name, value):
 ##
 
 
-def find_file_in_dir(file_name: str, search_directory: str) -> List:
-    """
-    Search for file_name recursively in the root_directory.
-
-    Args:
-        file_name: The file name or pattern with wildcards.
-        search_directory: The root directory from where to search for file_name.
-    Returns:
-        List of absolute path for matching files.
-    """
-    search_pattern = os.path.join(search_directory, "**", file_name)
-    matching_files = glob.glob(search_pattern, recursive=True)
-    return matching_files
-
-
 def warn_if_wrong_mode(file_like: typing.IO, mode: str):
     def binary(mode):
         return "b" in mode
@@ -456,31 +441,3 @@ def merge_function_arguments(func, *args, **kwargs):
     all_args = get_positional_arg_names(func, *args)
     all_args.extend(kwargs.items())
     return all_args
-
-
-def get_arg_by_name(name, func, *args, **kwargs):
-    if name in kwargs:
-        return kwargs[name]
-
-    args = dict(get_positional_arg_names(func, *args))
-    if name in args:
-        return args[name]
-
-    assert False, f"No such argument: {name}"
-
-
-def modify_arg(name, modify_func, func, *args, **kwargs):
-    """
-    Modifies an argument corresponding to the provided name if it is present.
-    `modify_func` should be a function that accepts the argument and returns the modified argument.
-    """
-    if name in kwargs:
-        kwargs[name] = modify_func(kwargs[name])
-
-    all_args = get_positional_arg_names(func, *args)
-    args = list(args)
-    for index, (arg_name, _) in enumerate(all_args):
-        if name == arg_name:
-            args[index] = modify_func(args[index])
-
-    return args, kwargs