digsim-logic-simulator 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

digsim/circuit/components/atoms/_component.py

@@ -1,12 +1,16 @@
-# Copyright (c) Fredrik Andersson, 2023-2024
+# Copyright (c) Fredrik Andersson, 2023-2025
 # All rights reserved
 
 """This module contains the base classes for all component types"""
 
+from __future__ import annotations
+
 import abc
 import copy
+from typing import Callable
 
 from ._digsim_exception import DigsimException
+from ._port import Port
 
 
 class ComponentException(DigsimException):
@@ -16,15 +20,14 @@ class ComponentException(DigsimException):
 class Component(abc.ABC):
     """The component base class"""
 
-    def __init__(self, circuit, name=None, display_name=None):
+    def __init__(self, circuit, name: str | None = None, display_name: str | None = None):
         self._circuit = circuit
-        self._name = name or self.__class__.__name__
-        self._parent = None
-        self._ports = []
-        self._edge_detect_dict = {}
+        self._name: str = name or self.__class__.__name__
+        self._parent: Component | None = None
+        self._ports: list[Port] = []
         self._circuit.add_component(self)
-        self._display_name = display_name or self.__class__.__name__
-        self._parameters = {}
+        self._display_name: str = display_name or self.__class__.__name__
+        self._parameters: dict[str, int | str | bool] = {}
 
     def init(self):
         """Initialize port, will be called when circuit is initialized"""
@@ -37,15 +40,15 @@ class Component(abc.ABC):
     def clear(self):
         """Remove static state within the component class"""
 
-    def parameter_set(self, parameter, value):
+    def parameter_set(self, parameter: str, value: int | str | bool):
         """Set component parameter"""
         self._parameters[parameter] = value
 
-    def parameter_get(self, parameter):
+    def parameter_get(self, parameter: str) -> int | str | bool:
         """Get component parameter"""
         return self._parameters[parameter]
 
-    def add_port(self, port):
+    def add_port(self, port: Port):
         """
         Add port to component,
         also add a 'portname' variable to the component with help of the 'self.__dict__'
@@ -59,7 +62,7 @@ class Component(abc.ABC):
         """
         self._ports = []
 
-    def path(self):
+    def path(self) -> str:
         """Get component path"""
         if self._parent is not None:
             return f"{self._parent.path()}.{self.name()}"
@@ -70,22 +73,22 @@ class Component(abc.ABC):
         """Get component ports"""
         return self._ports
 
-    def _get_ports(self, output):
+    def _get_ports(self, output) -> list[Port]:
         sel_ports = []
         for port in self._ports:
             if port.is_output() == output:
                 sel_ports.append(port)
         return sel_ports
 
-    def inports(self):
+    def inports(self) -> list[Port]:
         """Get component input ports"""
         return self._get_ports(False)
 
-    def outports(self):
+    def outports(self) -> list[Port]:
         """Get component output ports"""
         return self._get_ports(True)
 
-    def port(self, portname):
+    def port(self, portname: str) -> Port:
         """Get port with name 'portname'"""
         for port in self._ports:
             if port.name() == portname:
@@ -97,46 +100,46 @@ class Component(abc.ABC):
         """Get the circuit for the current component"""
         return self._circuit
 
-    def name(self):
+    def name(self) -> str:
         """Get the component name"""
         return self._name
 
-    def set_name(self, name, update_circuit=True):
+    def set_name(self, name: str, update_circuit: bool = True):
         """Set the component name"""
         if update_circuit:
             self.circuit.change_component_name(self, name)
         else:
             self._name = name
 
-    def display_name(self):
+    def display_name(self) -> str:
         """Get the component display name"""
         return self._display_name
 
-    def set_display_name(self, display_name):
+    def set_display_name(self, display_name: str):
         """Set the component display name"""
         self._display_name = display_name
 
     @property
-    def parent(self):
+    def parent(self) -> Component | None:
         """Get parent component"""
         return self._parent
 
