most-queue 1.45__tar.gz → 1.47__tar.gz

{most_queue-1.45 → most_queue-1.47}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: most_queue
-Version: 1.45
+Version: 1.47
 Summary: Software package for calculation and simulation of queuing systems
 Home-page: https://github.com/xabarov/most-queue
 Author: Xabarov Roman
@@ -31,8 +31,11 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
 
-# MostQueue
+# Queueing systems. Simulation and numerical methods of queuing theory
 
 ![Queue](assets/queue6.jpg)
 

{most_queue-1.45 → most_queue-1.47}/README.md

@@ -1,4 +1,4 @@
-# MostQueue
+# Queueing systems. Simulation and numerical methods of queuing theory
 
 ![Queue](assets/queue6.jpg)
 

{most_queue-1.45 → most_queue-1.47}/most_queue/sim/batch_sim.py

@@ -1,5 +1,5 @@
 """
-QS with batch arrival
+Queueing system with batch arrivals.
 """
 import numpy as np
 
@@ -8,17 +8,17 @@ from most_queue.sim.qs_sim import QueueingSystemSimulator, Task
 
 class QueueingSystemBatchSim(QueueingSystemSimulator):
     """
-    QS with batch arrivals
+    Queueing system with batch arrivals.
     """
 
     def __init__(self, num_of_channels,
                  batch_prob,
                  buffer=None, verbose=True):
         """
-        Args:
-            num_of_channels: 
-            batch_prob: list[float], probs of batch size 1, 2, .. len(batch_probs)
-            buffer: Optional(int, None) : length of queueu
+        :param num_of_channels: int : number of channels (servers)
+        :param batch_prob: list : probabilities for different batch sizes
+        :param buffer: Optional(int, None) : length of queueu
+        :param verbose: bool : if True prints info about simulation process
         """
         super().__init__(num_of_channels, buffer, verbose)
 
@@ -52,7 +52,7 @@ class QueueingSystemBatchSim(QueueingSystemSimulator):
 
         self.arrival_time = self.ttek + self.source.generate()
 
-        for tsk in range(batch_size):
+        for _tsk in range(batch_size):
             self.arrived += 1
             self.p[self.in_sys] += self.arrival_time - self.t_old
 
@@ -89,5 +89,5 @@ class QueueingSystemBatchSim(QueueingSystemSimulator):
                         # Проверям, не наступил ли ПНЗ:
                         if self.free_channels == 0:
                             if self.in_sys == self.n:
-                                self.start_ppnz = self.ttek
+                                self.start_busy = self.ttek
                         break

{most_queue-1.45 → most_queue-1.47}/most_queue/sim/fj_delta_sim.py

@@ -12,13 +12,16 @@ class ForkJoinSimDelta(ForkJoinSim):
     Имитационная модель СМО Fork-Join, Split-Join
     """
 
-    def __init__(self, num_of_channels, num_of_parts, delta, is_SJ=False, buffer=None):
+    def __init__(self, num_of_channels, num_of_parts, delta, is_sj=False, buffer=None):
         """
-        num_of_channels - количество каналов СМО
-        buffer - максимальная длина очереди
+        :param num_of_channels: int : количество каналов СМО
+        :param num_of_parts: int : количество частей на которые разбивается задача
+        :param delta: float : параметр модели Fork-Join с дельта-разбиением
+        :param is_sj: bool : если True, то используется модель Split-Join, иначе - Fork-Join
+        :param buffer: Optional(int, None) : максимальная длина очереди
         """
         ForkJoinSim.__init__(self, num_of_channels,
-                             num_of_parts, is_SJ, buffer)
+                             num_of_parts, is_sj, buffer)
         self.delta = delta
         self.subtask_arr_queue = []
         self.serv_task_id = -1
@@ -26,7 +29,7 @@ class ForkJoinSimDelta(ForkJoinSim):
 
     def task_arrival(self):
         """
