switch the order fo comparisons to use sequence instead of list / tuple

Author: keenan-simpson

cuda_core/cuda/core/experimental/_program.py

@@ -13,8 +13,8 @@
     _handle_boolean_option,
     check_or_create_options,
     handle_return,
-    is_list_or_tuple,
-    is_nested_list_or_tuple,
+    is_nested_sequence,
+    is_sequence,
 )
 
 
@@ -247,11 +247,11 @@ def __post_init__(self):
             self._formatted_options.append(f"--dopt={'on' if self.device_code_optimize else 'off'}")
         if self.ptxas_options is not None:
             self._formatted_options.append("--ptxas-options")
-            if is_list_or_tuple(self.ptxas_options):
+            if isinstance(self.ptxas_options, str):
+                self._formatted_options.append(self.ptxas_options)
+            elif is_sequence(self.ptxas_options):
                 for option in self.ptxas_options:
                     self._formatted_options.append(option)
-            else:
-                self._formatted_options.append(self.ptxas_options)
         if self.max_register_count is not None:
             self._formatted_options.append(f"--maxrregcount={self.max_register_count}")
         if self.ftz is not None:
@@ -271,7 +271,9 @@ def __post_init__(self):
         if self.gen_opt_lto is not None and self.gen_opt_lto:
             self._formatted_options.append("--gen-opt-lto")
         if self.define_macro is not None:
-            if is_nested_list_or_tuple(self.define_macro):
+            if isinstance(self.define_macro, str):
+                self._formatted_options.append(f"--define-macro={self.define_macro}")
+            if is_nested_sequence(self.define_macro):
                 for macro in self.define_macro:
                     if isinstance(macro, tuple):
                         assert len(macro) == 2
@@ -281,27 +283,26 @@ def __post_init__(self):
             elif isinstance(self.define_macro, tuple):
                 assert len(self.define_macro) == 2
                 self._formatted_options.append("--define-macro=MY_MACRO=999")
-            else:
-                self._formatted_options.append(f"--define-macro={self.define_macro}")
 
         if self.undefine_macro is not None:
-            if is_list_or_tuple(self.undefine_macro):
+            if isinstance(self.undefine_macro, str):
+                self._formatted_options.append(f"--undefine-macro={self.undefine_macro}")
+            elif is_sequence(self.undefine_macro):
                 for macro in self.undefine_macro:
                     self._formatted_options.append(f"--undefine-macro={macro}")
-            else:
-                self._formatted_options.append(f"--undefine-macro={self.undefine_macro}")
         if self.include_path is not None:
-            if is_list_or_tuple(self.include_path):
+            if isinstance(self.include_path, str):
+                self._formatted_options.append(f"--include-path={self.include_path}")
+            elif is_sequence(self.include_path):
                 for path in self.include_path:
                     self._formatted_options.append(f"--include-path={path}")
-            else:
-                self._formatted_options.append(f"--include-path={self.include_path}")
         if self.pre_include is not None:
-            if is_list_or_tuple(self.pre_include):
+            if isinstance(self.pre_include, str):
+                self._formatted_options.append(f"--pre-include={self.pre_include}")
+            elif is_sequence(self.pre_include):
                 for header in self.pre_include:
                     self._formatted_options.append(f"--pre-include={header}")
-            else:
-                self._formatted_options.append(f"--pre-include={self.pre_include}")
+
         if self.no_source_include is not None and self.no_source_include:
             self._formatted_options.append("--no-source-include")
         if self.std is not None:
@@ -327,23 +328,23 @@ def __post_init__(self):
         if self.no_display_error_number is not None and self.no_display_error_number:
             self._formatted_options.append("--no-display-error-number")
         if self.diag_error is not None:
-            if is_list_or_tuple(self.diag_error):
+            if isinstance(self.diag_error, int):
+                self._formatted_options.append(f"--diag-error={self.diag_error}")
+            elif is_sequence(self.diag_error):
                 for error in self.diag_error:
                     self._formatted_options.append(f"--diag-error={error}")
-            else:
-                self._formatted_options.append(f"--diag-error={self.diag_error}")
         if self.diag_suppress is not None:
-            if is_list_or_tuple(self.diag_suppress):
+            if isinstance(self.diag_suppress, int):
+                self._formatted_options.append(f"--diag-suppress={self.diag_suppress}")
+            elif is_sequence(self.diag_suppress):
                 for suppress in self.diag_suppress:
                     self._formatted_options.append(f"--diag-suppress={suppress}")
-            else:
-                self._formatted_options.append(f"--diag-suppress={self.diag_suppress}")
         if self.diag_warn is not None:
-            if is_list_or_tuple(self.diag_warn):
+            if isinstance(self.diag_warn, int):
+                self._formatted_options.append(f"--diag-warn={self.diag_warn}")
+            elif is_sequence(self.diag_warn):
                 for warn in self.diag_warn:
                     self._formatted_options.append(f"--diag-warn={warn}")
-            else:
-                self._formatted_options.append(f"--diag-warn={self.diag_warn}")
         if self.brief_diagnostics is not None:
             self._formatted_options.append(f"--brief-diagnostics={_handle_boolean_option(self.brief_diagnostics)}")
         if self.time is not None:

cuda_core/cuda/core/experimental/_utils.py

@@ -4,6 +4,7 @@
 
 import functools
 from collections import namedtuple
+from collections.abc import Sequence
 from typing import Callable, Dict
 
 from cuda import cuda, cudart, nvrtc
@@ -143,15 +144,15 @@ def get_device_from_ctx(ctx_handle) -> int:
     return device_id
 
 
-def is_list_or_tuple(obj):
+def is_sequence(obj):
     """
     Check if the given object is a sequence (list or tuple).
     """
-    return isinstance(obj, (list, tuple))
+    return isinstance(obj, Sequence)
 
 
-def is_nested_list_or_tuple(obj):
+def is_nested_sequence(obj):
     """
     Check if the given object is a nested sequence (list or tuple with atleast one list or tuple element).
     """
-    return is_list_or_tuple(obj) and any(is_list_or_tuple(elem) for elem in obj)
+    return is_sequence(obj) and any(is_sequence(elem) for elem in obj)