.gitlab-ci.yml

@@ -130,7 +130,7 @@ run-doc-test:
     - pip install black velin
     - velin . --check --black
     - pip install ruff
-    - ruff b_asic --output-format=gitlab > ruff.json
+    - ruff check b_asic --output-format=gitlab > ruff.json
   artifacts:
     name: "${CI_PROJECT_NAME}_code_quality"
     when: always

.pre-commit-config.yaml

@@ -14,12 +14,12 @@ repos:
       - id: check-toml
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.20.9
+    rev: v1.22.9
     hooks:
       - id: typos
 
   - repo: https://github.com/psf/black
-    rev: 24.4.0
+    rev: 24.4.2
     hooks:
       - id: black
 
@@ -36,17 +36,17 @@ repos:
 
   - repo: https://github.com/charliermarsh/ruff-pre-commit
     # Ruff version.
-    rev: "v0.4.0"
+    rev: "v0.5.0"
     hooks:
       - id: ruff
 
   - repo: https://github.com/adamchainz/blacken-docs
-    rev: 1.16.0
+    rev: 1.18.0
     hooks:
       - id: blacken-docs
 
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.15.2
+    rev: v3.16.0
     hooks:
       - id: pyupgrade
         args: [--py38-plus]

b_asic/GUI/__init__.py

@@ -2,6 +2,7 @@
 
 Graphical user interface for B-ASIC.
 """
+
 from b_asic.GUI.main_window import start_editor
 
 __all__ = ['start_editor']

b_asic/GUI/port_button.py

 """
 B-ASIC port button module.
 """
+
 from typing import TYPE_CHECKING
 
 from qtpy.QtCore import QMimeData, Qt, Signal

b_asic/GUI/precedence_graph_window.py

 """
 B-ASIC window to show precedence graph.
 """
+
 from qtpy.QtCore import Qt, Signal
 from qtpy.QtWidgets import (
     QCheckBox,

b_asic/GUI/properties_window.py

@@ -162,10 +162,12 @@ class PropertiesWindow(QDialog):
 
         self.operation.operation.set_latency_offsets(
             {
-                port: float(latency_edit.text().replace(",", "."))
-                if latency_edit.text()
-                and float(latency_edit.text().replace(",", ".")) > 0
-                else None
+                port: (
+                    float(latency_edit.text().replace(",", "."))
+                    if latency_edit.text()
+                    and float(latency_edit.text().replace(",", ".")) > 0
+                    else None
+                )
                 for port, latency_edit in self._latency_fields.items()
             }
         )

b_asic/GUI/select_sfg_window.py

 """
 B-ASIC select SFG window.
 """
+
 from typing import TYPE_CHECKING
 
 from qtpy.QtCore import Qt, Signal

b_asic/GUI/simulate_sfg_window.py

 """
 B-ASIC window to simulate an SFG.
 """
+
 from typing import TYPE_CHECKING, Dict
 
 from qtpy.QtCore import Qt, Signal

b_asic/__init__.py

 """B-ASIC - Better ASIC Toolbox.
 ASIC toolbox that simplifies circuit design and optimization.
 """
+
 # Python modules.
 from b_asic.core_operations import *
 from b_asic.graph_component import *

b_asic/architecture.py

@@ -53,6 +53,8 @@ class HardwareBlock:
     entity_name : str, optional
         The name of the resulting entity.
     """
+    __slots__ = "_entity_name"
+    _entity_name: Optional[str]
 
     def __init__(self, entity_name: Optional[str] = None):
         self._entity_name: Optional[str] = None
@@ -379,6 +381,9 @@ class ProcessingElement(Resource):
     """
 
     _color = f"#{''.join(f'{v:0>2X}' for v in PE_COLOR)}"
+    __slots__ = ("_process_collection", "_entity_name")
+    _process_collection: ProcessCollection
+    _entity_name : Optional[str]
 
     def __init__(
         self,
@@ -462,6 +467,22 @@ class Memory(Resource):
     """
 
     _color = f"#{''.join(f'{v:0>2X}' for v in MEMORY_COLOR)}"
