Merge pull request #281 from CiwPython/updates-by-pr

Updates PR

Author: geraintpalmer

.github/workflows/tests.yml

@@ -35,7 +35,7 @@ jobs:
     - name: Run tests
       run: |
         python -m pip install -r test_requirements.txt
-        coverage run --source=ciw -m unittest discover
+        coverage run -m unittest discover
 
     - name: Report coverage
       run: |

.gitignore

@@ -10,3 +10,5 @@ dist/
 *ciw/.hypothesis*
 *ciw/disciplines/.hypothesis*
 env/
+venv/
+.venv/

CHANGES.rst

@@ -2,7 +2,7 @@ History
 -------
 
 + **3.2.5 (2025-03-25)**
-  + Fixes bug in PoissonIntervals distribution where if the last rate is zero or so small there is no samples, the cycle begins again too early.
+    + Fixes bug in PoissonIntervals distribution where if the last rate is zero or so small there is no samples, the cycle begins again too early.
 
 + **3.2.4 (2024-12-04)**
     + Adds a new method for the `simulate_until_max_customers`: "Complete" simulates until a specific number of completed customer journeys; while "Finish" simulates until a specific number of customers have reached the exit node (through bailking or reneging).

CONTRIBUTING.rst

@@ -19,12 +19,12 @@ Install a development version of the library::
 
 Make sure the tests pass (Ciw uses unit & doc testing)::
 
-    python -m unittest discover ciw
+    python -m unittest discover
     python doctests.py
 
 We encourage the use of coverage, ensuring all aspects of the code are tested::
 
-    coverage run --source=ciw -m unittest discover ciw.tests
+    coverage run --source=ciw -m unittest discover
     coverage report -m
 
 Add tests for your change. Make your change and make the tests pass.

ciw/deadlock/deadlock_detector.py

@@ -1,7 +1,7 @@
 import networkx as nx
 
 
-class NoDetection(object):
+class NoDetection:
     """
     A generic class for all deadlock detector classes to inherit from.
     Using this class is equivalent to having no deadlock detection

ciw/dists/distributions.py

@@ -349,8 +349,10 @@ class PhaseType(Distribution):
     """
 
     def __init__(self, initial_state, absorbing_matrix):
-        if any(p < 0 or p > 1.0 for p in initial_state):
-            raise ValueError("Initial state vector must have valid probabilities.")
+        if any(p < 0 for p in initial_state):
+            raise ValueError("Initial state vector must have positive probabilities.")
+        if any(p > 1.0 for p in initial_state):
+            raise ValueError("Initial state vector probabilities must be no more than 1.0.")
         if sum(initial_state) > 1.0 + 10 ** (-10) or sum(initial_state) < 1.0 - 10 ** (
             -10
         ):

ciw/exactnode.py

@@ -1,39 +1,34 @@
+from typing import List
+
 from .node import Node
 from .arrival_node import ArrivalNode
-from decimal import Decimal, getcontext
+from decimal import Decimal
 from .server import Server
 
 
 class ExactNode(Node):
-    """
-    Inherits from the Node class, implements a more
-    precise version of addition to fix discrepencies
-    with floating point numbers.
+    """Exact numerical precision node.
+
+    This class inherits from the Node class, and
+    implements a more precise version of addition to
+    fix discrepencies with floating point numbers.
     """
 
     @property
-    def now(self):
-        """
-        Gets the current time
-        """
+    def now(self) -> Decimal:
+        """Get the current time."""
         return Decimal(self.simulation.current_time)
 
-    def create_starting_servers(self):
-        """
-        Initialise the servers
-        """
+    def create_starting_servers(self) -> List[Server]:
+        """Initialise the servers at this node."""
         return [Server(self, i + 1, Decimal("0.0")) for i in range(self.c)]
 
-    def increment_time(self, original, increment):
-        """
-        Increments the original time by the increment
-        """
+    def increment_time(self, original, increment) -> Decimal:
+        """Increment the original time by the increment."""
         return Decimal(str(original)) + Decimal(str(increment))
 
-    def get_service_time(self, ind):
-        """
-        Returns a service time for the given customer class
-        """
+    def get_service_time(self, ind) -> Decimal:
+        """Return a service time for the given customer class."""
         return Decimal(
             str(
                 self.simulation.service_times[self.id_number][
@@ -44,21 +39,25 @@ def get_service_time(self, ind):
 
 
 class ExactArrivalNode(ArrivalNode):
-    """
+    """Node with exact numerical time precision.
+
     Inherits from the ArrivalNode class, implements a
     more precise version of addition to fix discrepencies
     with floating point numbers.
     """
 
-    def increment_time(self, original, increment):
-        """
-        Increments the original time by the increment
-        """
+    def increment_time(self, original, increment) -> Decimal:
+        """Increment the original time by the increment."""
         return Decimal(str(original)) + Decimal(str(increment))
 
-    def inter_arrival(self, nd, clss):
-        """
-        Samples the inter-arrival time for next class and node.
+    def inter_arrival(self, nd, clss) -> Decimal:
+        """Samples the inter-arrival time for next class and node.
+
+        Parameters
+        ----------
+        nd (Node): Next node.
+        clss (Individual): Individual class to be selected next.
+
         """
         return Decimal(
             str(

ciw/exit_node.py

@@ -1,12 +1,8 @@
-class ExitNode(object):
-    """
-    Class for the exit node on our network.
-    """
+class ExitNode:
+    """Exit node on our network."""
 
     def __init__(self):
-        """
-        Initialise the exit node.
-        """
+        """Initialise the exit node."""
         self.all_individuals = []
         self.number_of_individuals = 0
         self.number_of_completed_individuals = 0
@@ -25,6 +21,7 @@ def accept(self, next_individual, completed=True):
         Adds individual to the list of completed individuals.
         """
         self.all_individuals.append(next_individual)