-            Действия по прибытию заявки в СМО.
+        Действия по прибытию заявки в СМО.
         """
 
         self.arrived += 1
@@ -37,7 +40,7 @@ class ForkJoinSimDelta(ForkJoinSim):
         is_dropped = False
 
         if self.buffer:  # ограниченная длина очереди
-            if not self.is_SJ:
+            if not self.is_sj:
                 if self.queue.size() + self.k - 1 > self.buffer + self.free_channels:
                     self.dropped += 1
                     is_dropped = True
@@ -54,7 +57,7 @@ class ForkJoinSimDelta(ForkJoinSim):
             self.in_sys += 1
             self.sub_task_in_sys += 1
 
-            if not self.is_SJ:  # Fork-Join discipline
+            if not self.is_sj:  # Fork-Join discipline
 
                 if self.free_channels == 0:
                     self.queue.append(t.subtasks[0])
@@ -85,6 +88,9 @@ class ForkJoinSimDelta(ForkJoinSim):
                 self.subtask_arr_queue.append(t.subtasks[i])
 
     def subtask_arrival(self, subtask_num):
+        """
+        Действия по прибытию подзадачи в СМО.
+        """
 
         subtsk = self.subtask_arr_queue.pop(subtask_num)
         self.p[self.in_sys] += subtsk.future_arr_time - self.t_old
@@ -99,7 +105,7 @@ class ForkJoinSimDelta(ForkJoinSim):
         if not is_dropped:
             self.sub_task_in_sys += 1
 
-            if not self.is_SJ:  # Fork-Join discipline
+            if not self.is_sj:  # Fork-Join discipline
 
                 if self.free_channels == 0:
                     self.queue.append(subtsk)
@@ -136,7 +142,7 @@ class ForkJoinSimDelta(ForkJoinSim):
         self.total += 1
         self.free_channels += 1
 
-        if not self.is_SJ:
+        if not self.is_sj:
 
             if self.served_subtask_in_task[end_ts.task_id] == self.k:
                 self.served += 1
@@ -186,6 +192,9 @@ class ForkJoinSimDelta(ForkJoinSim):
                         q for q in self.queue.queue if q.task_id != end_ts.task_id]
 
     def run_one_step(self):
+        """
+        Runs one step of simulation.
+        """
 
         num_of_server_earlier = -1
         serv_earl = 1e10
@@ -198,9 +207,9 @@ class ForkJoinSimDelta(ForkJoinSim):
         subtask_arr_time_earl = 1e10
         num_of_subtask_earl = -1
 
-        for c in range(len(self.subtask_arr_queue)):
-            if self.subtask_arr_queue[c].future_arr_time < subtask_arr_time_earl:
-                subtask_arr_time_earl = self.subtask_arr_queue[c].future_arr_time
+        for c, subtask in enumerate(self.subtask_arr_queue):
+            if subtask.future_arr_time < subtask_arr_time_earl:
+                subtask_arr_time_earl = subtask.future_arr_time
                 num_of_subtask_earl = c
 
         is_task_arr = False
@@ -219,37 +228,42 @@ class ForkJoinSimDelta(ForkJoinSim):
             self.serving(num_of_server_earlier)
 
     def __str__(self, is_short=False):
+        """
+        Returns string representation of the system
+         :param is_short: bool : if True returns short version of string
+         :return: str : string representation of the system
+        """
 
         res = "Queueing system " + self.source_types + \
             "/" + self.server_types + "/" + str(self.n)
-        if self.buffer != None:
+        if self.buffer is not None:
             res += "/" + str(self.buffer)
-        if self.is_SJ:
+        if self.is_sj:
             res += '| Split-Join'
         else:
             res += '| Fork-Join'
 
         res += "\n"
         # res += "Load: " + "{0:4.3f}".format(self.calc_load()) + "\n"
-        res += "Current Time " + "{0:8.3f}".format(self.ttek) + "\n"
-        res += "Arrival Time: " + "{0:8.3f}".format(self.arrival_time) + "\n"
+        res += f"Current Time {self.ttek:8.3f}\n"
+        res += f"Arrival Time: {self.arrival_time:8.3f}\n"
 
         res += "Sojourn moments:\n"
         for i in range(3):
-            res += "\t" + "{0:8.4f}".format(self.v[i])
+            res += f"\t{self.v[i]:8.4f}"
         res += "\n"
 
         if not is_short:
             res += "Stationary prob:\n"
             res += "\t"
             for i in range(10):
-                res += "{0:6.5f}".format(self.p[i] / self.ttek) + "   "
+                res += f"{self.p[i] / self.ttek:6.5f}   "
             res += "\n"
-            res += "Arrived: " + str(self.arrived) + "\n"
-            if self.buffer != None:
-                res += "Dropped: " + str(self.dropped) + "\n"
-            res += "Served: " + str(self.served) + "\n"
-            res += "In System:" + str(self.in_sys) + "\n"
+            res += f"Arrived: {self.arrived}\n"
+            if self.buffer is not None:
+                res += f"Dropped: {self.dropped}\n"
+            res += f"Served: {self.served}\n"
+            res += f"In System: {self.in_sys}\n"
 
             for c in range(self.n):
                 res += str(self.servers[c])

{most_queue-1.45 → most_queue-1.47}/most_queue/sim/fj_sim.py

@@ -2,7 +2,6 @@
 ForkJoin Queue
 """
 import math
