update with changes to main

.gitignore

@@ -69,9 +69,6 @@ instance/
 # Scrapy stuff:
 .scrapy
 
-# Sphinx documentation
-docs/_build/
-
 # PyBuilder
 .pybuilder/
 target/
@@ -139,4 +136,4 @@ dmypy.json
 cython_debug/
 
 # notes, remove at merge
-.notes/
+.notes/

conf.py

@@ -0,0 +1,14 @@
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("."))
+
+extensions = [
+    "sphinx.ext.autodoc",
+]
+
+autodoc_modules = {
+    "Device": "./emulators/Device.py",
+    "Medium": "./emulators/Medium.py",
+    "MessageStub": "./emulators/MessageStub.py",
+}

docs/source/index.rst

@@ -0,0 +1,27 @@
+DistributedExercisesAAU docs
+=============================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+Device
+------
+
+.. automodule:: emulators.Device
+   :members:
+   :undoc-members:
+
+Medium
+------
+
+.. automodule:: emulators.Medium
+   :members:
+   :undoc-members:
+
+MessageStub
+-----------
+
+.. automodule:: emulators.MessageStub
+   :members:
+   :undoc-members:

emulators/AsyncEmulator.py

@@ -1,74 +1,95 @@
 import copy
 import random
-import threading
 import time
-from threading import Lock
 from typing import Optional
+from os import name
 
 from emulators.EmulatorStub import EmulatorStub
 from emulators.MessageStub import MessageStub
 
+if name == "posix":
+    RESET = "\u001B[0m"
+    CYAN = "\u001B[36m"
+    GREEN = "\u001B[32m"
+else:
+    RESET = ""
+    CYAN = ""
+    GREEN = ""
 
-class AsyncEmulator(EmulatorStub):
 
+class AsyncEmulator(EmulatorStub):
     def __init__(self, number_of_devices: int, kind):
         super().__init__(number_of_devices, kind)
         self._terminated = 0
-        self._messages = {}
+        self._messages: dict[int, list[MessageStub]] = {}
         self._messages_sent = 0
 
     def run(self):
         self._progress.acquire()
         self._start_threads()
         self._progress.release()
 
-        # make sure the round_lock is locked initially
         while True:
             time.sleep(0.1)
             self._progress.acquire()
             # check if everyone terminated
-            if self.all_terminated():
+            if self.all_terminated:
                 break
             self._progress.release()
         for t in self._threads:
             t.join()
         return
 
-    def queue(self, message: MessageStub):
-        self._progress.acquire()
+    def queue(self, message: MessageStub, stepper=False):
+        if not stepper:
+            self._progress.acquire()
         self._messages_sent += 1
-        print(f'\tSend {message}')
+        print(f"\r\t{GREEN}Send{RESET} {message}")
         if message.destination not in self._messages:
             self._messages[message.destination] = []
-        self._messages[message.destination].append(copy.deepcopy(message)) # avoid accidental memory sharing
-        random.shuffle(self._messages[message.destination]) # shuffle to emulate changes in order
-        time.sleep(random.uniform(0.01, 0.1)) # try to obfuscate delays and emulate network delays
-        self._progress.release()
+        self._messages[message.destination].append(
+            copy.deepcopy(message)
+        )  # avoid accidental memory sharing
+        random.shuffle(
+            self._messages[message.destination]
+        )  # shuffle to emulate changes in order
+        time.sleep(
+            random.uniform(0.01, 0.1)
+        )  # try to obfuscate delays and emulate network delays
+        if not stepper:
+            self._progress.release()
 
-    def dequeue(self, index: int) -> Optional[MessageStub]:
-        self._progress.acquire()
+    def dequeue(self, index: int, stepper=False) -> Optional[MessageStub]:
+        if not stepper:
+            self._progress.acquire()
         if index not in self._messages:
-            self._progress.release()
+            if not stepper:
+                self._progress.release()
             return None
         elif len(self._messages[index]) == 0:
-            self._progress.release()
+            if not stepper:
+                self._progress.release()
             return None
         else:
             m = self._messages[index].pop()
-            print(f'\tRecieve {m}')
-            self._progress.release()
+            print(f"\r\t{GREEN}Recieve{RESET} {m}")
+            if not stepper:
+                self._progress.release()
             return m
 
     def done(self, index: int):
-        time.sleep(random.uniform(0.01, 0.1)) # try to obfuscate delays and emulate network delays
+        time.sleep(
+            random.uniform(0.01, 0.1)
+        )  # try to obfuscate delays and emulate network delays
         return
 
-
     def print_statistics(self):
-        print(f'\tTotal {self._messages_sent} messages')
-        print(f'\tAverage {self._messages_sent/len(self._devices)} messages/device')
+        print(f"\t{GREEN}Total{RESET} {self._messages_sent} messages")
+        print(
+            f"\t{GREEN}Average{RESET} {self._messages_sent/len(self._devices)} messages/device"
+        )
 
-    def terminated(self, index:int):
+    def terminated(self, index: int):
         self._progress.acquire()
         self._terminated += 1
-        self._progress.release()
+        self._progress.release()

emulators/Device.py

@@ -5,24 +5,68 @@
 
 
 class Device:
+    """
+    Base class representing a device in a simulation.
+
+    Args:
+        index (int): The unique identifier for the device.
+        number_of_devices (int): The total number of devices in the simulation.
+        medium (Medium): The communication medium used by the devices.
+
+    Attributes:
+        _id (int): The unique identifier for the device.
+        _medium (Medium): The communication medium used by the device.
+        _number_of_devices (int): The total number of devices in the simulation.
+        _finished (bool): A flag indicating if the device has finished its task.
+    """
+
     def __init__(self, index: int, number_of_devices: int, medium: Medium):
         self._id = index
         self._medium = medium
         self._number_of_devices = number_of_devices
+        self._finished = False
 
     def run(self):
+        """
+        Abstract method representing the main functionality of the device.
+        """
+
         raise NotImplementedError("You have to implement a run-method!")
 
     def print_result(self):
+        """
+        Abstract method for the result printer
+        """
         raise NotImplementedError("You have to implement a result printer!")
 
+    @property
     def index(self):
+        """
+        The unique identifier for the device.
+
+        Returns:
+            int: The unique identifier of the device.
+        """
         return self._id
 
+    @property
     def number_of_devices(self):
+        """
+        Get the total number of devices in the simulation.
+
+        Returns:
+            int: The total number of devices.
+        """
         return self._number_of_devices
 
+    @property
     def medium(self):
+        """
+        Get the communication medium used by the device.
+
+        Returns:
+            Medium: The communication medium.
+        """
         return self._medium
 
 
@@ -34,9 +78,12 @@ def __init__(self, index: int, number_of_devices: int, medium: Medium):
         super().__init__(index, number_of_devices, medium)
         self._has_work = False
 
+    @property
     def has_work(self) -> bool:
         # The random call emulates that a concurrent process asked for the
-        self._has_work = self._has_work or random.randint(0, self.number_of_devices()) == self.index()
+        self._has_work = (
+            self._has_work or random.randint(0, self.number_of_devices) == self.index
+        )
         return self._has_work
 
     def do_work(self):
@@ -45,19 +92,19 @@ def do_work(self):
         # might require continued interaction. The "working" thread would then notify our Requester class back
         # when the mutex is done being used.
         self._lock.acquire()
-        print(f'Device {self.index()} has started working')
+        print(f"Device {self.index} has started working")
         self._concurrent_workers += 1
         if self._concurrent_workers > 1:
             self._lock.release()
             raise Exception("More than one concurrent worker!")
         self._lock.release()
 
-        assert (self.has_work())
+        assert self.has_work
         amount_of_work = random.randint(1, 4)
         for i in range(0, amount_of_work):
-            self.medium().wait_for_next_round()
+            self.medium.wait_for_next_round()
         self._lock.acquire()
-        print(f'Device {self.index()} has ended working')
+        print(f"Device {self.index} has ended working")
         self._concurrent_workers -= 1
         self._lock.release()
         self._has_work = False

emulators/EmulatorStub.py

@@ -6,18 +6,19 @@
 
 
 class EmulatorStub:
-
     def __init__(self, number_of_devices: int, kind):
         self._nids = number_of_devices
         self._devices = []
         self._threads = []
         self._media = []
         self._progress = threading.Lock()
 
-        for index in self.ids():
+        for index in self.ids:
             self._media.append(Medium(index, self))
             self._devices.append(kind(index, number_of_devices, self._media[-1]))
-            self._threads.append(threading.Thread(target=self._run_thread, args=[index]))
+            self._threads.append(
+                threading.Thread(target=self._run_thread, args=[index])
+            )
 
     def _run_thread(self, index: int):
         self._devices[index].run()
@@ -30,14 +31,15 @@ def _run_thread(self, index: int):
     def _start_threads(self):
         cpy = self._threads.copy()
         random.shuffle(cpy)
-        print('Starting Threads')
+        print("Starting Threads")
         for thread in cpy:
             thread.start()
 
+    @property
     def all_terminated(self) -> bool:
-        return all([not self._threads[x].is_alive()
-                    for x in self.ids()])
+        return all([not self._threads[x].is_alive() for x in self.ids])
 
+    @property
     def ids(self):
         return range(0, self._nids)
 
@@ -46,19 +48,19 @@ def print_result(self):
             d.print_result()
 
     def run(self):
-        raise NotImplementedError(f'Please contact the instructor')
+        raise NotImplementedError("Please contact the instructor")
 
     def queue(self, message: MessageStub):
-        raise NotImplementedError(f'Please contact the instructor')
+        raise NotImplementedError("Please contact the instructor")
 
     def dequeue(self, id) -> MessageStub:
-        raise NotImplementedError(f'Please contact the instructor')
+        raise NotImplementedError("Please contact the instructor")
 
     def done(self, id):
-        raise NotImplementedError(f'Please contact the instructor')
+        raise NotImplementedError("Please contact the instructor")
 
     def print_statistics(self):
-        raise NotImplementedError(f'Please contact the instructor')
+        raise NotImplementedError("Please contact the instructor")
 
     def terminated(self, index: int):
-        raise NotImplementedError(f'Please contact the instructor')
+        raise NotImplementedError("Please contact the instructor")