-    def is_toplevel(self):
-        """Return True if this component is a toplevel component"""
-        return self._parent is None
-
     @parent.setter
-    def parent(self, parent):
+    def parent(self, parent: Component):
         """Set component parent"""
         self._parent = parent
 
+    def is_toplevel(self) -> bool:
+        """Return True if this component is a toplevel component"""
+        return self._parent is None
+
     @property
     def wire(self):
         """Property needed to be able to have a setter"""
         raise ComponentException(f"Cannot get wire for component '{self.display_name}'")
 
     @wire.setter
-    def wire(self, port):
+    def wire(self, port: Port):
         """Some components have a single output port, they can wired at component level"""
         self.outports()[0].wire = port
 
@@ -146,14 +149,14 @@ class Component(abc.ABC):
     def remove_connections(self):
         """Remove component connections"""
         for src_port in self.outports():
-            for dst_port in src_port.get_wires():
+            for dst_port in src_port.wired_ports:
                 dst_port.set_driver(None)
 
         for dst_port in self.inports():
             if dst_port.has_driver():
                 dst_port.get_driver().disconnect(dst_port)
 
-    def add_event(self, port, value, delay_ns):
+    def add_event(self, port: Port, value: int, delay_ns: int):
         """Add delta cycle event"""
         self.circuit.add_event(port, value, delay_ns)
 
@@ -166,12 +169,12 @@ class Component(abc.ABC):
         return comp_str
 
     @property
-    def has_action(self):
+    def has_action(self) -> bool:
         """Return True if this component is interactive"""
         return False
 
     @property
-    def active(self):
+    def active(self) -> bool:
         """Return True if this component is active/activated ('on' for a switch for example)"""
         return False
 
@@ -185,7 +188,7 @@ class Component(abc.ABC):
         """Get component settings from dict"""
         raise ComponentException(f"No setup for component '{self.display_name}'")
 
-    def settings_to_dict(self):
+    def settings_to_dict(self) -> dict[str, int | str | bool]:
         """Return component settings as a dict"""
         return copy.deepcopy(self._parameters)
 
@@ -194,7 +197,7 @@ class Component(abc.ABC):
         """Return parameters"""
         return {}
 
-    def update_settings(self, settings):
+    def update_settings(self, settings: dict[str, int | str | bool]):
         """Update parameters from settings dict"""
         for setting, value in settings.items():
             self.parameter_set(setting, value)
@@ -222,9 +225,9 @@ class Component(abc.ABC):
 class MultiComponent(Component):
     """A component that holds one or several sub components"""
 
-    def __init__(self, circuit, name):
+    def __init__(self, circuit, name: str):
         super().__init__(circuit, name)
-        self._components = []
+        self._components: list[Component] = []
 
     def init(self):
         super().init()
