format with ruff

Author: calad0i

docs/conf.py

@@ -99,7 +99,7 @@ def get_pypi_version(package, url_pattern=URL_PATTERN):
 
 # -- Extension configuration -------------------------------------------------
 html_show_sourcelink = False
-html_logo = "img/hls4ml_logo_navbar.png"
+html_logo = 'img/hls4ml_logo_navbar.png'
 
 html_theme_options = {
     'canonical_url': '',
@@ -120,7 +120,7 @@ def get_pypi_version(package, url_pattern=URL_PATTERN):
 html_context = {
     'display_github': True,  # Integrate GitHub
     'github_user': 'fastmachinelearning',  # Username
-    'github_repo': "hls4ml",  # Repo name
+    'github_repo': 'hls4ml',  # Repo name
     'github_version': 'main',  # Version
     'conf_py_path': '/docs/',  # Path in the checkout to the docs root
 }

hls4ml/__init__.py

@@ -1,11 +1,11 @@
-from hls4ml import converters, report, utils  # noqa: F401, E402
+from hls4ml import converters, report, utils
 
 try:
     from ._version import version as __version__
     from ._version import version_tuple
 except ImportError:
-    __version__ = "unknown version"
-    version_tuple = (0, 0, "unknown version")
+    __version__ = 'unknown version'
+    version_tuple = (0, 0, 'unknown version')
 
 
 def reseed(newseed):

hls4ml/backends/__init__.py

@@ -1,11 +1,11 @@
-from hls4ml.backends.backend import Backend, get_available_backends, get_backend, register_backend  # noqa: F401
-from hls4ml.backends.fpga.fpga_backend import FPGABackend  # noqa: F401
+from hls4ml.backends.backend import Backend, get_available_backends, get_backend, register_backend
+from hls4ml.backends.fpga.fpga_backend import FPGABackend
 from hls4ml.backends.oneapi.oneapi_backend import OneAPIBackend
 from hls4ml.backends.quartus.quartus_backend import QuartusBackend
 from hls4ml.backends.symbolic.symbolic_backend import SymbolicExpressionBackend
 from hls4ml.backends.vivado.vivado_backend import VivadoBackend
 from hls4ml.backends.vivado_accelerator.vivado_accelerator_backend import VivadoAcceleratorBackend
-from hls4ml.backends.vivado_accelerator.vivado_accelerator_config import VivadoAcceleratorConfig  # noqa: F401
+from hls4ml.backends.vivado_accelerator.vivado_accelerator_config import VivadoAcceleratorConfig
 
 from hls4ml.backends.catapult.catapult_backend import CatapultBackend  # isort: skip
 

hls4ml/backends/catapult/catapult_backend.py

@@ -251,7 +251,7 @@ def build(
         ccs_args = f'"reset={reset} csim={csim} synth={synth} cosim={cosim} validation={validation}'
         ccs_args += f' export={export} vsynth={vsynth} fifo_opt={fifo_opt} bitfile={bitfile} ran_frame={ran_frame}'
         ccs_args += f' sw_opt={sw_opt} power={power} da={da} vhdl={vhdl} verilog={verilog} bup={bup}"'
-        ccs_invoke = catapult_exe + ' -product ultra -shell -f build_prj.tcl -eval \'set ::argv ' + ccs_args + '\''
+        ccs_invoke = catapult_exe + " -product ultra -shell -f build_prj.tcl -eval 'set ::argv " + ccs_args + "'"
         print(ccs_invoke)
         os.system(ccs_invoke)
         os.chdir(curr_dir)
@@ -455,9 +455,9 @@ def init_global_pooling2d(self, layer):
     @layer_optimizer(Softmax)
     def init_softmax(self, layer):
         if layer.model.config.get_config_value('IOType') == 'io_parallel':
-            assert (
-                len(layer.get_input_variable().shape) == 1
-            ), 'Softmax with io_parallel strategy cannot be used on multidimensional tensors.'
+            assert len(layer.get_input_variable().shape) == 1, (
+                'Softmax with io_parallel strategy cannot be used on multidimensional tensors.'
+            )
 
     @layer_optimizer(Embedding)
     def init_embed(self, layer):

hls4ml/backends/catapult/passes/broadcast_stream.py

@@ -6,7 +6,7 @@
 
 
 class Broadcast(Layer):
-    '''Inserted between layers for broadcasting.'''
+    """Inserted between layers for broadcasting."""
 
     def initialize(self):
         shape = self.attributes['target_shape']

hls4ml/backends/catapult/passes/conv_stream.py

@@ -3,7 +3,7 @@
 
 
 class GenerateConvStreamingInstructions(OptimizerPass):
-    '''Generates the instructions for streaming implementation of CNNs'''
+    """Generates the instructions for streaming implementation of CNNs"""
 
     def match(self, node):
         is_match = (

hls4ml/backends/catapult/passes/convolution_winograd.py

@@ -7,10 +7,10 @@
 
 
 class ApplyWinogradKernelTransformation(OptimizerPass):
-    '''
+    """
     Transforms the weights of a Conv2D kernel to a format suitable for Wingorad convolution
     For further information, refer to Lavin & Gray, 2015 - Fast Algorithms for Convolutional Neural Networks
-    '''
+    """
 
     def match(self, node):
         node_matches = isinstance(node, (Conv1D, Conv2D))

hls4ml/backends/catapult/passes/fifo_depth_optimization.py

@@ -82,9 +82,9 @@ def transform(self, model):
 
         if len(data['children']) == 0:
             print(
-                "FIFO depth optimization found no FIFOs implemented using BRAMs in the design, no optimization is possible."
+                'FIFO depth optimization found no FIFOs implemented using BRAMs in the design, no optimization is possible.'
             )
-            print("Consider increasing profiling_fifo_depth.")
+            print('Consider increasing profiling_fifo_depth.')
             return False
 
         n_elem = len(data['children'][0]['children'][0]['children'])

hls4ml/backends/catapult/passes/resource_strategy.py

@@ -5,7 +5,7 @@
 
 
 class ApplyResourceStrategy(OptimizerPass):
-    '''Transposes the weights to use the dense_resource matrix multiply routine'''
+    """Transposes the weights to use the dense_resource matrix multiply routine"""
 
     def match(self, node):
         node_matches = isinstance(node, (Dense, Conv1D, SeparableConv1D, Conv2D, SeparableConv2D, LSTM, GRU))

hls4ml/backends/fpga/fpga_backend.py

@@ -346,9 +346,9 @@ def convert_precision_string(cls, precision):
 
     @classmethod
     def _convert_ap_type(cls, precision):
-        '''
+        """
         Convert a precision string (e.g. "ap_fixed<16,6>" to the internal FixedPrecisionTypes etc)
-        '''
+        """
         bits = re.search('.+<(.+?)>', precision).group(1).split(',')
         sat_mode = None
         round_mode = None
@@ -357,12 +357,12 @@ def _convert_ap_type(cls, precision):
             width = int(bits[0])
             integer = int(bits[1])
             fields = 2
-            signed = not ('u' in precision)
+            signed = 'u' not in precision
         elif 'int' in precision:
             width = int(bits[0])
             integer = width
             fields = 1
-            signed = not ('u' in precision)
+            signed = 'u' not in precision
         if len(bits) > fields:
             round_mode = bits[fields]
         if len(bits) > fields + 1:
@@ -376,9 +376,9 @@ def _convert_ap_type(cls, precision):
 
     @classmethod
     def _convert_ac_type(cls, precision):
-        '''
+        """
         Convert a precision string (e.g. "ac_fixed<16,6>" to the internal FixedPrecisionTypes etc)
-        '''
+        """
         bits = re.search('.+<(.+?)>', precision).group(1).split(',')
         signed = True  # default is signed
         sat_mode = None
@@ -414,18 +414,18 @@ def _convert_ac_type(cls, precision):
 
     @classmethod
     def _convert_auto_type(cls, precision):
-        '''
+        """
         Convert a "auto" precision string into the UnspecifiedPrecisionType
-        '''
+        """
         return UnspecifiedPrecisionType()
 
     def product_type(self, data_T, weight_T):
-        '''
+        """
         Helper function to determine which product implementation to use during inference
-        '''
-        assert not isinstance(
-            data_T, ExponentPrecisionType
-        ), "Only ExponentPrecisionType (aka 'power of 2') weights are currently supported, not data."
+        """
+        assert not isinstance(data_T, ExponentPrecisionType), (
+            "Only ExponentPrecisionType (aka 'power of 2') weights are currently supported, not data."
+        )
         product = 'mult'
         if isinstance(weight_T, ExponentPrecisionType):
             product = 'weight_exponential'
@@ -754,14 +754,14 @@ def generate_conv1d_line_buffer_fn(self, layer_idx, n_partitions, in_W, in_C, ke
         im2col_matrix = self._compute_conv1d_im2col((in_W, in_C), kernel, stride, (pad_left, pad_right), dilation)
 
         generated_code = (
-            "template<class data_T, typename CONFIG_T>\n"
-            "class fill_buffer_{index} : public nnet::FillConv1DBuffer<data_T, CONFIG_T> {{\n"
-            "    public:\n"
-            "    static void fill_buffer(\n"
-            "        data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],\n"
-            "        data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_width * CONFIG_T::n_chan],\n"
-            "        const unsigned partition\n"
-            "    ) {{\n"
+            'template<class data_T, typename CONFIG_T>\n'
+            'class fill_buffer_{index} : public nnet::FillConv1DBuffer<data_T, CONFIG_T> {{\n'
+            '    public:\n'
+            '    static void fill_buffer(\n'
+            '        data_T data[CONFIG_T::in_width * CONFIG_T::n_chan],\n'
+            '        data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_width * CONFIG_T::n_chan],\n'
+            '        const unsigned partition\n'
+            '    ) {{\n'
         ).format(index=layer_idx)
         indent = '    '
 
@@ -884,14 +884,14 @@ def generate_conv2d_line_buffer_fn(
         )
 
         generated_code = (
-            "template<class data_T, typename CONFIG_T>\n"
-            "class fill_buffer_{index} : public nnet::FillConv2DBuffer<data_T, CONFIG_T> {{\n"
-            "    public:\n"
-            "    static void fill_buffer(\n"
-            "        data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],\n"
-            "        data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],\n"
-            "        const unsigned partition\n"
-            "    ) {{\n"
+            'template<class data_T, typename CONFIG_T>\n'
+            'class fill_buffer_{index} : public nnet::FillConv2DBuffer<data_T, CONFIG_T> {{\n'
+            '    public:\n'
+            '    static void fill_buffer(\n'
+            '        data_T data[CONFIG_T::in_height * CONFIG_T::in_width * CONFIG_T::n_chan],\n'
+            '        data_T buffer[CONFIG_T::n_pixels][CONFIG_T::filt_height * CONFIG_T::filt_width * CONFIG_T::n_chan],\n'
+            '        const unsigned partition\n'
+            '    ) {{\n'
         ).format(index=layer_idx)
         indent = '    '
 

hls4ml/backends/fpga/fpga_layers.py

@@ -6,10 +6,10 @@
 
 
 class BatchNormalizationQuantizedTanh(Layer):
-    '''Merged Batch Normalization and quantized (binary or ternary) Tanh layer.
+    """Merged Batch Normalization and quantized (binary or ternary) Tanh layer.
     The mean, variance, beta, gamma parameters are folded into the threshold(s) at which the
     sign of the input flips after the quantized (binary or ternary) Tanh activation.
-    '''
+    """
 
     _expected_attributes = [
         Attribute('n_in'),
@@ -71,15 +71,15 @@ def set_thresholds(self, scale, bias, ternary_threshold=0.5):
 
 
 class PointwiseConv1D(Conv1D):
-    '''Optimized Conv1D implementation for 1x1 kernels.'''
+    """Optimized Conv1D implementation for 1x1 kernels."""
 
     def initialize(self):
         # Do noting, values copied
         pass
 
 
 class PointwiseConv2D(Conv2D):
-    '''Optimized Conv2D implementation for 1x1 kernels.'''
+    """Optimized Conv2D implementation for 1x1 kernels."""
 
     def initialize(self):
         # Do noting, values copied

hls4ml/backends/fpga/fpga_types.py

@@ -165,7 +165,7 @@ def definition_cpp(self):
 
 class CompressedTypeConverter(TypeDefinition, TypePrecisionConverter):
     def definition_cpp(self):
-        cpp_fmt = 'typedef struct {name} {{' '{index} row_index;' '{index} col_index;' '{precision} weight; }} {name};\n'
+        cpp_fmt = 'typedef struct {name} {{{index} row_index;{index} col_index;{precision} weight; }} {name};\n'
         return cpp_fmt.format(name=self.name, index=self.index_precision, precision=self.precision.definition_cpp())
 
     def convert_precision(self, precision_converter):
@@ -175,7 +175,7 @@ def convert_precision(self, precision_converter):
 
 class ExponentTypeConverter(TypeDefinition, TypePrecisionConverter):
     def definition_cpp(self):
-        cpp_fmt = 'typedef struct {name} {{' '{sign} sign;' '{precision} weight; }} {name};\n'
+        cpp_fmt = 'typedef struct {name} {{{sign} sign;{precision} weight; }} {name};\n'
         return cpp_fmt.format(name=self.name, precision=self.precision.definition_cpp(), sign=self.sign.definition_cpp())
 
     def convert_precision(self, precision_converter):

hls4ml/backends/fpga/passes/clone.py

@@ -6,7 +6,7 @@
 
 
 class Clone(Layer):
-    '''Inserted after the layer whose output is used more than once.'''
+    """Inserted after the layer whose output is used more than once."""
 
     def initialize(self):
         inp = self.get_input_variable()
@@ -47,7 +47,7 @@ def register_clone(backend):
 
 
 class CloneOutput(OptimizerPass):
-    '''Clones streams that are used multiple times'''
+    """Clones streams that are used multiple times"""
 
     def match(self, node):
         # We may have already inserted the Clone layer
@@ -70,7 +70,6 @@ def match(self, node):
         return False
 
     def transform(self, model, node):
-
         output_map = node.get_output_use_map()
 
         transformed = False

hls4ml/backends/fpga/passes/final_reshape.py

@@ -3,7 +3,7 @@
 
 
 class RemoveFinalReshape(OptimizerPass):
-    '''Remove reshape if final layer'''
+    """Remove reshape if final layer"""
 
     def match(self, node):
         # match if reshape is final node

hls4ml/backends/fpga/passes/fix_softmax_table_size.py

@@ -33,28 +33,28 @@ def transform(self, model, node: Layer):
                 # 125 characters long line.
                 warnings.warn(
                     (
-                        f"Softmax layer {node.name} table size is too large for input"
-                        f"bitwidth {input_bw}. Setting table size to {2**input_bw}."
-                        "To avoid this warning, please increase input bitwidth or"
-                        "decrease table size."
+                        f'Softmax layer {node.name} table size is too large for input'
+                        f'bitwidth {input_bw}. Setting table size to {2**input_bw}.'
+                        'To avoid this warning, please increase input bitwidth or'
+                        'decrease table size.'
                     ),
                     stacklevel=1,
                 )
             if 2**table_bw < table_size:
                 warnings.warn(
                     (
-                        f"Softmax layer {node.name} table size is too large for input"
-                        f"bitwidth {input_bw}. Setting table size to {2**input_bw}."
-                        "To avoid this warning, please increase input bitwidth or"
-                        "decrease table size."
+                        f'Softmax layer {node.name} table size is too large for input'
+                        f'bitwidth {input_bw}. Setting table size to {2**input_bw}.'
+                        'To avoid this warning, please increase input bitwidth or'
+                        'decrease table size.'
                     ),
                     stacklevel=1,
                 )
             if backend == 'Quartus':
                 warnings.warn(
                     (
                         "Quartus backend's table size is half of 2^min(input_bw-1,table_bw-1)"
-                        " instead of 2^min(input_bw,table_bw)."
+                        ' instead of 2^min(input_bw,table_bw).'
                     ),
                     stacklevel=1,
                 )

hls4ml/backends/fpga/passes/hgq_proxy_model.py

@@ -35,15 +35,15 @@ def generate_mask_fn(
         else:
             fn = f'out[{idx}] = {to_fixed(k, b, i, RND, SAT)}(inp[{idx}]);'
         masks.append(f'    {fn}')
-    body = "\n".join(masks)
-    mask_fn = f'''
+    body = '\n'.join(masks)
+    mask_fn = f"""
 template<typename input_t, typename output_t>
 void {name}(input_t *inp, output_t *out) {{
     #pragma HLS INLINE
 
 {body}
 }}
-'''
+"""
     return mask_fn
 
 

hls4ml/backends/fpga/passes/im2col_codegen.py

@@ -4,7 +4,7 @@
 
 
 class GenerateConvIm2col(OptimizerPass):
-    '''Generates tcode for im2col step of 1D/2d convolution'''
+    """Generates tcode for im2col step of 1D/2d convolution"""
 
     # Note, DepthwizeConv1D/2D also matches because it inherits from Conv1D/2D
     def match(self, node):

hls4ml/backends/fpga/passes/inplace_parallel_reshape.py

@@ -22,10 +22,10 @@ def transform(self, model, node):
         node.set_attr(node.outputs[0], newoutvar)
         if node.name in model.outputs:
             prev_node = node.get_input_node()
-            assert (
-                prev_node.name not in model.outputs
-            ), f"Cannot output node {prev_node.name}: reshape is a no-op in io_parallel.\
+            assert prev_node.name not in model.outputs, (
+                f"Cannot output node {prev_node.name}: reshape is a no-op in io_parallel.\
             As a result, the previous node {prev_node.name}'s output will be used as the\
             output. However, this node is already an output."
+            )
             model.outputs = [name if name != node.name else prev_node.name for name in model.outputs]
         return False