clean up some code formatting

Author: geraintpalmer

ciw/__init__.py

@@ -17,4 +17,5 @@
 import ciw.deadlock
 import ciw.trackers
 import ciw.disciplines
-rng = np.random.default_rng()
+
+rng = np.random.default_rng()

ciw/arrival_node.py

@@ -6,6 +6,7 @@ class ArrivalNode(object):
     """
     Class for the arrival node of the network
     """
+
     def __init__(self, simulation):
         """
         Initialise the arrvial node.
@@ -15,9 +16,10 @@ def __init__(self, simulation):
         self.number_of_individuals_per_class = [0] * self.simulation.network.number_of_classes
         self.number_accepted_individuals = 0
         self.number_accepted_individuals_per_class = [0] * self.simulation.network.number_of_classes
-        self.event_dates_dict = {nd + 1: {clss: False for clss in range(
-            self.simulation.network.number_of_classes)}
-            for nd in range(self.simulation.network.number_of_nodes)}
+        self.event_dates_dict = {
+            nd + 1: {clss: False for clss in range(self.simulation.network.number_of_classes)
+            } for nd in range(self.simulation.network.number_of_nodes)
+        }
 
     def initialise(self):
         self.initialise_event_dates_dict()
@@ -27,7 +29,7 @@ def __repr__(self):
         """
         Representation of an arrival node.
         """
-        return 'Arrival Node'
+        return "Arrival Node"
 
     def decide_baulk(self, next_node, next_individual):
         """
@@ -38,8 +40,7 @@ def decide_baulk(self, next_node, next_individual):
             self.send_individual(next_node, next_individual)
         else:
             rnd_num = random()
-            if rnd_num < next_node.baulking_functions[self.next_class](
-                next_node.number_of_individuals):
+            if rnd_num < next_node.baulking_functions[self.next_class](next_node.number_of_individuals):
                 self.record_baulk(next_node, next_individual)
                 self.simulation.nodes[-1].accept(next_individual, completed=False)
             else:
@@ -71,24 +72,22 @@ def have_event(self):
         for _ in range(batch):
             self.number_of_individuals += 1
             self.number_of_individuals_per_class[self.next_class] += 1
-            priority_class = self.simulation.network.priority_class_mapping[
-                self.next_class]
+            priority_class = self.simulation.network.priority_class_mapping[self.next_class]
             next_individual = self.simulation.IndividualType(
                 self.number_of_individuals,
                 self.next_class,
                 priority_class,
-                simulation=self.simulation)
+                simulation=self.simulation,
+            )
             if self.simulation.network.process_based:
-                next_individual.route = self.simulation.network.customer_classes[
-                next_individual.customer_class].routing[self.next_node - 1](next_individual)
+                next_individual.route = self.simulation.network.customer_classes[next_individual.customer_class].routing[self.next_node - 1](next_individual)
             next_node = self.simulation.transitive_nodes[self.next_node - 1]
             self.release_individual(next_node, next_individual)
 
-        self.event_dates_dict[self.next_node][
-            self.next_class] = self.increment_time(
-            self.event_dates_dict[self.next_node][
-            self.next_class], self.inter_arrival(
-            self.next_node, self.next_class))
+        self.event_dates_dict[self.next_node][self.next_class] = self.increment_time(
+            self.event_dates_dict[self.next_node][self.next_class],
+            self.inter_arrival(self.next_node, self.next_class),
+        )
         self.find_next_event_date()
 
     def increment_time(self, original, increment):
@@ -107,7 +106,7 @@ def initialise_event_dates_dict(self):
                 if self.simulation.inter_arrival_times[nd][clss] is not None:
                     self.event_dates_dict[nd][clss] = self.inter_arrival(nd, clss)
                 else:
-                    self.event_dates_dict[nd][clss] = float('inf')
+                    self.event_dates_dict[nd][clss] = float("inf")
 
     def inter_arrival(self, nd, clss):
         """
@@ -123,19 +122,19 @@ def batch_size(self, nd, clss):
         batch = self.simulation.batch_sizes[nd][clss]._sample(t=self.simulation.current_time)
         if isinstance(batch, int) and batch >= 0:
             return batch
-        raise ValueError('Batch sizes must be positive integers.')
+        raise ValueError("Batch sizes must be positive integers.")
 
     def record_baulk(self, next_node, individual):
         """
         Adds an individual to the baulked dictionary.
         """
-        next_node.write_baulking_or_rejection_record(individual, record_type='baulk')
+        next_node.write_baulking_or_rejection_record(individual, record_type="baulk")
 
     def record_rejection(self, next_node, individual):
         """
         Adds an individual to the rejection dictionary.
         """
-        next_node.write_baulking_or_rejection_record(individual, record_type='rejection')
+        next_node.write_baulking_or_rejection_record(individual, record_type="rejection")
 
     def release_individual(self, next_node, next_individual):
         """

ciw/auxiliary.py

@@ -2,61 +2,66 @@
 import numpy as np
 import ciw
 
+
 def seed(z):
-	"""
-	Sets all seeds used to generate random number streams.
-	Currently contains:
-		- random library
-		- numpy random
-	"""
-	random.seed(z)
-	ciw.rng = np.random.default_rng(seed=z)
+    """
+    Sets all seeds used to generate random number streams.
+    Currently contains:
+            - random library
+            - numpy random
+    """
+    random.seed(z)
+    ciw.rng = np.random.default_rng(seed=z)
+
 
 def random_choice(array, probs=None):
-	"""
-	This function takes in an array of values to make a choice from,
-	and an pdf corresponding to those values. It returns a random choice
-	from that array, using the probs as weights.
-	"""
-	# If no pdf provided, assume uniform dist:
-	if probs == None:
-		index = int(random.random() * len(array))
-		return array[index]
-
-	# A common case, guaranteed to reach the Exit node;
-	# No need to sample for this:
-	if (set(probs[:-1]) == set([0.0])) and (probs[-1] == 1.0):
-		return array[-1]
-
-	# Sample a random value from using pdf
-	rdm_num = random.random()
-	i, p = 0, probs[0]
-	while rdm_num > p:
-		i += 1
-		p += probs[i]
-	return array[i]
+    """
+    This function takes in an array of values to make a choice from,
+    and an pdf corresponding to those values. It returns a random choice
+    from that array, using the probs as weights.
+    """
+    # If no pdf provided, assume uniform dist:
+    if probs == None:
+        index = int(random.random() * len(array))
+        return array[index]
+
+    # A common case, guaranteed to reach the Exit node;
+    # No need to sample for this:
+    if (set(probs[:-1]) == set([0.0])) and (probs[-1] == 1.0):
+        return array[-1]
+
+    # Sample a random value from using pdf
+    rdm_num = random.random()
+    i, p = 0, probs[0]
+    while rdm_num > p:
+        i += 1
+        p += probs[i]
+    return array[i]
+
 
 def truncated_normal(mean, sd):
-	"""
-	Sample from a Normal distribution, with mean and standard
-	deviation (sd). This truncates the distribution at 0 (lower bound
-	of 0). If samples less than 0 are sampled, they are resampled
+    """
+        Sample from a Normal distribution, with mean and standard
+        deviation (sd). This truncates the distribution at 0 (lower bound
+        of 0). If samples less than 0 are sampled, they are resampled
     until a positive value is sampled.
-	"""
-	sample = random.normalvariate(mean, sd)
-	while sample <= 0.0:
-		sample = random.normalvariate(mean, sd)
-	return sample
+    """
+    sample = random.normalvariate(mean, sd)
+    while sample <= 0.0:
+        sample = random.normalvariate(mean, sd)
+    return sample
+
 
 def flatten_list(list_of_lists):
-	flat = []
-	for a_list in list_of_lists:
-		flat += a_list
-	return flat
+    flat = []
+    for a_list in list_of_lists:
+        flat += a_list
+    return flat
+
 
 def no_routing(ind):
-	"""
-	Process-based routing fucntion that sends the customer straight
-	to exit node. It is a placeholder for when NoArrivals is used. 
-	"""
-	return []
+    """
+    Process-based routing fucntion that sends the customer straight
+    to exit node. It is a placeholder for when NoArrivals is used.
+    """
+    return []

ciw/data_record.py

@@ -1,20 +1,23 @@
 from collections import namedtuple
 