@@ -253,11 +256,11 @@ class CallbackComponent(Component):
     objects when the component change value.
     """
 
-    def __init__(self, circuit, name, callback=None):
+    def __init__(self, circuit, name: str, callback: Callable[[Component], None] | None = None):
         super().__init__(circuit, name)
         self._callback = callback
 
-    def set_callback(self, callback):
+    def set_callback(self, callback: Callable[[Component], None]):
         """Set CallbackComponent callback function"""
         self._callback = callback
 

digsim/circuit/components/atoms/_port.py

@@ -1,8 +1,10 @@
-# Copyright (c) Fredrik Andersson, 2023-2024
+# Copyright (c) Fredrik Andersson, 2023-2025
 # All rights reserved
 
 """This module contains the classes for all component ports"""
 
+from __future__ import annotations
+
 import abc
 
 from ._digsim_exception import DigsimException
@@ -15,14 +17,14 @@ class PortConnectionError(DigsimException):
 class Port(abc.ABC):
     """The abstract base class for all ports"""
 
-    def __init__(self, parent, name, width=1, output=False):
+    def __init__(self, parent, name: str, width: int = 1, output: bool = False):
         self._parent = parent  # The parent component
-        self._name = name  # The name of this port
-        self._width = width  # The bit-width of this port
-        self._output = output  # Is this port an output port
-        self._wired_ports = []  # The ports that this port drives
-        self._value = None  # The value of this port
-        self._edge_detect_value = "X"  # Last edge detect value
+        self._name: str = name  # The name of this port
+        self._width: int = width  # The bit-width of this port
+        self._output: bool = output  # Is this port an output port
+        self._wired_ports: list[Port] = []  # The ports that this port drives
+        self._value: int | str | None = None  # The value of this port
+        self._edge_detect_value: int | str | None = "X"  # Last edge detect value
         self.init()  # Initialize the port
 
     def init(self):
@@ -32,27 +34,27 @@ class Port(abc.ABC):
         self.update_wires("X")
 
     @property
-    def wired_ports(self):
+    def wired_ports(self) -> list[Port]:
         """Get wires from thisport"""
         return self._wired_ports
 
     @property
-    def value(self):
+    def value(self) -> int | str | None:
         """Get the value of the port, can be "X" """
         return self._value
 
     @value.setter
-    def value(self, value):
+    def value(self, value: int | str | None):
         """Set the value of the port"""
         self.set_value(value)
 
     @property
-    def width(self):
+    def width(self) -> int:
         """Get the bit-width of the port"""
         return self._width
 
     @width.setter
-    def width(self, width):
+    def width(self, width: int):
         """Set the bit-width of the port, will force a disconnect if it is connected"""
         if width != self._width:
             driver = self.get_driver()
@@ -68,7 +70,7 @@ class Port(abc.ABC):
         raise PortConnectionError("Cannot get a wire")
 
     @wire.setter
-    def wire(self, port):
+    def wire(self, port: PortWire):
         """Wire setter, connect this port to an input port (of same width)"""
         if port.has_driver():
             raise PortConnectionError(f"The port {port.path()}.{port.name()} already has a driver")
@@ -84,11 +86,11 @@ class Port(abc.ABC):
             port.set_driver(None)
         self._wired_ports = []
 
-    def name(self):
+    def name(self) -> str:
         """Get port name"""
         return self._name
 
-    def path(self):
+    def path(self) -> str:
         """Get port path, <component_name>...<component_name>"""
         return self._parent.path()
 
@@ -96,7 +98,7 @@ class Port(abc.ABC):
         """Get parent component"""
         return self._parent
 
-    def update_wires(self, value):
+    def update_wires(self, value: int | str | None):
         """Update connected wires (and self._value) with value"""
         if self._value == value:
             return
@@ -104,26 +106,22 @@ class Port(abc.ABC):
         for port in self._wired_ports:
             port.value = self._value
 
-    def get_wires(self):
-        """Get connected ports"""
-        return self._wired_ports
-
-    def get_wired_ports_recursive(self):
+    def get_wired_ports_recursive(self) -> list[Port]:
         """Get all connected ports (recursive)"""
         all_wired_ports = [self]
         for port in self._wired_ports:
             all_wired_ports.extend(port.get_wired_ports_recursive())
         return all_wired_ports
 
-    def is_output(self):
+    def is_output(self) -> bool:
         """Return True if this port is an output port"""
         return self._output
 
-    def is_input(self):
+    def is_input(self) -> bool:
         """Return True if this port is an input port"""
         return not self._output
 
-    def is_rising_edge(self):
+    def is_rising_edge(self) -> bool:
         """
         Return True if a rising edge has occured
         Note: This function can only be called once per 'update'
@@ -134,7 +132,7 @@ class Port(abc.ABC):
         self._edge_detect_value = self.value
         return rising_edge
 