+        next_individual.node = -1
         self.number_of_individuals += 1
         if completed:
             self.number_of_completed_individuals += 1

ciw/import_params.py

@@ -1,5 +1,3 @@
-import copy
-import types
 import ciw.dists
 from .network import *
 from .schedules import *
@@ -75,10 +73,9 @@ def create_network_from_dictionary(params_input):
     params = fill_out_dictionary(params_input)
     validify_dictionary(params)
     # Then make the Network object
-    number_of_classes = params["number_of_classes"]
     number_of_nodes = params["number_of_nodes"]
     if isinstance(params["priority_classes"], dict):
-        preempt_priorities = [False for _ in range(number_of_nodes)]
+        preempt_priorities = [False] * number_of_nodes
     if isinstance(params["priority_classes"], tuple):
         preempt_priorities = params["priority_classes"][1]
         params["priority_classes"] = {
@@ -87,16 +84,15 @@ def create_network_from_dictionary(params_input):
         }
     class_change_matrices = params.get(
         "class_change_matrices",
-        [None for nd in range(number_of_nodes)],
+        [None] * number_of_nodes,
     )
     class_change_time_distributions = {clss2: {clss1: None for clss1 in params['customer_class_names']} for clss2 in params['customer_class_names']}
     if 'class_change_time_distributions' in params:
         for clss1 in params['customer_class_names']:
-            for clss2 in params['customer_class_names']:
-                try:
-                    class_change_time_distributions[clss1][clss2] = params['class_change_time_distributions'][clss1][clss2]
-                except:
-                    pass
+            if clss1 in params['class_change_time_distributions']:
+                for clss2 in params['customer_class_names']:
+                    if clss2 in params['class_change_time_distributions'][clss1]:
+                        class_change_time_distributions[clss1][clss2] = params['class_change_time_distributions'][clss1][clss2]
 
     nodes, classes = [], {}
     for nd in range(number_of_nodes):
@@ -165,28 +161,27 @@ def fill_out_dictionary(params):
     class_names = sorted(params["arrival_distributions"].keys())
     params["customer_class_names"] = class_names
 
+    number_of_nodes = len(params["number_of_servers"])
     default_dict = {
         "name": "Simulation",
         "routing": {class_name: routing.TransitionMatrix(transition_matrix=[[0.0]]) for class_name in class_names},
-        "number_of_nodes": len(params["number_of_servers"]),
+        "number_of_nodes": number_of_nodes,
         "number_of_classes": len(class_names),
-        "queue_capacities": [float("inf") for _ in range(len(params["number_of_servers"]))],
+        "queue_capacities": [float("inf")] * number_of_nodes, 
         "priority_classes": {class_name: 0 for class_name in class_names},
-        "baulking_functions": {class_name: [None for _ in range(len(params["number_of_servers"]))]for class_name in class_names},
+        "baulking_functions": {class_name: [None] * number_of_nodes for class_name in class_names},
         "batching_distributions": {class_name: [
-                ciw.dists.Deterministic(1) for _ in range(len(params["number_of_servers"]))
-            ] for class_name in class_names},
-        "ps_thresholds": [1 for _ in range(len(params["number_of_servers"]))],
+                ciw.dists.Deterministic(1)
+        ] * number_of_nodes for class_name in class_names},
+        "ps_thresholds": [1] * number_of_nodes,
         "server_priority_functions": [
-            None for _ in range(len(params["number_of_servers"]))
-        ],
+            None
+        ] * number_of_nodes,
         "reneging_time_distributions": {
-            class_name: [None for _ in range(len(params["number_of_servers"]))]
+            class_name: [None] * number_of_nodes
             for class_name in class_names
         },
-        "service_disciplines": [
-            ciw.disciplines.FIFO for _ in range(len(params["number_of_servers"]))
-        ],
+        "service_disciplines": [ciw.disciplines.FIFO for _ in range(number_of_nodes)],
         "system_capacity": float('inf')
     }
 

ciw/node.py

@@ -871,6 +871,46 @@ def write_individual_record(self, individual):
         )
         individual.data_records.append(record)
 
+    def write_incomplete_record(self, individual):
+        """
+        Write an incomplete data record for an individual
+        at the end of the simulation run.
+        """
+        if not individual.service_time:  # Still in queue
+            service_start_date = None
+            waiting_time = None
+            service_time = None
+            service_end_date = None
+        else:
+            service_start_date = individual.service_start_date
+            waiting_time = individual.service_start_date - individual.arrival_date
+            if individual.service_end_date > self.now: # Still in service
+                service_time = None
+                service_end_date = None
+            else: # Still blocked
+                service_time = individual.service_time
+                service_end_date = individual.service_end_date
+
+        record = DataRecord(
+            id_number=individual.id_number,
+            customer_class=individual.previous_class,
+            original_customer_class=individual.original_class,
+            node=self.id_number,
+            arrival_date=individual.arrival_date,
+            waiting_time=waiting_time,
+            service_start_date=service_start_date,
+            service_time=service_time,
+            service_end_date=service_end_date,
+            time_blocked=None,
+            exit_date=None,
+            destination=None,
+            queue_size_at_arrival=individual.queue_size_at_arrival,
+            queue_size_at_departure=None,
+            server_id=False,
+            record_type="incomplete",
+        )
+        return record
+
     def write_interruption_record(self, individual, destination=nan):
         """
         Write a data record for an individual when being interrupted.