Tweak writing of all attributes, allow writing only configurable attributes

Author: vloncar

docs/attr_doc_gen.py

@@ -4,10 +4,6 @@
 import hls4ml.model.attributes as attributes
 import hls4ml.model.layers as layers
 
-all_backends = backends.get_available_backends()
-# Removing duplicates but preserving order
-all_layers = list(dict.fromkeys(layers.layer_map.values()))
-
 
 class AttrList:
     def __init__(self, cls_name, cls_attrs) -> None:
@@ -17,29 +13,61 @@ def __init__(self, cls_name, cls_attrs) -> None:
         self.weight_attrs = [attr for attr in cls_attrs if attr.__class__.__name__ == 'WeightAttribute']
         self.base_attrs = [attr for attr in cls_attrs if attr not in self.config_attrs + self.type_attrs + self.weight_attrs]
         self.backend_attrs = {}
+        self.reverse_backend_attrs = []  # Will hold (attr, backend_name) pairs, used temporarily
+        self.unique_backend_attrs = []
 
     def add_backend_attrs(self, backend_name, backend_attrs):
         self.backend_attrs[backend_name] = backend_attrs
 
+        for attr in backend_attrs:
+            self.reverse_backend_attrs.append((attr, backend_name))
+
+    def sift_backend_attrs(self):
+        grouped_dict = {}
+        for attr, backend_name in self.reverse_backend_attrs:
+            if attr not in grouped_dict:
+                grouped_dict[attr] = []
+            grouped_dict[attr].append(backend_name)
+
+        for attr, backend_names in grouped_dict.items():
+            attr.available_in = backend_names
+            self.unique_backend_attrs.append(attr)
+
+    @property
+    def only_configurable(self):
+        all_attrs = self.config_attrs + self.type_attrs + self.unique_backend_attrs
+        return [attr for attr in all_attrs if attr.configurable is True]
+
 
-attr_map = []
+def convert_to_attr_list():
+    all_backends = backends.get_available_backends()
+    # Removing duplicates but preserving order
+    all_layers = list(dict.fromkeys(layers.layer_map.values()))
+    all_layers_attrs = []
 
-for layer_cls in all_layers:
-    base_attrs = layer_cls.expected_attributes
+    for layer_cls in all_layers:
+        base_attrs = layer_cls.expected_attributes
 
-    attr_list = AttrList(layer_cls.__name__, base_attrs)
+        attr_list = AttrList(layer_cls.__name__, base_attrs)
 
-    for backend_name in all_backends:
-        backend = backends.get_backend(backend_name)
+        for backend_name in all_backends:
+            backend = backends.get_backend(backend_name)
 
-        backend_cls = backend.create_layer_class(layer_cls)
-        backend_attrs = backend_cls.expected_attributes
+            backend_cls = backend.create_layer_class(layer_cls)
+            backend_attrs = backend_cls.expected_attributes
 
-        diff_atts = [attr for attr in backend_attrs if attr not in base_attrs]  # Sets are faster, but don't preserve order
-        if len(diff_atts) > 0:
-            attr_list.add_backend_attrs(backend.name, diff_atts)
+            diff_atts = [
+                attr for attr in backend_attrs if attr not in base_attrs
+            ]  # Sets are faster, but don't preserve order
+            if len(diff_atts) > 0:
+                attr_list.add_backend_attrs(backend.name, diff_atts)
 
-    attr_map.append(attr_list)
+        all_layers_attrs.append(attr_list)
+
+    for attr_list in all_layers_attrs:
+        attr_list.sift_backend_attrs()
+
+    return all_layers_attrs
 
 
 def print_attrs(attrs, file):
@@ -60,40 +88,62 @@ def print_attrs(attrs, file):
         if attr.description is not None:
             file.write('  * ' + attr.description + '\n\n')
 
+        if hasattr(attr, 'available_in'):
+            file.write('  * Available in: ' + ', '.join(attr.available_in) + '\n\n')
+
+
+def write_all_attributes(all_layers_attrs):
+    with open('attributes.rst', mode='w') as file:
+        file.write('================\n')
+        file.write('Layer attributes\n')
+        file.write('================\n\n\n')
+
+        for attr_list in all_layers_attrs:
+            file.write(attr_list.cls_name + '\n')
+            file.write('=' * len(attr_list.cls_name) + '\n')
+
+            if len(attr_list.base_attrs) > 0:
+                file.write('Base attributes\n')
+                file.write('---------------\n')
+                print_attrs(attr_list.type_attrs, file)
+
+            if len(attr_list.type_attrs) > 0:
+                file.write('Type attributes\n')
+                file.write('---------------\n')
+                print_attrs(attr_list.base_attrs, file)
+
+            if len(attr_list.weight_attrs) > 0:
+                file.write('Weight attributes\n')
+                file.write('-----------------\n')
+                print_attrs(attr_list.weight_attrs, file)
+
+            if len(attr_list.config_attrs) > 0:
+                file.write('Configurable attributes\n')
+                file.write('-----------------------\n')
+                print_attrs(attr_list.config_attrs, file)
+
+            if len(attr_list.backend_attrs) > 0:
+                file.write('Backend-specific attributes\n')
+                file.write('---------------------------\n')
+                print_attrs(attr_list.unique_backend_attrs, file)
+
+
+def write_only_configurable(all_layers_attrs):
+    with open('attributes.rst', mode='w') as file:
+        file.write('================\n')
+        file.write('Layer attributes\n')
+        file.write('================\n\n\n')
+
+        for attr_list in all_layers_attrs:
+            file.write(attr_list.cls_name + '\n')
+            file.write('=' * len(attr_list.cls_name) + '\n')
+
+            config_attrs = attr_list.only_configurable
+            if len(config_attrs) > 0:
+                print_attrs(config_attrs, file)
+
 
