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

digsim/app/gui/_circuit_area.py

@@ -1,4 +1,4 @@
-# Copyright (c) Fredrik Andersson, 2023-2024
+# Copyright (c) Fredrik Andersson, 2023-2025
 # All rights reserved
 
 """The circuit area and component widget"""
@@ -275,7 +275,7 @@ class _CircuitAreaScene(QGraphicsScene):
         component_objects = self._app_model.objects.components.get_object_list()
         for src_comp_item in component_objects:
             for src_port in src_comp_item.component.outports():
-                for dst_port in src_port.get_wires():
+                for dst_port in src_port.wired_ports:
                     dst_comp_item = self._app_model.objects.components.get_object(
                         dst_port.parent()
                     )

digsim/app/gui_objects/_image_objects.py

@@ -3,6 +3,8 @@
 
 """A component with an image as symbol the GUI"""
 
+from __future__ import annotations
+
 from pathlib import Path
 
 from PySide6.QtCore import QPoint, Qt
@@ -14,8 +16,8 @@ from ._component_object import ComponentObject
 class ImageObject(ComponentObject):
     """The class for a image component placed in the GUI"""
 
-    IMAGE_FILENAME = None
-    ACTIVE_IMAGE_FILENAME = None
+    IMAGE_FILENAME: str | None = None
+    ACTIVE_IMAGE_FILENAME: str | None = None
     _pixmap = None
     _pixmap_active = None
 

digsim/circuit/_circuit.py

@@ -1,16 +1,19 @@
-# Copyright (c) Fredrik Andersson, 2023-2024
+# Copyright (c) Fredrik Andersson, 2023-2025
 # All rights reserved
 
 """
 Module that handles the circuit simulation of components
 """
 
+from __future__ import annotations
+
 import os
+from typing import Tuple
 
 from digsim.storage_model import CircuitDataClass, CircuitFileDataClass
 
 from ._waves_writer import WavesWriter
-from .components.atoms import DigsimException
+from .components.atoms import Component, DigsimException, PortOutDelta
 
 
 class CircuitError(DigsimException):
@@ -23,90 +26,89 @@ class CircuitEvent:
     delta events in the simulation.
     """
 
-    def __init__(self, time_ns, port, value):
-        self._time_ns = time_ns
-        self._port = port
-        self._value = value
+    def __init__(self, time_ns: int, port: PortOutDelta, value: int | str | None):
+        self._time_ns: int = time_ns
+        self._port: PortOutDelta = port
+        self._value: int | str | None = value
 
     @property
-    def time_ns(self):
+    def time_ns(self) -> int:
         """Get the simulation time (ns) of this event"""
         return self._time_ns
 
     @property
-    def port(self):
+    def port(self) -> PortOutDelta:
         """Get the port of this event"""
         return self._port
 
     @property
-    def value(self):
+    def value(self) -> int | str | None:
         """Get the delta cycle value of this event"""
         return self._value
 
-    def is_same_event(self, port):
+    def is_same_event(self, port: PortOutDelta):
         """Return True if the in the event is the same as"""
         return port == self._port
 
-    def update(self, time_ns, value):
+    def update(self, time_ns: int, value: int | str | None):
         """Update the event with a new time (ns) and a new value"""
         self._time_ns = time_ns
         self._value = value
 
-    def __lt__(self, other):
+    def __lt__(self, other) -> bool:
         return other.time_ns > self.time_ns
 
 
 class Circuit:
     """Class thay handles the circuit simulation"""
 
-    def __init__(self, name=None, vcd=None):
-        self._components = {}
-        self._circuit_events = []
-        self._name = name
-        self._time_ns = 0
-        self._folder = None
+    def __init__(self, name: str | None = None, vcd: str | None = None):
+        self._components: dict[str, Component] = {}
+        self._circuit_events: list[CircuitEvent] = []
+        self._name: str | None = name
+        self._time_ns: int = 0
+        self._folder: str | None = None
+        self._vcd: WavesWriter | None = None
 
         if vcd is not None:
             self._vcd = WavesWriter(filename=vcd)
-        else:
-            self._vcd = None
 
     @property
-    def name(self):
+    def name(self) -> str | None:
         """Get the circuit name"""
         return self._name
 
     @property
-    def time_ns(self):
+    def time_ns(self) -> int:
         """Get the current simulation time (ns)"""
         return self._time_ns
 
     @property
-    def components(self):
+    def components(self) -> list[Component]:
         """Get the components in this circuit"""
         comp_array = []
         for _, comp in self._components.items():
             comp_array.append(comp)
         return comp_array
 
-    def load_path(self, path):
+    def load_path(self, path) -> str:
         """Get the load path relative to the circuit path"""
         if self._folder is not None:
             return self._folder + "/" + path
         return path
 
-    def store_path(self, path):
+    def store_path(self, path) -> str:
         """Get the store path relative to the circuit path"""
         if self._folder is not None:
             return os.path.relpath(path, self._folder)
         return path
 
-    def delete_component(self, component):
+    def delete_component(self, component: Component):
         """Delete a component from the circuit"""
         del self._components[component.name()]
         component.remove_connections()
 
-    def get_toplevel_components(self):
+    def get_toplevel_components(self) -> list[Component]:
         """Get toplevel components in the circuit"""
         toplevel_components = []
         for _, comp in self._components.items():
@@ -157,7 +159,7 @@ class Circuit:
             for port in comp.ports:
                 self._vcd.write(port, self._time_ns)
 
-    def _time_to_ns(self, s=None, ms=None, us=None, ns=None):
+    def _time_to_ns(self, s=None, ms=None, us=None, ns=None) -> int:
         time_ns = 0
         time_ns += s * 1e9 if s is not None else 0
         time_ns += ms * 1e6 if ms is not None else 0
@@ -168,7 +170,7 @@ class Circuit:
     def __exit__(self, exc_type, exc_value, exc_traceback):
         self._vcd.close()
 
-    def process_single_event(self, stop_time_ns=None):
+    def process_single_event(self, stop_time_ns=None) -> Tuple[bool, bool]:
         """
         Process one simulation event
         Return False if ther are now events of if the stop_time has passed
