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 E402, 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 = '    '