-    def is_falling_edge(self):
+    def is_falling_edge(self) -> bool:
         """
         Return True if a falling edge has occured
         Note: This function can only be called once per 'update'
@@ -146,14 +144,21 @@ class Port(abc.ABC):
         return falling_edge
 
     @abc.abstractmethod
-    def set_value(self, value):
+    def set_value(self, value: int | str | None):
         """Set value on port"""
 
     @abc.abstractmethod
-    def set_driver(self, port):
+    def set_driver(self, port: Port | None):
         """Set port driver"""
 
-    def can_add_wire(self):
+    @abc.abstractmethod
+    def has_driver(self) -> bool:
+        """Return True if port has driver"""
+
+    def get_driver(self):
+        """Get port driver"""
+
+    def can_add_wire(self) -> bool:
         """Return True if it is possible to add a wire to this port"""
         if self.is_output():
             return True
@@ -161,14 +166,14 @@ class Port(abc.ABC):
             return True
         return False
 
-    def disconnect(self, port):
+    def disconnect(self, port: Port):
         """Disconnect port if it is wired"""
         if port in self._wired_ports:
             index = self._wired_ports.index(port)
             del self._wired_ports[index]
         port.set_driver(None)
 
-    def strval(self):
+    def strval(self) -> str:
         """Return value as string"""
         if self.value == "X":
             return "X"
@@ -176,7 +181,7 @@ class Port(abc.ABC):
             return f"0x{self.value:x}"
         return f"{self.value}"
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self._parent.name()}:{self._name}={self.value}"
 
 
@@ -186,22 +191,22 @@ class PortWire(Port):
     * The port wire will instantaneously update the driven wires upon change.
     """
 
-    def __init__(self, parent, name, width=1, output=False):
+    def __init__(self, parent, name: str, width: int = 1, output: bool = False):
         super().__init__(parent, name, width, output)
-        self._port_driver = None  # The port that drives this port
+        self._port_driver: Port | None = None  # The port that drives this port
 
-    def set_value(self, value):
+    def set_value(self, value: int | str | None):
         if value != self.value:
             self.update_wires(value)
 
-    def set_driver(self, port):
+    def set_driver(self, port: Port | None):
         self._port_driver = port
 
-    def get_driver(self):
+    def get_driver(self) -> Port | None:
         """Get driver for port"""
         return self._port_driver
 
-    def has_driver(self):
+    def has_driver(self) -> bool:
         """Return True if port has driver"""
         return self._port_driver is not None
 
@@ -213,10 +218,10 @@ class PortIn(PortWire):
     * The port will update the parent component upon change.
     """
 
-    def __init__(self, parent, name, width=1):
+    def __init__(self, parent, name: str, width: int = 1):
         super().__init__(parent, name, width, output=False)
 
-    def set_value(self, value):
+    def set_value(self, value: int | str | None):
         super().set_value(value)
         self.parent().update()
 
@@ -228,40 +233,40 @@ class PortOutDelta(Port):
     * The port will update the parent component if the _update_parent variable is set to true.
     """
 
-    def __init__(self, parent, name, width=1, delay_ns=1):
+    def __init__(self, parent, name: str, width: int = 1, delay_ns: int = 1):
         super().__init__(parent, name, width, output=True)
         self._delay_ns = delay_ns  # Propagation delay for this port
         self._update_parent = False  # Should this port update parent on change
 
-    def update_parent(self, update_parent):
+    def update_parent(self, update_parent: bool):
         """Set update parent valiable (True/False)"""
         self._update_parent = update_parent
 
-    def set_delay_ns(self, delay_ns):
+    def set_delay_ns(self, delay_ns: int):
         """Set port propagation delay"""
         self._delay_ns = delay_ns
 
-    def set_value(self, value):
+    def set_value(self, value: int | str | None):
         self.parent().add_event(self, value, self._delay_ns)
 
-    def update_port(self, value):
+    def update_port(self, value: int | str | None):
         """Update the port output and the connected wires"""
         self.update_wires(value)
         if self._update_parent:
             self.parent().update()
 
-    def delta_cycle(self, value):
+    def delta_cycle(self, value: int | str | None):
         """Handle the delta cycle event from the circuit"""
         self.update_port(value)
 