@@ -190,13 +192,20 @@ class Circuit:
             self._vcd.write(event.port, self._time_ns)
         return True, toplevel
 
-    def _is_toplevel_event(self):
+    def _is_toplevel_event(self) -> bool:
         if len(self._circuit_events) == 0:
             return False
         event = self._circuit_events[0]
         return event.port.parent().is_toplevel()
 
-    def run(self, s=None, ms=None, us=None, ns=None, single_step=False):
+    def run(
+        self,
+        s: int | None = None,
+        ms: int | None = None,
+        us: int | None = None,
+        ns: int | None = None,
+        single_step: bool = False,
+    ) -> bool:
         """Run simulation for a period of time"""
         stop_time_ns = self._time_ns + self._time_to_ns(s=s, ms=ms, us=us, ns=ns)
         single_step_stop = False
@@ -210,13 +219,19 @@ class Circuit:
         self._time_ns = max(self._time_ns, stop_time_ns)
         return single_step_stop
 
-    def run_until(self, s=None, ms=None, us=None, ns=None):
+    def run_until(
+        self,
+        s: int | None = None,
+        ms: int | None = None,
+        us: int | None = None,
+        ns: int | None = None,
+    ):
         """Run simulation until a specified time"""
         stop_time_ns = self._time_to_ns(s=s, ms=ms, us=us, ns=ns)
         if stop_time_ns >= self._time_ns:
             self.run(ns=stop_time_ns - self._time_ns)
 
-    def add_event(self, port, value, propagation_delay_ns):
+    def add_event(self, port: PortOutDelta, value: int | str | None, propagation_delay_ns: int):
         """Add delta cycle event, this will also write values to .vcd file"""
         event_time_ns = self._time_ns + propagation_delay_ns
         # print(f"Add event {port.parent().name()}:{port.name()} => {value}")
@@ -226,7 +241,7 @@ class Circuit:
                 return
         self._circuit_events.append(CircuitEvent(event_time_ns, port, value))
 
-    def add_component(self, component):
+    def add_component(self, component: Component):
         """Add component to circuit"""
         name_id = 1
         namebase = component.name()
@@ -235,21 +250,21 @@ class Circuit:
             name_id += 1
         self._components[component.name()] = component
 
-    def change_component_name(self, component, name):
+    def change_component_name(self, component: Component, name: str):
         """Change component name"""
         comp = self._components[component.name()]
         del self._components[component.name()]
         comp.set_name(name, update_circuit=False)
         self.add_component(comp)
 
-    def get_component(self, component_name):
+    def get_component(self, component_name: str) -> Component:
         """Get component witgh 'component_name'"""
         comp = self._components.get(component_name)
         if comp is not None:
             return comp
         raise CircuitError(f"Component '{component_name}' not found")
 