-with open('attributes.rst', mode='w') as file:
-    file.write('================\n')
-    file.write('Layer attributes\n')
-    file.write('================\n\n\n')
-
-    for attr_list in attr_map:
-        file.write(attr_list.cls_name + '\n')
-        file.write('=' * len(attr_list.cls_name) + '\n')
-
-        if len(attr_list.base_attrs) > 0:
-            file.write('Base attributes\n')
-            file.write('---------------\n')
-            print_attrs(attr_list.type_attrs, file)
-
-        if len(attr_list.type_attrs) > 0:
-            file.write('Type attributes\n')
-            file.write('---------------\n')
-            print_attrs(attr_list.base_attrs, file)
-
-        if len(attr_list.weight_attrs) > 0:
-            file.write('Weight attributes\n')
-            file.write('-----------------\n')
-            print_attrs(attr_list.weight_attrs, file)
-
-        if len(attr_list.config_attrs) > 0:
-            file.write('Configurable attributes\n')
-            file.write('-----------------------\n')
-            print_attrs(attr_list.config_attrs, file)
-
-        if len(attr_list.backend_attrs) > 0:
-            file.write('Backend attributes\n')
-            file.write('-----------------------\n')
-            for backend, backend_attrs in attr_list.backend_attrs.items():
-                file.write(backend + '\n')
-                file.write('^' * len(backend) + '\n')
-                print_attrs(backend_attrs, file)
+if __name__ == '__main__':
+    all_layers_attrs = convert_to_attr_list()
+    write_all_attributes(all_layers_attrs)
+    # write_only_configurable(all_layers_attrs)

hls4ml/model/attributes.py

@@ -60,6 +60,20 @@ def config_name(self):
         """
         return convert_to_pascal_case(self.name)
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Attribute):
+            return NotImplemented
+        return (
+            self.name == other.name
+            and self.value_type == other.value_type
+            and self.default == other.default
+            and self.configurable == other.configurable
+            and self.description == other.description
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.value_type, self.default, self.configurable, self.description))
+
 
 class ConfigurableAttribute(Attribute):
     """
@@ -69,7 +83,7 @@ class ConfigurableAttribute(Attribute):
     when defining the expected attributes of layer classes.
     """
 
-    def __init__(self, name, value_type=int, default=None, description=None):
+    def __init__(self, name, value_type=Integral, default=None, description=None):
         super().__init__(name, value_type, default, configurable=True, description=description)
 
 
@@ -101,6 +115,13 @@ def __init__(self, name, choices, default=None, configurable=True, description=N
     def validate_value(self, value):
         return value in self.choices
 
+    def __eq__(self, other: object) -> bool:
+        base_eq = super().__eq__(other)
+        return base_eq and hasattr(other, 'choices') and set(self.choices) == set(other.choices)
+
+    def __hash__(self) -> int:
+        return super().__hash__() ^ hash(tuple(sorted(self.choices)))
+
 
 class WeightAttribute(Attribute):
     """
@@ -117,9 +138,7 @@ class CodeAttrubute(Attribute):
     """
 
     def __init__(self, name, description=None):
-        super(WeightAttribute, self).__init__(
-            name, value_type=Source, default=None, configurable=False, description=description
-        )
+        super().__init__(name, value_type=Source, default=None, configurable=False, description=description)
 
 
 # endregion

hls4ml/model/types.py

@@ -64,12 +64,15 @@ def __init__(self, width, signed):
         self.width = width
         self.signed = signed
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         eq = self.width == other.width
         eq = eq and self.signed == other.signed
 
         return eq
 
+    def __hash__(self) -> int:
+        return hash((self.width, self.signed))
+
 
 class IntegerPrecisionType(PrecisionType):
     """Arbitrary precision integer  data type.
@@ -89,12 +92,15 @@ def __str__(self):
         return typestring
 
     # Does this need to make sure other is also an IntegerPrecisionType? I could see a match between Fixed and Integer
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, IntegerPrecisionType):
             return super().__eq__(other)
 
         return False
 
+    def __hash__(self) -> int:
+        return super().__hash__()
+
     @property
     def integer(self):
         return self.width
@@ -186,7 +192,7 @@ def __str__(self):
         typestring = '{signed}fixed<{args}>'.format(signed='u' if not self.signed else '', args=args)
         return typestring
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, FixedPrecisionType):
             eq = super().__eq__(other)
             eq = eq and self.integer == other.integer
@@ -197,6 +203,9 @@ def __eq__(self, other):
 
         return False
 
+    def __hash__(self) -> int:
+        return super().__hash__() ^ hash((self.integer, self.rounding_mode, self.saturation_mode, self.saturation_bits))
+
 
 class XnorPrecisionType(PrecisionType):
     """