-import sys
 
 from colorama import Fore, Style, init
 from tqdm import tqdm
@@ -15,35 +14,39 @@ init()
 
 class ForkJoinSim(QueueingSystemSimulator):
     """
-    Имитационная модель СМО Fork-Join, Split-Join
+    Simulation of a ForkJoin Queueing System (Fork-Join, Split-Join)
     """
 
-    def __init__(self, num_of_channels, k, is_SJ=False, is_Purge=False, buffer=None):
+    def __init__(self, num_of_channels, k, is_sj=False, is_purge=False, buffer=None):
         """
-        num_of_channels - количество каналов СМО
-        buffer - максимальная длина очереди
+        :param num_of_channels: int : number of channels in the system
+        :param k: int : number of parts a task is split into
+        :param is_sj: bool : if True, then Split-Join model is used, otherwise Fork-Join model is used
+        :param buffer: Optional(int, None) : maximum length of the queue
+        :param is_purge: bool : if True, then Purge model is used
+
         """
         QueueingSystemSimulator.__init__(self, num_of_channels, buffer)
         self.k = k
-        self.is_SJ = is_SJ
-        self.is_Purge = is_Purge
+        self.is_sj = is_sj
+        self.is_purge = is_purge
         self.served_subtask_in_task = {}
         self.sub_task_in_sys = 0
 
         self.queues = []
-        for i in range(num_of_channels):
+        for _ in range(num_of_channels):
             self.queues.append([])
 
     def calc_load(self):
         """
-        вычисляет коэффициент загрузки СМО
+        calculates the load of the system.
         """
 
         pass
 
     def arrival(self):
         """
-        Действия по прибытию заявки в СМО.
+        action on arrival of a task in the system.
         """
 
         self.arrived += 1
@@ -55,7 +58,7 @@ class ForkJoinSim(QueueingSystemSimulator):
         is_dropped = False
 
         if self.buffer:  # ограниченная длина очереди
-            if not self.is_SJ:
+            if not self.is_sj:
 
                 if self.queue.size() + self.k - 1 > self.buffer + self.free_channels:
                     self.dropped += 1
@@ -71,7 +74,7 @@ class ForkJoinSim(QueueingSystemSimulator):
             self.in_sys += 1
             self.sub_task_in_sys += self.n
 
-            if not self.is_SJ:  # Fork-Join discipline
+            if not self.is_sj:  # Fork-Join discipline
 
                 for i in range(self.n):
                     if self.free_channels == 0:
@@ -96,8 +99,8 @@ class ForkJoinSim(QueueingSystemSimulator):
 
     def serving(self, c):
         """
-        Дейтсвия по поступлению заявки на обслуживание
-        с - номер канала
+        Action when a service is completed on channel c.
+        :param c: int : number of channel where service is completed.
         """
         time_to_end = self.servers[c].time_to_end_service
         self.p[self.in_sys] += time_to_end - self.t_old
@@ -109,11 +112,11 @@ class ForkJoinSim(QueueingSystemSimulator):
         self.free_channels += 1
         self.sub_task_in_sys -= 1
 
-        if not self.is_SJ:
+        if not self.is_sj:
 
             if self.served_subtask_in_task[end_ts.task_id] == self.k:
 
-                if self.is_Purge:
+                if self.is_purge:
                     # найти все остальные подзадачи в СМО и выкинуть
                     task_id = end_ts.task_id
                     for i in range(self.n):
@@ -147,6 +150,11 @@ class ForkJoinSim(QueueingSystemSimulator):
                         self.free_channels -= 1
 
     def run_one_step(self):
+        """
+        Run one step of the simulation.
+         If there is an arrival before the earliest service completion time,
+         then process the arrival. Otherwise, process the earliest service completion.
+        """
 
         num_of_server_earlier = -1
         serv_earl = 1e10
@@ -164,12 +172,15 @@ class ForkJoinSim(QueueingSystemSimulator):
             self.serving(num_of_server_earlier)
 
     def run(self, total_served, is_real_served=True):
+        """
+        Run simulation until total_served tasks are served.
+        """
 
         if is_real_served:
-            
+
             last_percent = 0
 
-            with tqdm(total=100, unit='jobs') as pbar:
+            with tqdm(total=100) as pbar:
                 while self.served < total_served:
                     self.run_one_step()
                     percent = int(100*(self.served/total_served))
@@ -178,7 +189,7 @@ class ForkJoinSim(QueueingSystemSimulator):
                         pbar.update(1)
                         pbar.set_description(Fore.MAGENTA + '\rJob served: ' +
                                              Fore.YELLOW + f'{self.served}/{total_served}' + Fore.LIGHTGREEN_EX)
-                        
+
         else:
             print(Fore.GREEN + '\rStart simulation')
             print(Style.RESET_ALL)
@@ -197,8 +208,7 @@ class ForkJoinSim(QueueingSystemSimulator):
 
     def get_p(self):
         """
-        Возвращает список с вероятностями состояний СМО
-        p[j] - вероятность того, что в СМО в случайный момент времени будет ровно j заявок
+        Get probabilities of states for Fork-Join model
         """
         res = [0.0] * len(self.p)
         for j in range(0, self.num_of_states):
@@ -206,37 +216,42 @@ class ForkJoinSim(QueueingSystemSimulator):
         return res
 
     def __str__(self, is_short=False):
+        """
+        Prints the model of the queueing system
+        :param is_short: bool : if True, then short information about the model of the queueing system is returned
+        :return: str : string representation of the model of the queueing system
+        """
 
         res = "Queueing system " + self.source_types + \
             "/" + self.server_types + "/" + str(self.n)
-        if self.buffer != None:
+        if self.buffer is not None:
             res += "/" + str(self.buffer)
-        if self.is_SJ:
+        if self.is_sj:
             res += '| Split-Join'
         else:
             res += '| Fork-Join'
 
         res += "\n"
         # res += "Load: " + "{0:4.3f}".format(self.calc_load()) + "\n"
-        res += "Current Time " + "{0:8.3f}".format(self.ttek) + "\n"
-        res += "Arrival Time: " + "{0:8.3f}".format(self.arrival_time) + "\n"
+        res += f"Current Time {self.ttek:8.3f}\n"
+        res += f"Arrival Time: {self.arrival_time:8.3f}\n"
 
         res += "Sojourn moments:\n"
         for i in range(3):