-    def to_dataclass(self, folder=None):
+    def to_dataclass(self, folder: str | None = None) -> CircuitDataClass:
         """Generate dict from circuit, used when storing circuit"""
         if self._name is None:
             raise CircuitError("Circuit must have a name")
@@ -257,8 +272,12 @@ class Circuit:
         return CircuitDataClass.from_circuit(self)
 
     def from_dataclass(
-        self, circuit_dc, folder=None, component_exceptions=True, connect_exceptions=True
-    ):
+        self,
+        circuit_dc: CircuitDataClass,
+        folder: str | None = None,
+        component_exceptions: bool = True,
+        connect_exceptions: bool = True,
+    ) -> list[str]:
         """Clear circuit and add components from dict"""
         self._folder = folder
         self.clear()
@@ -285,12 +304,12 @@ class Circuit:
 
         return exception_str_list
 
-    def to_json_file(self, filename):
+    def to_json_file(self, filename: str):
         """Store circuit in json file"""
         circuitfile_dc = CircuitFileDataClass(circuit=self.to_dataclass())
         circuitfile_dc.save(filename)
 
-    def from_json_file(self, filename, folder=None):
+    def from_json_file(self, filename: str, folder: str | None = None):
         """Load circuit from json file"""
         file_dc = CircuitFileDataClass.load(filename)
         self.from_dataclass(file_dc.circuit, folder)

digsim/circuit/_waves_writer.py

@@ -1,35 +1,46 @@
-# Copyright (c) Fredrik Andersson, 2023-2024
+# Copyright (c) Fredrik Andersson, 2023-2025
 # All rights reserved
 
 """
 Module that handles the creation of vcd files
 """
 
+import io
+from typing import Any, Tuple
+
 from vcd import VCDWriter
 
+from .components.atoms import Port
+
 
 class WavesWriter:
     """Class that handles the creation of vcd files"""
 
-    def __init__(self, filename):
-        self._vcd_name = filename
-        self._vcd_file = None
-        self._vcd_writer = None
-        self._vcd_dict = {}
+    def __init__(self, filename: str):
+        self._vcd_name: str = filename
+        self._vcd_file: io.TextIOWrapper | None = None
+        self._vcd_writer: VCDWriter | None = None
+        self._vcd_dict: dict[str, Any] = {}
 
-    def init(self, port_info):
+    def init(self, port_info: list[Tuple[str, str, int]]):
         """Initialize vcd writer"""
         if self._vcd_file is not None or self._vcd_writer is not None:
             self.close()
         self._vcd_file = open(self._vcd_name, mode="w", encoding="utf-8")
+        if self._vcd_file is None:
+            raise RuntimeError("VCD file is None")
         self._vcd_writer = VCDWriter(self._vcd_file, timescale="1 ns", date="today")
         for port_path, port_name, port_width in port_info:
             var = self._vcd_writer.register_var(port_path, port_name, "wire", size=port_width)
             self._vcd_dict[f"{port_path}.{port_name}"] = var
         self._vcd_file.flush()
 
-    def write(self, port, time_ns):
+    def write(self, port: Port, time_ns: int):
         """Write port value to vcd file"""
+        if self._vcd_file is None:
+            raise RuntimeError("VCD file is None")
+        if self._vcd_writer is None:
+            raise RuntimeError("VCD Writer is None")
         for wired_port in port.get_wired_ports_recursive():
             var = self._vcd_dict.get(f"{wired_port.path()}.{wired_port.name()}")
             if var is None:

digsim/circuit/components/_label_wire.py

@@ -3,15 +3,15 @@
 
 """Label Wire components module"""
 
-from .atoms import Component, DigsimException, PortWire
+from .atoms import Component, DigsimException, PortIn, PortWire
 
 
 class _LabelWireStorage:
     """Singleton class with label wires"""
 
     _instance = None
-    _wire_drivers = {}
-    _wire_sinks = {}
+    _wire_drivers: dict[str, PortWire] = {}
+    _wire_sinks: dict[str, PortIn] = {}
 
     def __new__(cls):
         if cls._instance is None:

digsim/circuit/components/atoms/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) Fredrik Andersson, 2023
+# Copyright (c) Fredrik Andersson, 2023-2025
 # All rights reserved
 
 """All classes within digsim.circuit.components.atoms namespace"""
@@ -11,6 +11,7 @@ from ._component import (  # noqa: F401
 )
 from ._digsim_exception import DigsimException  # noqa: F401
 from ._port import (  # noqa: F401
+    Port,
     PortConnectionError,
     PortIn,
     PortMultiBitWire,

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