+    _slots__ = (
+        "_process_collection",
+        "_memory_type",
+        "_entity_name",
+        "_read_ports",
+        "_write_ports",
+        "_total_ports",
+        "_assign",
+    )
+    _process_collection: ProcessCollection
+    _memory_type: Literal["RAM", "register"]
+    _entity_name: Optional[str]
+    _read_ports: Optional[int]
+    _write_ports: Optional[int]
+    _total_ports: Optional[int]
+    _assign: bool
 
     def __init__(
         self,

b_asic/codegen/vhdl/entity.py

 """
 Module for code generation of VHDL entity declarations
 """
+
 from typing import Set, TextIO
 
 from b_asic.codegen.vhdl import VHDL_TAB, write_lines

b_asic/core_operations.py

@@ -32,6 +32,10 @@ class Constant(AbstractOperation):
         Operation name.
     """
 
+    __slots__ = ("_value", "_name")
+    _value: Num
+    _name: Name
+
     _execution_time = 0
     is_linear = True
     is_constant = True
@@ -73,6 +77,7 @@ class Constant(AbstractOperation):
     def __str__(self) -> str:
         return f"{self.value}"
 
+
 class Addition(AbstractOperation):
     """
     Binary addition operation.
@@ -105,6 +110,21 @@ class Addition(AbstractOperation):
     AddSub
     """
 
+    __slots__ = (
+        "_src0",
+        "_src1",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_linear = True
     is_swappable = True
 
@@ -172,6 +192,21 @@ class Subtraction(AbstractOperation):
 
     is_linear = True
 
+    __slots__ = (
+        "_src0",
+        "_src1",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     def __init__(
         self,
         src0: Optional[SignalSourceProvider] = None,
@@ -240,6 +275,24 @@ class AddSub(AbstractOperation):
     ========
     Addition, Subtraction
     """
+
+    __slots__ = (
+        "_is_add",
+        "_src0",
+        "_src1",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _is_add: bool
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_linear = True
 
     def __init__(
@@ -317,6 +370,22 @@ class Multiplication(AbstractOperation):
     ========
     ConstantMultiplication
     """
+
+    __slots__ = (
+        "_src0",
+        "_src1",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_swappable = True
 
     def __init__(
@@ -385,6 +454,21 @@ class Division(AbstractOperation):
     Reciprocal
     """
 
+    __slots__ = (
+        "_src0",
+        "_src1",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     def __init__(
         self,
         src0: Optional[SignalSourceProvider] = None,
@@ -450,6 +534,22 @@ class Min(AbstractOperation):
     ========
     Max
     """
+
+    __slots__ = (
+        "_src0",
+        "_src1",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_swappable = True
 
     def __init__(
@@ -515,6 +615,22 @@ class Max(AbstractOperation):
     ========
     Min
     """
+
+    __slots__ = (
+        "_src0",
+        "_src1",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_swappable = True
 
     def __init__(
@@ -571,6 +687,13 @@ class SquareRoot(AbstractOperation):
         Operation execution time (time units before operator can be reused).
     """
 
+    __slots__ = ("_src0", "_name", "_latency", "_latency_offsets", "_execution_time")
+    _src0: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     def __init__(
         self,
         src0: Optional[SignalSourceProvider] = None,
@@ -622,6 +745,13 @@ class ComplexConjugate(AbstractOperation):
         Operation execution time (time units before operator can be reused).
     """
 
+    __slots__ = ("_src0", "_name", "_latency", "_latency_offsets", "_execution_time")
+    _src0: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     def __init__(
         self,
         src0: Optional[SignalSourceProvider] = None,
@@ -673,6 +803,13 @@ class Absolute(AbstractOperation):
         Operation execution time (time units before operator can be reused).
     """
 
+    __slots__ = ("_src0", "_name", "_latency", "_latency_offsets", "_execution_time")
+    _src0: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     def __init__(
         self,
         src0: Optional[SignalSourceProvider] = None,
@@ -729,6 +866,22 @@ class ConstantMultiplication(AbstractOperation):
     --------
     Multiplication
     """
+
+    __slots__ = (
+        "_value",
+        "_src0",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _value: Num
+    _src0: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_linear = True
 
     def __init__(
@@ -802,6 +955,22 @@ class Butterfly(AbstractOperation):
     execution_time : int, optional
         Operation execution time (time units before operator can be reused).
     """
+
+    __slots__ = (
+        "_src0",
+        "_src1",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_linear = True
 
     def __init__(
@@ -865,6 +1034,24 @@ class MAD(AbstractOperation):
     Multiplication
     Addition
     """
+
+    __slots__ = (
+        "_src0",
+        "_src1",
+        "_src2",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _src2: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_swappable = True
 
     def __init__(
@@ -922,6 +1109,22 @@ class SymmetricTwoportAdaptor(AbstractOperation):
         y_1 & = & x_0 + \text{value}\times\left(x_1 - x_0\right)
         \end{eqnarray}
     """
+
+    __slots__ = (
+        "_src0",
+        "_src1",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _src0: Optional[SignalSourceProvider]
+    _src1: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_linear = True
     is_swappable = True
 
@@ -1007,6 +1210,13 @@ class Reciprocal(AbstractOperation):
     Division
     """
 
+    __slots__ = ("_src0", "_name", "_latency", "_latency_offsets", "_execution_time")
+    _src0: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     def __init__(
         self,
         src0: Optional[SignalSourceProvider] = None,
@@ -1066,6 +1276,21 @@ class RightShift(AbstractOperation):
     Shift
     """
 
+    __slots__ = (
+        "_value",
+        "_src0",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _value: Num
+    _src0: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_linear = True
 
     def __init__(
@@ -1143,6 +1368,21 @@ class LeftShift(AbstractOperation):
     Shift
     """
 
+    __slots__ = (
+        "_value",
+        "_src0",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _value: Num
+    _src0: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_linear = True
 
     def __init__(
@@ -1221,6 +1461,21 @@ class Shift(AbstractOperation):
     RightShift
     """
 
+    __slots__ = (
+        "_value",
+        "_src0",
+        "_name",
+        "_latency",
+        "_latency_offsets",
+        "_execution_time",
+    )
+    _value: Num
+    _src0: Optional[SignalSourceProvider]
+    _name: Name
+    _latency: Optional[int]
+    _latency_offsets: Optional[Dict[str, int]]
+    _execution_time: Optional[int]
+
     is_linear = True
 
     def __init__(
@@ -1263,6 +1518,7 @@ class Shift(AbstractOperation):
             raise TypeError("value must be an int")
         self.set_param("value", value)
 
+
 class Sink(AbstractOperation):
     r"""
     Sink operation.
@@ -1276,7 +1532,9 @@ class Sink(AbstractOperation):
         Operation name.
     """
 
-    _execution_time = 0
+    __slots__ = "_name"
+    _name: Name
+
     is_linear = True
 
     def __init__(self, name: Name = ""):

b_asic/gui_utils/color_button.py

 """
 Qt button for use in preference dialogs, selecting color.
 """
+
 from qtpy.QtCore import Qt, Signal
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QColorDialog, QPushButton

b_asic/save_load_structure.py

@@ -63,9 +63,11 @@ def sfg_to_python(
                 if attr != "latency" and hasattr(comp, attr)
             }
             params = {
-                attr: getattr(comp, attr)
-                if not isinstance(getattr(comp, attr), str)
-                else f'"{getattr(comp, attr)}"'
+                attr: (
+                    getattr(comp, attr)
+                    if not isinstance(getattr(comp, attr), str)
+                    else f'"{getattr(comp, attr)}"'
+                )
                 for attr in params_filtered
             }
             params = {k: v for k, v in params.items() if v}
@@ -153,9 +155,11 @@ def python_to_sfg(path: str) -> Tuple[SFG, Dict[str, Tuple[int, int]]]:
         exec(code, globals(), locals())
 
     return (
-        locals()["prop"]["name"]
-        if "prop" in locals()
-        else [v for k, v in locals().items() if isinstance(v, SFG)][0],
+        (
+            locals()["prop"]["name"]
+            if "prop" in locals()
+            else [v for k, v in locals().items() if isinstance(v, SFG)][0]
+        ),
         locals()["positions"] if "positions" in locals() else {},
     )
 

b_asic/schedule.py

@@ -526,6 +526,34 @@ class Schedule:
         """
         self._sfg.set_execution_time_of_type(type_name, execution_time)
 
+    def set_latency_of_type(self, type_name: TypeName, latency: int) -> None:
+        """
+        Set the latency of all operations with the given type name.
+
+        Parameters
+        ----------
+        type_name : TypeName
+            The type name of the operation. For example, obtained as
+            ``Addition.type_name()``.
+        latency : int
+            The latency of the operation.
+        """
+        passed = True
+        for op in self._sfg.operations:
+            if type_name == op.type_name() or type_name == op.graph_id:
+                change_in_latency = latency - op.latency
+                if change_in_latency > (self.forward_slack(op.graph_id)):
+                    passed = False
+                    raise ValueError(
+                        f"Error: Can't increase latency for all components. Try increassing forward slack time by rescheduling. "
+                        f"Error in: {op.graph_id}"
+                    )
+                    break
+        if change_in_latency < 0 or passed:
+            for op in self._sfg.operations:
+                if type_name == op.type_name() or type_name == op.graph_id:
+                    cast(Operation, op).set_latency(latency)
+
     def move_y_location(
         self, graph_id: GraphID, new_y: int, insert: bool = False
     ) -> None:
@@ -1052,6 +1080,21 @@ class Schedule:
             y = np.array(_y)
             xy = np.stack((x + op_start_time, y + y_pos))
             ax.add_patch(Polygon(xy.T, fc=_LATENCY_COLOR))
+
+            if 'in' in str(graph_id):
+                ax.annotate(
+                    graph_id,
+                    xy=(op_start_time - 0.48, y_pos + 0.7),
+                    color="black",
+                    size=10 - (0.05 * len(self._start_times)),
+                )
+            else:
+                ax.annotate(
+                    graph_id,
+                    xy=(op_start_time + 0.03, y_pos + 0.7),
+                    color="black",
+                    size=10 - (0.05 * len(self._start_times)),
+                )
             if execution_time_coordinates:
                 _x, _y = zip(*execution_time_coordinates)
                 x = np.array(_x)
@@ -1164,7 +1207,8 @@ class Schedule:
         -------
         The Matplotlib Figure.
         """
-        fig, ax = plt.subplots()
+        height = len(self._start_times) * 0.3 + 2
+        fig, ax = plt.subplots(figsize=(12, height))
         self._plot_schedule(ax, operation_gap=operation_gap)
         return fig
 
@@ -1173,7 +1217,8 @@ class Schedule:
         Generate an SVG of the schedule. This is automatically displayed in e.g.
         Jupyter Qt console.
         """
-        fig, ax = plt.subplots()
+        height = len(self._start_times) * 0.3 + 2
+        fig, ax = plt.subplots(figsize=(12, height))
         self._plot_schedule(ax)
         buffer = io.StringIO()
         fig.savefig(buffer, format="svg")

b_asic/scheduler_gui/__init__.py

@@ -3,6 +3,7 @@ B-ASIC Scheduler-gui Module.
 
 Graphical user interface for B-ASIC scheduler.
 """
+
 from b_asic.scheduler_gui.main_window import start_scheduler
 
 __all__ = ['start_scheduler']

b_asic/scheduler_gui/scheduler_event.py

@@ -69,12 +69,10 @@ class SchedulerEvent:  # PyQt5
     # Filters #
     ###########
     @overload
-    def installSceneEventFilters(self, filterItems: QGraphicsItem) -> None:
-        ...
+    def installSceneEventFilters(self, filterItems: QGraphicsItem) -> None: ...
 
     @overload
-    def installSceneEventFilters(self, filterItems: List[QGraphicsItem]) -> None:
-        ...
+    def installSceneEventFilters(self, filterItems: List[QGraphicsItem]) -> None: ...
 
     def installSceneEventFilters(self, filterItems) -> None:
         """
@@ -88,12 +86,10 @@ class SchedulerEvent:  # PyQt5
             item.installSceneEventFilter(self)
 
     @overload
-    def removeSceneEventFilters(self, filterItems: QGraphicsItem) -> None:
-        ...
+    def removeSceneEventFilters(self, filterItems: QGraphicsItem) -> None: ...
 
     @overload
-    def removeSceneEventFilters(self, filterItems: List[QGraphicsItem]) -> None:
-        ...
+    def removeSceneEventFilters(self, filterItems: List[QGraphicsItem]) -> None: ...
 
     def removeSceneEventFilters(self, filterItems) -> None:
         """

b_asic/scheduler_gui/signal_item.py

@@ -5,7 +5,6 @@ Contains the scheduler_gui SignalItem class for drawing and maintaining a signal
 in the schedule.
 """
 
-
 from typing import TYPE_CHECKING, cast
 
 from qtpy.QtCore import QPointF

b_asic/sfg_generators.py

@@ -3,6 +3,7 @@ B-ASIC signal flow graph generators.
 
 This module contains a number of functions generating SFGs for specific functions.
 """
+
 from typing import Dict, Optional, Sequence, Union
 
 import numpy as np

b_asic/signal.py

@@ -3,6 +3,7 @@ B-ASIC Signal Module.
 
 Contains the class for representing the connections between operations.
 """
+
 from typing import TYPE_CHECKING, Iterable, Optional, Union
 
 from b_asic.graph_component import AbstractGraphComponent, GraphComponent