-DataRecord = namedtuple('Record', [
-    'id_number',
-    'customer_class',
-    'original_customer_class',
-    'node',
-    'arrival_date',
-    'waiting_time',
-    'service_start_date',
-    'service_time',
-    'service_end_date',
-    'time_blocked',
-    'exit_date',
-    'destination',
-    'queue_size_at_arrival',
-    'queue_size_at_departure',
-    'server_id',
-    'record_type'
-    ])
+DataRecord = namedtuple(
+    "Record",
+    [
+        "id_number",
+        "customer_class",
+        "original_customer_class",
+        "node",
+        "arrival_date",
+        "waiting_time",
+        "service_start_date",
+        "service_time",
+        "service_end_date",
+        "time_blocked",
+        "exit_date",
+        "destination",
+        "queue_size_at_arrival",
+        "queue_size_at_departure",
+        "server_id",
+        "record_type",
+    ],
+)

ciw/deadlock/deadlock_detector.py

@@ -1,11 +1,13 @@
 import networkx as nx
 
+
 class NoDetection(object):
     """
     A generic class for all deadlock detector classes to inherit from.
     Using this class is equivalent to having no deadlock detection
     capabilities.
     """
+
     def __init__(self):
         """
         Initialises the detection mechanism class.
@@ -23,7 +25,7 @@ def detect_deadlock(self):
         Returns True is deadlock is reached, False otherwise.
         """
         return False
-    
+
     def action_at_attach_server(self, node, server, individual):
         """
         The action taken at the 'attach_server' method of the node.
@@ -54,6 +56,7 @@ class StateDigraph(NoDetection):
           contains k.
     Deadlock is equivalent to a knot in the directed graph.
     """
+
     def __init__(self):
         """
         Initialises the state digraph detection mechanism class.
@@ -65,7 +68,7 @@ def initialise_at_node(self, node):
         Initialises the state digraph when the node is created.
         Adds the servers of that node if c < Inf.
         """
-        if node.c < float('Inf'):
+        if node.c < float("Inf"):
             self.statedigraph.add_nodes_from([str(s) for s in node.servers])
 
     def detect_deadlock(self):
@@ -103,8 +106,10 @@ def action_at_attach_server(self, node, server, individual):
             it needs to be added back in.
         """
         for blq in node.blocked_queue:
-            inds = [ind for ind in node.simulation.nodes[
-                blq[0]].all_individuals if ind.id_number == blq[1]]
+            inds = [
+                ind for ind in node.simulation.nodes[blq[0]].all_individuals
+                if ind.id_number == blq[1]
+            ]
             ind = inds[0]
             if ind != individual:
                 self.statedigraph.add_edge(str(ind.server), str(server))
@@ -123,8 +128,6 @@ def action_at_detatch_server(self, server):
           - Remove any edges of servers who have been detatched.
         """
         self.statedigraph.remove_edges_from(
-            list(
-                self.statedigraph.in_edges(str(server))
-            ) + list(
-                self.statedigraph.out_edges(str(server)))
-            )
+            list(self.statedigraph.in_edges(str(server)))
+            + list(self.statedigraph.out_edges(str(server)))
+        )

ciw/disciplines/service_distributions.py

@@ -1,22 +1,25 @@
 from ciw.auxiliary import random_choice
 
+
 def FIFO(individuals):
-	"""
-	FIFO: First in first out / First come first served
-	Returns the individual at the head of the queue
-	"""
-	return individuals[0]
+    """
+    FIFO: First in first out / First come first served
+    Returns the individual at the head of the queue
+    """
+    return individuals[0]
+
 
 def SIRO(individuals):
-	"""
-	SIRO: Service in random order
-	Returns a random individual from the queue
-	"""
-	return random_choice(individuals)
+    """
+    SIRO: Service in random order
+    Returns a random individual from the queue
+    """
+    return random_choice(individuals)
+
 
 def LIFO(individuals):
-	"""
-	LIFO: Last in first out / Last come first served
-	Returns the individual who joined the queue most recently
-	"""
-	return individuals[-1]
+    """
+    LIFO: Last in first out / Last come first served
+    Returns the individual who joined the queue most recently
+    """
+    return individuals[-1]