-            res += "\t" + "{0:8.4f}".format(self.v[i])
+            res += f"\t{self.v[i]:8.4f}"
         res += "\n"
 
         if not is_short:
             res += "Stationary prob:\n"
             res += "\t"
             for i in range(10):
-                res += "{0:6.5f}".format(self.p[i] / self.ttek) + "   "
+                res += f"{self.p[i] / self.ttek:6.5f}   "
             res += "\n"
-            res += "Arrived: " + str(self.arrived) + "\n"
-            if self.buffer != None:
-                res += "Dropped: " + str(self.dropped) + "\n"
-            res += "Served: " + str(self.served) + "\n"
-            res += "In System:" + str(self.in_sys) + "\n"
+            res += f"Arrived: {self.arrived}\n"
+            if self.buffer is not None:
+                res += f"Dropped: {self.dropped}\n"
+            res += f"Served: {self.served}\n"
+            res += f"In System: {self.in_sys}\n"
 
             for c in range(self.n):
                 res += str(self.servers[c])

{most_queue-1.45 → most_queue-1.47}/most_queue/sim/impatient_queue_sim.py

@@ -1,38 +1,65 @@
-from most_queue.sim.utils.distribution_utils import create_distribution
-from most_queue.sim.qs_sim import QueueingSystemSimulator, Task
+"""
+Simulation model for queueing systems with impatient tasks
+"""
+from colorama import Fore, Style, init
 
+from most_queue.sim.qs_sim import QueueingSystemSimulator
+from most_queue.sim.utils.distribution_utils import create_distribution
+from most_queue.sim.utils.tasks import ImpatientTask
 
-class ImpatientTask(Task):
-    def __init__(self, arr_time, moment_to_leave):
-        super().__init__(arr_time)
-        self.moment_to_leave = moment_to_leave
+init()
 
-    def __str__(self):
-        return f'Task # {self.id}\nArrival moment: {self.arr_time:8.3f}\nMoment to leave: {self.moment_to_leave:8.3f}'
+class ImpatientQueueSim(QueueingSystemSimulator):
+    """
+    Queueing system with impatient tasks
 
+    """
 
-class ImpatientQueueSim(QueueingSystemSimulator):
     def __init__(self, num_of_channels, buffer=None, verbose=True):
+        """
+        :param num_of_channels: int
+            Number of channels in the system.
+        :param buffer: int or None
+            Buffer size. If None, then infinite buffer.
+        :param verbose: bool
+            If True, then print information about simulation process.
+
+        To start the simulation, you need to:
+        - call the constructor with parameters
+        - set the input arrival distribution using the set_sorces() method
+        - set the service distribution using the set_servers() method
+        - set the impatience distribution using the set_impatience() method
+        - start the simulation using the run() method
+        to which you need to pass the number of job required for servicing
+
+        See supported distributions params in the README.md file or use
+            ``` 
+            from most_queue.sim.utils.distribution_utils import print_supported_distributions
+            print_supported_distributions()
+            ```
+
+        """
         super().__init__(num_of_channels, buffer, verbose)
 
         self.impatience_params = None
         self.impatience_types = None
-        
+
         self.impatience = None
         self.is_set_impatience_params = False
 
-    def set_impatiens(self, params, types):
+    def set_impatience(self, params, types):
         """
-        Задает тип и параметры распределения интервала нетерпения заявок.
-        Вид распределения                   Тип[types]     Параметры [params]
-        Экспоненциальное                      'М'             [mu]
-        Гиперэкспоненциальное 2-го порядка    'Н'         [y1, mu1, mu2]
-        Гамма-распределение                   'Gamma'       [mu, alpha]
-        Эрланга                               'E'           [r, mu]
-        Кокса 2-го порядка                    'C'         [y1, mu1, mu2]
-        Парето                                'Pa'         [alpha, K]
-        Детерминированное                      'D'         [b]
-        Равномерное                         'Uniform'     [mean, half_interval]
+        set impatience parameters and types
+        :param params: list
+            List of lists with parameters for each type of impatience.
+        :param types: list
+            List of strings with types of impatience.
+
+        See supported distributions params in the README.md file or use
+            ``` 
+            from most_queue.sim.utils.distribution_utils import print_supported_distributions
+            print_supported_distributions()
+            ```
         """
         self.impatience_params = params
         self.impatience_types = types
