pyworkforce 0.5.0.dev0__tar.gz → 0.5.2__tar.gz

{pyworkforce-0.5.0.dev0 → pyworkforce-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyworkforce
-Version: 0.5.0.dev0
+Version: 0.5.2
 Summary: Common tools for workforce management, schedule and optimization problems
 Home-page: https://github.com/rodrigo-arenas/pyworkforce
 Author: Rodrigo Arenas
@@ -11,69 +11,100 @@ Project-URL: Source Code, https://github.com/rodrigo-arenas/pyworkforce
 Project-URL: Bug Tracker, https://github.com/rodrigo-arenas/pyworkforce/issues
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Requires-Python: >=3.7
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12,<3.15
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: ortools>=9.12.4544
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: joblib>=1.4.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 [![Build Status](https://www.travis-ci.com/rodrigo-arenas/pyworkforce.svg?branch=main)](https://www.travis-ci.com/rodrigo-arenas/pyworkforce)
 [![Codecov](https://codecov.io/gh/rodrigo-arenas/pyworkforce/branch/main/graphs/badge.svg?branch=main&service=github)](https://codecov.io/github/rodrigo-arenas/pyworkforce?branch=main)
 [![PyPI Version](https://badge.fury.io/py/pyworkforce.svg)](https://badge.fury.io/py/pyworkforce)
-[![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9-blue)](https://www.python.org/downloads/)
+[![Python Version](https://img.shields.io/badge/python-3.12%20%7C%203.13%20%7C%203.14-blue)](https://www.python.org/downloads/)
 
 
 # pyworkforce
-Standard tools for workforce management, queuing, scheduling, rostering and optimization problems.
+Tools for workforce management problems such as queue staffing, shift scheduling,
+rostering, and operations research optimization.
 
-Make sure to check the documentation, which is available [here](https://pyworkforce.readthedocs.io/en/stable/)
+The full documentation is available at
+[pyworkforce.readthedocs.io](https://pyworkforce.readthedocs.io/en/stable/).
 
-## Features:
-pyworkforce currently includes:
+## Installation
+
+We recommend installing pyworkforce in a virtual environment:
+
+```bash
+pip install pyworkforce
+```
+
+pyworkforce supports Python 3.12, 3.13, and 3.14.
+
+If you are using Anaconda and run into installation issues, update the environment first:
+
+```bash
+conda update --all
+```
+
+If the issue is related to OR-Tools, check the
+[OR-Tools installation guide](https://github.com/google/or-tools#installation).
+
+For runnable examples, see the
+[examples folder](https://github.com/rodrigo-arenas/pyworkforce/tree/develop/examples).
+
+## What pyworkforce Does
+
+pyworkforce is organized around three planning steps:
 
 ### Queuing
-It solves the following system resource requirements:
+
+Use `pyworkforce.queuing` when you need to estimate how many resources are required
+to handle incoming work, for example calls arriving at a call center. The current
+implementation uses Erlang C assumptions: constant arrival rate, infinite queue,
+and no customer dropout.
 
 ![queue_system](https://raw.githubusercontent.com/rodrigo-arenas/pyworkforce/main/docs/images/erlangc_queue_system.png)
 
-- **queuing.ErlangC:** Find the number of resources required to attend incoming traffic to a constant rate, 
-  infinite queue length, and no dropout.
+- **queuing.ErlangC:** Calculate staffing requirements and performance metrics for one queue scenario.
+- **queuing.MultiErlangC:** Run multiple Erlang C scenarios from a parameter grid.
   
 ### Scheduling
 
-It finds the number of resources to schedule in a shift based on the number of required positions per time interval 
-(found, for example, using  [queuing.ErlangC](./pyworkforce/queuing/erlang.py)), maximum capacity restrictions and static shifts coverage.<br>
-- **scheduling.MinAbsDifference:** This module finds the "optimal" assignation by minimizing the total absolute 
-    differences between required resources per interval against the scheduled resources found by the solver.
-- **scheduling.MinRequiredResources**: This module finds the "optimal" assignation by minimizing the total 
-    weighted amount of scheduled resources (optionally weighted by shift cost), it ensures that in all intervals, there are
-    never fewer resources shifted than the ones required per period.
-
-### Rostering
-
-It assigns a list of resources to a list of required positions per day and shifts; it takes into account
-different restrictions as shift bans, consecutive shifts, resting days, and others.
-It also introduces soft restrictions like shift preferences.
-
-# Usage:
-Install pyworkforce
+Use `pyworkforce.scheduling` when you already know the required resources by time
+interval and need to choose how many people to place on each predefined shift.
 
-It's advised to install pyworkforce using a virtual env, inside the env use:
+- **scheduling.MinAbsDifference:** Minimizes the total absolute difference between required and scheduled resources.
+- **scheduling.MinRequiredResources:** Minimizes the total weighted number of scheduled resources while ensuring every interval is covered.
 
-```
-pip install pyworkforce
-```
+### Rostering
 
-If you are having troubles with or-tools installation, check the [or-tools guide](https://github.com/google/or-tools#installation)
+Use `pyworkforce.rostering` when you have named resources and need to assign them
+to days and shifts while respecting rules such as banned shifts, rest days,
+minimum working hours, and preferences.
 
-For complete list and details of examples go to the 
-[examples folder](https://github.com/rodrigo-arenas/pyworkforce/tree/develop/examples)
+- **rostering.MinHoursRoster:** Builds a resource-level roster that covers shift requirements with the minimum scheduled hours.
 
 ### Queue systems:
 
-A brief introduction can be found in this [medium post](https://medium.com/mlearning-ai/workforce-planning-optimization-using-python-69af0ef9011a)
+A brief introduction can be found in this [medium post](https://towardsdatascience.com/workforce-planning-optimization-using-python-69af0ef9011a)
 
 #### Example:
 
@@ -94,7 +125,8 @@ Output:
                              'waiting_probability': 0.1741319335950498}
 ```
 
-If you want to run different scenarios at the same time, you can use the MultiErlangC, for example, trying different service levels:
+If you want to run several scenarios at the same time, use `MultiErlangC`.
+For example, this tries different service-level targets:
 
 ```python
 from pyworkforce.queuing import MultiErlangC
@@ -135,18 +167,20 @@ Output:
 ```
 ### Scheduling
 
+A brief introduction can be found in this [medium post](https://towardsdatascience.com/how-to-solve-scheduling-problems-in-python-36a9af8de451)
+
 #### Example:
 
 ```python
 from pyworkforce.scheduling import MinAbsDifference, MinRequiredResources
 
-# Rows are the days, each entry of a row, is number of positions required at an hour of the day (24). 
+# Rows are days. Each value is the number of required positions for one hour of the day.
 required_resources = [
     [9, 11, 17, 9, 7, 12, 5, 11, 8, 9, 18, 17, 8, 12, 16, 8, 7, 12, 11, 10, 13, 19, 16, 7],
     [13, 13, 12, 15, 18, 20, 13, 16, 17, 8, 13, 11, 6, 19, 11, 20, 19, 17, 10, 13, 14, 23, 16, 8]
 ]
 
-# Each entry of a shift,an hour of the day (24), 1 if the shift covers that hour, 0 otherwise
+# Each shift has 24 entries, one per hour. Use 1 if the shift covers that hour, otherwise 0.
 shifts_coverage = {"Morning": [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    "Afternoon": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
                    "Night": [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],

{pyworkforce-0.5.0.dev0 → pyworkforce-0.5.2}/README.md

@@ -2,58 +2,73 @@
 [![Build Status](https://www.travis-ci.com/rodrigo-arenas/pyworkforce.svg?branch=main)](https://www.travis-ci.com/rodrigo-arenas/pyworkforce)
 [![Codecov](https://codecov.io/gh/rodrigo-arenas/pyworkforce/branch/main/graphs/badge.svg?branch=main&service=github)](https://codecov.io/github/rodrigo-arenas/pyworkforce?branch=main)
 [![PyPI Version](https://badge.fury.io/py/pyworkforce.svg)](https://badge.fury.io/py/pyworkforce)
-[![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9-blue)](https://www.python.org/downloads/)
-
-
-# pyworkforce
-Standard tools for workforce management, queuing, scheduling, rostering and optimization problems.
-
-Make sure to check the documentation, which is available [here](https://pyworkforce.readthedocs.io/en/stable/)
-
-## Features:
-pyworkforce currently includes:
-
-### Queuing
-It solves the following system resource requirements:
-
-![queue_system](https://raw.githubusercontent.com/rodrigo-arenas/pyworkforce/main/docs/images/erlangc_queue_system.png)
-
-- **queuing.ErlangC:** Find the number of resources required to attend incoming traffic to a constant rate, 
-  infinite queue length, and no dropout.
-  
-### Scheduling
-
-It finds the number of resources to schedule in a shift based on the number of required positions per time interval 
-(found, for example, using  [queuing.ErlangC](./pyworkforce/queuing/erlang.py)), maximum capacity restrictions and static shifts coverage.<br>
-- **scheduling.MinAbsDifference:** This module finds the "optimal" assignation by minimizing the total absolute 
-    differences between required resources per interval against the scheduled resources found by the solver.
-- **scheduling.MinRequiredResources**: This module finds the "optimal" assignation by minimizing the total 
-    weighted amount of scheduled resources (optionally weighted by shift cost), it ensures that in all intervals, there are
-    never fewer resources shifted than the ones required per period.
-
-### Rostering
-
-It assigns a list of resources to a list of required positions per day and shifts; it takes into account
-different restrictions as shift bans, consecutive shifts, resting days, and others.
-It also introduces soft restrictions like shift preferences.
-
-# Usage:
-Install pyworkforce
-
-It's advised to install pyworkforce using a virtual env, inside the env use:
-
-```
-pip install pyworkforce
-```
-
-If you are having troubles with or-tools installation, check the [or-tools guide](https://github.com/google/or-tools#installation)
-
-For complete list and details of examples go to the 
-[examples folder](https://github.com/rodrigo-arenas/pyworkforce/tree/develop/examples)
+[![Python Version](https://img.shields.io/badge/python-3.12%20%7C%203.13%20%7C%203.14-blue)](https://www.python.org/downloads/)
+
+
+# pyworkforce
+Tools for workforce management problems such as queue staffing, shift scheduling,
+rostering, and operations research optimization.
+
+The full documentation is available at
+[pyworkforce.readthedocs.io](https://pyworkforce.readthedocs.io/en/stable/).
+
+## Installation
+
+We recommend installing pyworkforce in a virtual environment:
+
+```bash
+pip install pyworkforce
+```
+
+pyworkforce supports Python 3.12, 3.13, and 3.14.
+
+If you are using Anaconda and run into installation issues, update the environment first:
+
+```bash
+conda update --all
+```
+
+If the issue is related to OR-Tools, check the
+[OR-Tools installation guide](https://github.com/google/or-tools#installation).
+
+For runnable examples, see the
+[examples folder](https://github.com/rodrigo-arenas/pyworkforce/tree/develop/examples).
+
+## What pyworkforce Does
+
+pyworkforce is organized around three planning steps:
+
+### Queuing
+
+Use `pyworkforce.queuing` when you need to estimate how many resources are required
+to handle incoming work, for example calls arriving at a call center. The current
+implementation uses Erlang C assumptions: constant arrival rate, infinite queue,
+and no customer dropout.
+
+![queue_system](https://raw.githubusercontent.com/rodrigo-arenas/pyworkforce/main/docs/images/erlangc_queue_system.png)
+
+- **queuing.ErlangC:** Calculate staffing requirements and performance metrics for one queue scenario.
+- **queuing.MultiErlangC:** Run multiple Erlang C scenarios from a parameter grid.
+  
+### Scheduling
+
+Use `pyworkforce.scheduling` when you already know the required resources by time
+interval and need to choose how many people to place on each predefined shift.
+
+- **scheduling.MinAbsDifference:** Minimizes the total absolute difference between required and scheduled resources.
+- **scheduling.MinRequiredResources:** Minimizes the total weighted number of scheduled resources while ensuring every interval is covered.
+
+### Rostering
+
+Use `pyworkforce.rostering` when you have named resources and need to assign them
+to days and shifts while respecting rules such as banned shifts, rest days,
+minimum working hours, and preferences.
+
+- **rostering.MinHoursRoster:** Builds a resource-level roster that covers shift requirements with the minimum scheduled hours.
 
 ### Queue systems:
 
-A brief introduction can be found in this [medium post](https://medium.com/mlearning-ai/workforce-planning-optimization-using-python-69af0ef9011a)
+A brief introduction can be found in this [medium post](https://towardsdatascience.com/workforce-planning-optimization-using-python-69af0ef9011a)
 
 #### Example:
 
@@ -74,7 +89,8 @@ Output:
                              'waiting_probability': 0.1741319335950498}
 ```
 
-If you want to run different scenarios at the same time, you can use the MultiErlangC, for example, trying different service levels:
+If you want to run several scenarios at the same time, use `MultiErlangC`.
+For example, this tries different service-level targets:
 
 ```python
 from pyworkforce.queuing import MultiErlangC
@@ -115,18 +131,20 @@ Output:
 ```
 ### Scheduling
 
+A brief introduction can be found in this [medium post](https://towardsdatascience.com/how-to-solve-scheduling-problems-in-python-36a9af8de451)
+
 #### Example:
 
 ```python
 from pyworkforce.scheduling import MinAbsDifference, MinRequiredResources
 
-# Rows are the days, each entry of a row, is number of positions required at an hour of the day (24). 
+# Rows are days. Each value is the number of required positions for one hour of the day.
 required_resources = [
     [9, 11, 17, 9, 7, 12, 5, 11, 8, 9, 18, 17, 8, 12, 16, 8, 7, 12, 11, 10, 13, 19, 16, 7],
     [13, 13, 12, 15, 18, 20, 13, 16, 17, 8, 13, 11, 6, 19, 11, 20, 19, 17, 10, 13, 14, 23, 16, 8]
 ]
 
-# Each entry of a shift,an hour of the day (24), 1 if the shift covers that hour, 0 otherwise
+# Each shift has 24 entries, one per hour. Use 1 if the shift covers that hour, otherwise 0.
 shifts_coverage = {"Morning": [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    "Afternoon": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
                    "Night": [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
@@ -181,4 +199,4 @@ Output:
                                                 {'day': 1, 'shift': 'Afternoon', 'resources': 20}, 
                                                 {'day': 1, 'shift': 'Night', 'resources': 23}, 
                                                 {'day': 1, 'shift': 'Mixed', 'resources': 0}]}
-```
+```

pyworkforce-0.5.2/pyworkforce/_version.py

@@ -0,0 +1 @@
+__version__ = "0.5.2"

{pyworkforce-0.5.0.dev0 → pyworkforce-0.5.2}/pyworkforce/queuing/erlang.py

@@ -5,22 +5,22 @@ from joblib import Parallel, delayed
 
 class ErlangC:
     """
-    Computes the number of positions required to attend a number of transactions in a
-    queue system based on erlangc.rst. Implementation inspired on:
+    Computes the number of positions required to handle transactions in an
+    Erlang C queue system. Implementation inspired by:
     https://lucidmanager.org/data-science/call-centre-workforce-planning-erlang-c-in-r/
 
     Parameters
     ----------
     transactions: float,
-        The number of total transactions that comes in an interval.
+        Total number of transactions arriving in the interval.
     aht: float,
         Average handling time of a transaction (minutes).
     asa: float,
         The required average speed of answer (minutes).
     interval: int,
-        Interval length (minutes) where the transactions come in
+        Interval length, in minutes.
     shrinkage: float,
-        Percentage of time that an operator unit is not available.
+        Fraction of time that an operator unit is not available.
     """
 
     def __init__(self, transactions: float, aht: float, asa: float,
@@ -46,51 +46,61 @@ class ErlangC:
         self.aht = aht
         self.interval = interval
         self.asa = asa
-        self.intensity = (self.n_transactions / self.interval) * self.aht
-        self.shrinkage = shrinkage
-
-    def waiting_probability(self, positions: int, scale_positions: bool = False):
+        self.intensity = (self.n_transactions / self.interval) * self.aht
+        self.shrinkage = shrinkage
+
+    def _productive_positions(self, positions: int, scale_positions: bool = False):
+        if scale_positions:
+            productive_positions = floor((1 - self.shrinkage) * positions)
+        else:
+            productive_positions = positions
+
+        if productive_positions <= 0:
+            raise ValueError("productive positions must be greater than 0")
+
+        if productive_positions <= self.intensity:
+            raise ValueError("positions must be greater than traffic intensity")
+
+        return productive_positions
+
+    def waiting_probability(self, positions: int, scale_positions: bool = False):
         """
-        Returns the probability of waiting in the queue
+        Returns the probability that a transaction waits in queue.
 
         Parameters
         ----------
-        positions: int,
-            The number of positions to attend the transactions.
-        scale_positions: bool, default=False
-            Set it to True if the positions were calculated using shrinkage.
+        positions: int,
+            The number of positions available to handle transactions.
+            Productive positions must be greater than traffic intensity.
+        scale_positions: bool, default=False
+            Set to True when ``positions`` includes shrinkage.
 
         """
 
-        if scale_positions:
-            productive_positions = floor((1 - self.shrinkage) * positions)
-        else:
-            productive_positions = positions
-
-        erlang_b_inverse = 1
-        for position in range(1, productive_positions + 1):
-            erlang_b_inverse = 1 + (erlang_b_inverse * position / self.intensity)
+        productive_positions = self._productive_positions(positions, scale_positions)
+
+        erlang_b_inverse = 1
+        for position in range(1, productive_positions + 1):
+            erlang_b_inverse = 1 + (erlang_b_inverse * position / self.intensity)
 
         erlang_b = 1 / erlang_b_inverse
         return productive_positions * erlang_b / (productive_positions - self.intensity * (1 - erlang_b))
 
     def service_level(self, positions: int, scale_positions: bool = False):
         """
-        Returns the expected service level given a number of positions
+        Returns the expected service level for a number of positions.
 
         Parameters
         ----------
 
-        positions: int,
-            The number of positions attending.
-        scale_positions: bool, default = False
-            Set it to True if the positions were calculated using shrinkage.
+        positions: int,
+            The number of positions available to handle transactions.
+            Productive positions must be greater than traffic intensity.
+        scale_positions: bool, default = False
+            Set to True when ``positions`` includes shrinkage.
 
         """
-        if scale_positions:
-            productive_positions = floor((1 - self.shrinkage) * positions)
-        else:
-            productive_positions = positions
+        productive_positions = self._productive_positions(positions, scale_positions)
 
         probability_wait = self.waiting_probability(productive_positions, scale_positions=False)
         exponential = exp(-(productive_positions - self.intensity) * (self.asa / self.aht))
@@ -98,57 +108,58 @@ class ErlangC:
 
     def achieved_occupancy(self, positions: int, scale_positions: bool = False):
         """
-        Returns the expected occupancy of positions
+        Returns the expected occupancy of positions.
 
         Parameters
         ----------
 
-        positions: int,
-            The number of raw positions
-        scale_positions: bool, default=False
-            Set it to True if the positions were calculated using shrinkage.
+        positions: int,
+            The number of raw positions.
+            Productive positions must be greater than traffic intensity.
+        scale_positions: bool, default=False
+            Set to True when ``positions`` includes shrinkage.
 
         """
-        if scale_positions:
-            productive_positions = floor((1 - self.shrinkage) * positions)
-        else:
-            productive_positions = positions
+        productive_positions = self._productive_positions(positions, scale_positions)
 
         return self.intensity / productive_positions
 
     def required_positions(self, service_level: float, max_occupancy: float = 1.0):
         """
-        Computes the requirements using erlangc.rst
+        Computes the required positions for a target service level.
 
         Parameters
         ----------
 
         service_level: float,
-            Target service level
-        max_occupancy: float,
-            The maximum fraction of time that a transaction can occupy a position
+            Target service level.
+        max_occupancy: float,
+            The maximum fraction of time that a transaction can occupy a position.
+            Must be greater than 0 and less than or equal to 1.
 
         Returns
         -------
 
         raw_positions: int,
-            The required positions assuming shrinkage = 0
+            Required positions before applying shrinkage.
         positions: int,
-            The number of positions needed to ensure the required service level
+            Positions needed after applying shrinkage.
         service_level: float,
-            The fraction of transactions that are expected to be assigned to a position,
-            before the asa time
+            Fraction of transactions expected to reach a position before the target ASA.
         occupancy: float,
-            The expected occupancy of positions
+            Expected occupancy of positions.
         waiting_probability: float,
-            The probability of a transaction waiting in the queue
+            Probability that a transaction waits in queue.
         """
 
         if service_level < 0 or service_level > 1:
             raise ValueError("service_level must be between 0 and 1")
 
-        if max_occupancy < 0 or max_occupancy > 1:
-            raise ValueError("max_occupancy must be between 0 and 1")
+        if max_occupancy < 0 or max_occupancy > 1:
+            raise ValueError("max_occupancy must be between 0 and 1")
+
+        if max_occupancy == 0:
+            raise ValueError("max_occupancy must be greater than 0")
 
         positions = round(self.intensity + 1)
         achieved_service_level = self.service_level(positions, scale_positions=False)
@@ -177,47 +188,40 @@ class ErlangC:
 
 class MultiErlangC:
     """
-    This class uses the erlangc.rst class using joblib's Parallel,
-    allowing to run multiple scenarios at once.
-    It finds solutions iterating over all possible combinations provided by the users,
-    inspired how Sklearn's Grid Search works
+    Runs Erlang C calculations over multiple parameter combinations.
+
+    This class uses joblib's ``Parallel`` to evaluate every combination from
+    ``param_grid`` and the method-specific argument grid. Its interface is
+    inspired by scikit-learn's grid search utilities.
 
     Parameters
     ----------
 
     param_grid: dict,
-        Dictionary with the erlangc.rst.__init__ parameters, each key of the dictionary must be the
-        expected parameter and the value must be a list with the different options to iterate
+        Dictionary with :class:`ErlangC` initialization parameters. Each key must be an
+        expected parameter, and each value must be a list of options to iterate over.
         example: {"transactions": [100, 200], "aht": [3], "interval": [30], "asa": [20 / 60], "shrinkage": [0.3]}
     n_jobs: int, default=2
-        The maximum number of concurrently running jobs.
+        Maximum number of concurrently running jobs.
         If -1 all CPUs are used. If 1 is given, no parallel computing code is used at all, which is useful for debugging.
         For n_jobs below -1, (n_cpus + 1 + n_jobs) are used. Thus for n_jobs = -2, all CPUs but one are used.
         None is a marker for ‘unset’ that will be interpreted as n_jobs=1 (sequential execution)
         unless the call is performed under a parallel_backend() context manager that sets another value for n_jobs.
     pre_dispatch: {"all", int, or expression}, default='2 * n_jobs'
-        The number of batches (of tasks) to be pre-dispatched. Default is ‘2*n_jobs’.
+        Number of task batches to pre-dispatch. Default is ``2*n_jobs``.
         See joblib's documentation for more details: https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html
 
     Attributes
     ----------
 
     waiting_probability_params: list[tuple],
-        Each tuple of the list represents the used parameters in param_grid for ErlangC and
-        arguments_grid for waiting_probability method,corresponding to the same order returned
-        by the MultiErlangC.waiting_probability method.
+        Parameters used for each ``waiting_probability`` result, in result order.
     service_level_params: list[tuple],
-        Each tuple of the list represents the used parameters in param_grid for ErlangC and
-        arguments_grid for service_level method,corresponding to the same order returned
-        by the MultiErlangC.service_level method.
+        Parameters used for each ``service_level`` result, in result order.
     achieved_occupancy_params: list[tuple],
-        Each tuple of the list represents the used parameters in param_grid for ErlangC and
-        arguments_grid for achieved_occupancy method,corresponding to the same order returned
-        by the MultiErlangC.achieved_occupancy method.
+        Parameters used for each ``achieved_occupancy`` result, in result order.
     required_positions_params: list[tuple],
-        Each tuple of the list represents the used parameters in param_grid for ErlangC and
-        arguments_grid for required_positions method,corresponding to the same order returned
-        by the MultiErlangC.required_positions method.
+        Parameters used for each ``required_positions`` result, in result order.
     """
 
     def __init__(self, param_grid: dict, n_jobs: int = 2, pre_dispatch: str = '2 * n_jobs'):
@@ -347,8 +351,8 @@ class MultiErlangC:
         if len(solutions) < 1:  # noqa
             raise ValueError("Could not find any solution, make sure the param_grid is defined correctly")
 
-        if len(solutions) != combinations:
-            raise ValueError('Inconsistent results. Expected {} '
-                             'solutions, got {}'
-                             .format(len(self.param_list),
-                                     len(solutions))) # noqa
+        if len(solutions) != combinations:
+            raise ValueError('Inconsistent results. Expected {} '
+                             'solutions, got {}'
+                             .format(combinations,
+                                     len(solutions))) # noqa