-    def set_driver(self, port):
+    def set_driver(self, port: Port | None):
         raise PortConnectionError(f"The port {self.path()}.{self.name()} cannot be driven")
 
-    def get_driver(self):
+    def get_driver(self) -> Port | None:
         """Get driver for port, the output port has no driver"""
         return None
 
-    def has_driver(self):
+    def has_driver(self) -> bool:
         """Return False since the port does not have a driver"""
         return False
 
@@ -274,14 +279,14 @@ class PortOutImmediate(PortOutDelta):
     * The port will update the parent component if the _update_parent variable is set to true.
     """
 
-    def __init__(self, parent, name, width=1):
+    def __init__(self, parent, name: str, width: int = 1):
         super().__init__(parent, name, width)
 
-    def set_value(self, value):
+    def set_value(self, value: int | str | None):
         self.parent().add_event(self, value, 0)
         super().update_port(value)
 
-    def delta_cycle(self, value):
+    def delta_cycle(self, value: int | str | None):
         """
         Do nothing here, the event is just used to updates waves in Circuit class
         """
@@ -294,15 +299,15 @@ class PortWireBit(PortWire):
     The PortWireBit will update its parent (a PortMultiBitWire) upon change.
     """
 
-    def __init__(self, parent, name, parent_port, output):
+    def __init__(self, parent, name: str, parent_port: PortMultiBitWire, output: bool):
         super().__init__(parent, name, 1, output)
         self._parent_port = parent_port
 
-    def set_value(self, value):
+    def set_value(self, value: int | str | None):
         super().set_value(value)
         self._parent_port.update_value_from_bits()
 
-    def get_parent_port(self):
+    def get_parent_port(self) -> PortMultiBitWire:
         """Get the parent PortMultiBitWire for this port"""
         return self._parent_port
 
@@ -314,8 +319,8 @@ class PortMultiBitWire(Port):
     The PortWireMultiBit will add events to the circuit upon change to update vcd output.
     """
 
-    def __init__(self, parent, name, width, output=False):
-        self._port_driver = None  # The port that drives this port
+    def __init__(self, parent, name: str, width: int, output: bool = False):
+        self._port_driver: Port | None = None  # The port that drives this port
         self._bits = []
         super().__init__(parent, name, width, output)
         for bit_id in range(self.width):
@@ -328,32 +333,32 @@ class PortMultiBitWire(Port):
         for bit in self._bits:
             bit.init()
 
-    def set_value(self, value):
-        if value == "X":
+    def set_value(self, value: int | str | None):
+        if value is None or isinstance(value, str):
             return
         for bit_id, bit in enumerate(self._bits):
             bit_val = (value >> bit_id) & 1
             bit.value = bit_val
 
-    def get_wired_ports_recursive(self):
+    def get_wired_ports_recursive(self) -> list[Port]:
         all_wired_ports = super().get_wired_ports_recursive()
         for bit in self._bits:
             all_wired_ports.extend(bit.get_wired_ports_recursive())
         return all_wired_ports
 
-    def set_driver(self, port):
+    def set_driver(self, port: Port | None):
         """Set port driver"""
         self._port_driver = port
 
-    def get_driver(self):
+    def get_driver(self) -> Port | None:
         """Get port driver"""
         return self._port_driver
 
-    def has_driver(self):
+    def has_driver(self) -> bool:
         """Return True if port has driver"""
         return self._port_driver is not None
 
-    def get_bit(self, bit_id):
+    def get_bit(self, bit_id: int) -> Port:
         """Get bit port"""
         return self._bits[bit_id]
 
@@ -370,7 +375,7 @@ class PortMultiBitWire(Port):
         # Send event just to update waves
         self.parent().add_event(self, value, 0)
 
-    def delta_cycle(self, value):
+    def delta_cycle(self, value: int | str | None):
         """
         Do nothing here, the event passed in 'update_value_from_bits'
         is just used to updates waves in Circuit class