@@ -43,7 +70,7 @@ class ImpatientQueueSim(QueueingSystemSimulator):
 
     def arrival(self):
         """
-        Действия по прибытию заявки в СМО.
+        Actions on arrival of a task.
         """
 
         self.arrived += 1
@@ -57,7 +84,7 @@ class ImpatientQueueSim(QueueingSystemSimulator):
         moment_to_leave = self.ttek + self.impatience.generate()
 
         if self.free_channels == 0:
-            if self.buffer == None:  # не задана длина очереди, т.е бесконечная очередь
+            if self.buffer is None:  # не задана длина очереди, т.е бесконечная очередь
                 new_tsk = ImpatientTask(self.ttek, moment_to_leave)
                 new_tsk.start_waiting_time = self.ttek
                 self.queue.append(new_tsk)
@@ -87,14 +114,18 @@ class ImpatientQueueSim(QueueingSystemSimulator):
                     # Проверям, не наступил ли ПНЗ:
                     if self.free_channels == 0:
                         if self.in_sys == self.n:
-                            self.start_ppnz = self.ttek
+                            self.start_busy = self.ttek
                     break
 
-    def drop_task(self, num_of_task_in_queue, moment_to_leave_earlier):
+    def drop_task(self, num_of_task_earlier, moment_to_leave_earlier):
+        """
+        Drop a task from the queue and update statistics.
+        """
         self.ttek = moment_to_leave_earlier
         new_queue = []
+        end_ts = None
         for i, tsk in enumerate(self.queue.queue):
-            if i != num_of_task_in_queue:
+            if i != num_of_task_earlier:
                 new_queue.append(tsk)
             else:
                 end_ts = self.queue.queue[i]
@@ -103,11 +134,16 @@ class ImpatientQueueSim(QueueingSystemSimulator):
         self.in_sys -= 1
         self.dropped += 1
         self.served += 1
-        self.refresh_v_stat(self.ttek - end_ts.arr_time)
-        end_ts.wait_time = self.ttek - end_ts.arr_time
-        self.refresh_w_stat(end_ts.wait_time)
+        
+        if end_ts is not None:
+            self.refresh_v_stat(self.ttek - end_ts.arr_time)
+            end_ts.wait_time = self.ttek - end_ts.arr_time
+            self.refresh_w_stat(end_ts.wait_time)
 
     def run_one_step(self):
+        """
+        Run one step of the simulation.
+        """
 
         num_of_server_earlier = -1
         serv_earl = 1e10
@@ -138,6 +174,11 @@ class ImpatientQueueSim(QueueingSystemSimulator):
                 self.drop_task(num_of_task_earlier, moment_to_leave_earlier)
 
     def __str__(self, is_short=False):
+        """
+        Returns a string representation of the system.
+         If `is_short` is True, it returns a short version of the string.
+         Otherwise, it returns a detailed version of the string.
+        """
         super().__str__(is_short)
         num_of_task_earlier = -1
         moment_to_leave_earlier = 1e10
@@ -145,4 +186,4 @@ class ImpatientQueueSim(QueueingSystemSimulator):
             if tsk.moment_to_leave < moment_to_leave_earlier:
                 moment_to_leave_earlier = tsk.moment_to_leave
                 num_of_task_earlier = i
-        return f'Task {num_of_task_earlier} is earlier to leave at {moment_to_leave_earlier:8.3f}'
+        return f'{Fore.GREEN}Task {num_of_task_earlier}{Style.RESET_ALL} is earlier to leave at {Fore.YELLOW}{moment_to_leave_earlier:8.3f}{Style.RESET_ALL}'