pyworkforce 0.5.1__tar.gz → 0.5.2__tar.gz

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyworkforce
-Version: 0.5.1
+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,66 +11,96 @@ 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.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.8
+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.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-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/).
 
-# Usage:
-Install pyworkforce
+## Installation
 
-It's advised to install pyworkforce using a virtual env, inside the env use:
+We recommend installing pyworkforce in a virtual environment:
 
-```
+```bash
 pip install pyworkforce
 ```
 
-If you are having troubles with or-tools installation, check the [or-tools guide](https://github.com/google/or-tools#installation)
+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 complete list and details of examples go to the 
-[examples folder](https://github.com/rodrigo-arenas/pyworkforce/tree/develop/examples)
+For runnable examples, see the
+[examples folder](https://github.com/rodrigo-arenas/pyworkforce/tree/develop/examples).
 
-## Features:
-pyworkforce currently includes:
+## 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.
+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
 
-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.
+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:
 
@@ -95,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
@@ -143,13 +174,13 @@ A brief introduction can be found in this [medium post](https://towardsdatascien
 ```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.1 → pyworkforce-0.5.2}/README.md

@@ -2,54 +2,69 @@
 [![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.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-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/)
-
-# 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)
-
-## 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.
+[![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:
 
@@ -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
@@ -122,13 +138,13 @@ A brief introduction can be found in this [medium post](https://towardsdatascien
 ```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.2/pyworkforce/_version.py

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

{pyworkforce-0.5.1 → 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

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/pyworkforce/queuing/tests/test_erlang.py

@@ -85,8 +85,38 @@ def test_wrong_service_level_erlangc():
     assert str(excinfo.value) == "service_level must be between 0 and 1"
 
 
-def test_wrong_max_occupancy_erlangc():
-    erlang = ErlangC(transactions=100, asa=0.33, aht=3, interval=30, shrinkage=0.3)
-    with pytest.raises(Exception) as excinfo:
-        results = erlang.required_positions(service_level=0.8, max_occupancy=1.2)
-    assert str(excinfo.value) == "max_occupancy must be between 0 and 1"
+def test_wrong_max_occupancy_erlangc():
+    erlang = ErlangC(transactions=100, asa=0.33, aht=3, interval=30, shrinkage=0.3)
+    with pytest.raises(Exception) as excinfo:
+        results = erlang.required_positions(service_level=0.8, max_occupancy=1.2)
+    assert str(excinfo.value) == "max_occupancy must be between 0 and 1"
+
+
+def test_zero_max_occupancy_erlangc():
+    erlang = ErlangC(transactions=100, asa=0.33, aht=3, interval=30, shrinkage=0.3)
+    with pytest.raises(Exception) as excinfo:
+        erlang.required_positions(service_level=0.8, max_occupancy=0)
+    assert str(excinfo.value) == "max_occupancy must be greater than 0"
+
+
+def test_waiting_probability_requires_productive_positions():
+    erlang = ErlangC(transactions=1, asa=0.33, aht=1, interval=30, shrinkage=0.9)
+    with pytest.raises(Exception) as excinfo:
+        erlang.waiting_probability(positions=1, scale_positions=True)
+    assert str(excinfo.value) == "productive positions must be greater than 0"
+
+
+def test_erlang_methods_require_stable_system():
+    erlang = ErlangC(transactions=100, asa=0.33, aht=3, interval=30, shrinkage=0.0)
+
+    with pytest.raises(Exception) as excinfo:
+        erlang.waiting_probability(positions=10)
+    assert str(excinfo.value) == "positions must be greater than traffic intensity"
+
+    with pytest.raises(Exception) as excinfo:
+        erlang.service_level(positions=10)
+    assert str(excinfo.value) == "positions must be greater than traffic intensity"
+
+    with pytest.raises(Exception) as excinfo:
+        erlang.achieved_occupancy(positions=10)
+    assert str(excinfo.value) == "positions must be greater than traffic intensity"

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/pyworkforce/queuing/tests/test_multi_erlang.py

@@ -86,10 +86,18 @@ def test_expected_multierlangc_wrong_arguments():
                                   "ErlangC.required_positions() missing 1 required positional argument: 'service_level'"]
 
 
-def test_multierlangc_wrong_grid():
-    param_grid = {"transactions": 100, "asa": [0.33], "aht": [3], "interval": [30], "shrinkage": [0.3]}
-
-    with pytest.raises(Exception) as excinfo:
-        results = MultiErlangC(param_grid=param_grid)
-    assert str(excinfo.value) == "Parameter grid value is not iterable (key='transactions', value=100)"
+def test_multierlangc_wrong_grid():
+    param_grid = {"transactions": 100, "asa": [0.33], "aht": [3], "interval": [30], "shrinkage": [0.3]}
+
+    with pytest.raises(Exception) as excinfo:
+        results = MultiErlangC(param_grid=param_grid)
+    assert str(excinfo.value) == "Parameter grid value is not iterable (key='transactions', value=100)"
+
+
+def test_multierlangc_check_solutions_expected_combinations():
+    erlang = MultiErlangC(param_grid={"transactions": [100], "asa": [0.33], "aht": [3], "interval": [30]})
+
+    with pytest.raises(Exception) as excinfo:
+        erlang._check_solutions([{}], combinations=2)
+    assert str(excinfo.value) == "Inconsistent results. Expected 2 solutions, got 1"
 

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/pyworkforce/rostering/binary_programming.py

@@ -5,48 +5,49 @@ from ortools.sat.python import cp_model
 class MinHoursRoster:
     """
 
-    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.
-    The "optimal" criteria is defined as the minimum total scheduled hours,
-    optionally weighted by resources shifts preferences
+    Assigns named resources to required positions by day and shift.
+
+    The solver supports restrictions such as banned shifts, non-sequential
+    shifts, rest days, and minimum working hours. It also supports soft shift
+    preferences. The objective is to minimize total scheduled hours, optionally
+    weighted by resource shift preferences.
 
     Parameters
     ----------
 
     num_days: int,
-        Number of days needed to schedule
+        Number of days to schedule.
     resources: list[str],
-        Resources available to shift
+        Resources available to schedule.
     shifts: list,
-        Array of shifts names
+        List of shift names.
     shifts_hours: list,
-        Array of size [shifts] with the total hours within the shift
+        Array of size ``[shifts]`` with the duration of each shift.
     min_working_hours: int,
-        Minimum working hours per resource in the horizon
+        Minimum working hours per resource in the planning horizon.
     banned_shifts: list[dict]
-        Each element {"resource": resource_index, "shift": shift_name, "day": day_number} indicating
-        that the resource can't be assigned to that shift that particular day
+        Each element has the form ``{"resource": resource_id, "shift": shift_name, "day": day_number}``
+        and marks a shift that the resource cannot work on that day.
         example: banned_shifts": [{"resource":"e.johnston@randatmail.com", "shift": "Night", "day":  0}],
     max_resting: int,
-        Maximum number of resting days per resource in the total interval
+        Maximum number of resting days per resource in the planning horizon.
     required_resources: dict[list]
-        Each key of the dict must be one of the shifts, the value must be a  list of length [days]
-        specifying the number of resources to shift in each day for that shift
+        Each key must be a shift name, and each value must be a list of length
+        ``num_days`` with the required resources for that shift each day.
     non_sequential_shifts: List[dict]
-        Each element must have the form {"origin": first_shift, "destination": second_shift}
-        to make sure that destination shift can't be after origin shift.
+        Each element must have the form ``{"origin": first_shift, "destination": second_shift}``
+        to prevent ``destination`` from being assigned the day after ``origin``.
         example: [{"origin":"Night", "destination":"Morning"}]
     resources_preferences: list[dict]
-        Each element must have the form {"resource": resource_idx, "shifts":shift_name}
-        indicating the resources that have preference for shift
+        Each element must have the form ``{"resource": resource_id, "shift": shift_name}``
+        and indicates that the resource prefers that shift.
     resources_prioritization: list[dict], default=None
-        Each element must have the form {"resource": resource_idx, "weight": weight_percentage}
-        this represent the relative importance for resources_preferences assignment
+        Each element must have the form ``{"resource": resource_id, "weight": weight}``
+        and represents the relative importance of that resource's preferences.
     max_search_time: float, default = 240
-        Maximum time in seconds to search for a solution
+        Maximum time, in seconds, to search for a solution.
     num_search_workers: int, default = 2
-        Number of workers to search for a solution
+        Number of workers used to search for a solution.
     """
 
     def __init__(self, num_days: int,
@@ -108,7 +109,7 @@ class MinHoursRoster:
 
         # Constrains
 
-        # The number of shifted resource must be ge that required resource, for each day and shift
+        # The number of scheduled resources must be greater than or equal to the requirement for each day and shift
         for d in range(self._num_days):
             for s in range(self.num_shifts):
                 sch_model.Add(sum(shifted_resource[n][d][s] for n in range(self.num_resource))
@@ -144,7 +145,7 @@ class MinHoursRoster:
                             shifted_resource[n][d + 1][j]
                             for j in range(self.num_shifts)) <= 1)
 
-        # resource can't be assigned to banned shifts
+        # Resources cannot be assigned to banned shifts
         if self.banned_shifts is not None:
             for ban in self.banned_shifts:
                 resource_idx = self.resources.index(ban['resource'])

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/pyworkforce/scheduling/base.py

@@ -13,31 +13,33 @@ class BaseShiftScheduler:
                  num_search_workers=2):
 
         """
-        Base class to solve the following schedule problem:
-
-        Its required to find the optimal number of resources (agents, operators, doctors, etc) to allocate
-        in a shift, based on a pre-defined requirement of number of resources per period of the day (periods of hours,
-        half-hour, etc)
+        Base class for shift scheduling problems.
+
+        Scheduling finds the number of resources (agents, operators, doctors, etc.)
+        to allocate to each shift, based on predefined resource requirements by
+        period of the day.
         
         Parameters
         ----------
 
         num_days: int,
-            Number of days needed to schedule
+            Number of days to schedule.
         periods: int,
-            Number of working periods in a day
+            Number of working periods in a day.
         shifts_coverage: dict,
-            dict with structure {"shift_name": "shift_array"} where "shift_array" is an array of size [periods] (p), 1 if shift covers period p, 0 otherwise
+            Dictionary of the form ``{"shift_name": shift_array}``, where each
+            ``shift_array`` has length ``periods`` and uses 1 when the shift
+            covers a period, otherwise 0.
         required_resources: list,
-            Array of size [days, periods]
+            Array of size ``[days, periods]``.
         max_period_concurrency: int,
-            Maximum resources that are allowed to shift in any period and day
+            Maximum resources allowed in any period and day.
         max_shift_concurrency: int,
-            Number of maximum allowed resources in the same shift
+            Maximum resources allowed in the same shift.
         max_search_time: float, default = 240
-            Maximum time in seconds to search for a solution
+            Maximum time, in seconds, to search for a solution.
         num_search_workers: int, default = 2
-            Number of workers to search for a solution
+            Number of workers used to search for a solution.
         """
 
         is_valid_num_days = check_positive_integer("num_days", num_days)

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/pyworkforce/scheduling/shifts_selection.py

@@ -15,29 +15,30 @@ class MinAbsDifference(BaseShiftScheduler):
                  num_search_workers=2,
                  *args, **kwargs):
         """
-        The "optimal" criteria is defined as the number of resources per shift
-        that minimize the total absolute difference between the required resources
-        per period and the actual scheduling found by the solver
+        Minimizes the total absolute difference between required resources per
+        period and resources scheduled by the solver.
 
         Parameters
         ----------
 
         num_days: int,
-            Number of days needed to schedule
+            Number of days to schedule.
         periods: int,
-            Number of working periods in a day
+            Number of working periods in a day.
         shifts_coverage: dict,
-            dict with structure {"shift_name": "shift_array"} where "shift_array" is an array of size [periods] (p), 1 if shift covers period p, 0 otherwise
+            Dictionary of the form ``{"shift_name": shift_array}``, where each
+            ``shift_array`` has length ``periods`` and uses 1 when the shift
+            covers a period, otherwise 0.
         required_resources: list,
-            Array of size [days, periods]
+            Array of size ``[days, periods]``.
         max_period_concurrency: int,
-            Maximum resources that are allowed to shift in any period and day
+            Maximum resources allowed in any period and day.
         max_shift_concurrency: int,
-            Number of maximum allowed resources in the same shift
+            Maximum resources allowed in the same shift.
         max_search_time: float, default = 240
-            Maximum time in seconds to search for a solution
+            Maximum time, in seconds, to search for a solution.
         num_search_workers: int, default = 2
-            Number of workers to search for a solution
+            Number of workers used to search for a solution.
         """
 
         super().__init__(num_days,
@@ -56,8 +57,8 @@ class MinAbsDifference(BaseShiftScheduler):
         Returns
         -------
         solution: dict,
-            Dictionary with the status on the optimization, the resources to schedule per day and the
-            final value of the cost function
+            Dictionary with optimization status, scheduled resources by day and
+            shift, and final objective value.
         """
         sch_model = cp_model.CpModel()
 
@@ -90,7 +91,7 @@ class MinAbsDifference(BaseShiftScheduler):
                                                              - sum(resources[d][s] * self.shifts_coverage_matrix[s][p]
                                                                    for s in range(self.num_shifts))))
 
-        # Total programmed resources, must be less or equals to max_period_concurrency, for each day and period
+        # Total programmed resources must be less than or equal to max_period_concurrency for each day and period
         for d in range(self.num_days):
             for p in range(self.num_periods):
                 sch_model.Add(
@@ -139,32 +140,33 @@ class MinRequiredResources(BaseShiftScheduler):
                  num_search_workers: int = 2,
                  *args, **kwargs):
         """
-        The "optimal" criteria is defined as the minimum weighted amount
-        of resources (by optional shift cost), that ensures that there are never
-        fewer resources shifted than the ones required per period
+        Minimizes the weighted number of scheduled resources while ensuring that
+        every period has at least the required number of resources.
 
         Parameters
         ----------
 
         num_days: int,
-            Number of days needed to schedule
+            Number of days to schedule.
         periods: int,
-            Number of working periods in a day
+            Number of working periods in a day.
         shifts_coverage: dict,
-            dict with structure {"shift_name": "shift_array"} where "shift_array" is an array of size [periods] (p), 1 if shift covers period p, 0 otherwise
+            Dictionary of the form ``{"shift_name": shift_array}``, where each
+            ``shift_array`` has length ``periods`` and uses 1 when the shift
+            covers a period, otherwise 0.
         required_resources: list,
-            Array of size [days, periods]
+            Array of size ``[days, periods]``.
         max_period_concurrency: int,
-            Maximum resources that are allowed to shift in any period and day
+            Maximum resources allowed in any period and day.
         max_shift_concurrency: int,
-            Number of maximum allowed resources in the same shift
+            Maximum resources allowed in the same shift.
         cost_dict: dict, default = None
-            dictionary of form {shift: cost_value}, where shift must be the same options listed in the
-            shifts_coverage matrix, and they must be all integers
+            Dictionary of the form ``{shift: cost_value}``. It must contain the
+            same shifts as ``shifts_coverage``.
         max_search_time: float, default = 240
-            Maximum time in seconds to search for a solution
+            Maximum time, in seconds, to search for a solution.
         num_search_workers: int, default = 2
-            Number of workers to search for a solution
+            Number of workers used to search for a solution.
         """
 
         super().__init__(num_days,
@@ -214,7 +216,7 @@ class MinRequiredResources(BaseShiftScheduler):
                 sch_model.Add(sum(resources[d][s] * self.shifts_coverage_matrix[s][p]
                                   for s in range(self.num_shifts)) >= self.required_resources[d][p])
 
-        # Total programmed resources, must be less or equals to max_period_concurrency, for each day and period
+        # Total programmed resources must be less than or equal to max_period_concurrency for each day and period
         for d in range(self.num_days):
             for p in range(self.num_periods):
                 sch_model.Add(

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/pyworkforce/utils/grid.py

@@ -98,7 +98,7 @@ class ParameterGrid:
             # Reverse so most frequent cycling parameter comes first
             keys, values_lists = zip(*sorted(sub_grid.items())[::-1])
             sizes = [len(v_list) for v_list in values_lists]
-            total = np.product(sizes)
+            total = np.prod(sizes)
 
             if ind >= total:
                 # Try the next grid

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/pyworkforce/utils/tests/test_parameter_grid.py

@@ -8,7 +8,7 @@ def assert_grid_iter_equals_getitem(grid):
     assert list(grid) == [grid[i] for i in range(len(grid))]
 
 
-def test_parameter_grid():
+def test_parameter_grid():
     """
     Test taken from scikit-learn
     """
@@ -39,13 +39,20 @@ def test_parameter_grid():
     assert len(empty) == 1
     assert list(empty) == [{}]
     assert_grid_iter_equals_getitem(empty)
-    with pytest.raises(IndexError):
-        empty[1]
-
-    has_empty = ParameterGrid([{'C': [1, 10]}, {}, {'C': [.5]}])
+    with pytest.raises(IndexError):
+        empty[1]
+
+    has_empty = ParameterGrid([{'C': [1, 10]}, {}, {'C': [.5]}])
     assert len(has_empty) == 4
     assert list(has_empty) == [{'C': 1}, {'C': 10}, {}, {'C': .5}]
-    assert_grid_iter_equals_getitem(has_empty)
+    assert_grid_iter_equals_getitem(has_empty)
+
+
+def test_parameter_grid_getitem_uses_numpy_2_compatible_product():
+    grid = ParameterGrid({"a": [1, 2], "b": [3, 4]})
+
+    assert grid[0] == {"a": 1, "b": 3}
+    assert grid[3] == {"a": 2, "b": 4}
 
 
 def test_non_iterable_parameter_grid():

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/pyworkforce.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyworkforce
-Version: 0.5.1
+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,66 +11,96 @@ 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.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.8
+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.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-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/).
 
-# Usage:
-Install pyworkforce
+## Installation
 
-It's advised to install pyworkforce using a virtual env, inside the env use:
+We recommend installing pyworkforce in a virtual environment:
 
-```
+```bash
 pip install pyworkforce
 ```
 
-If you are having troubles with or-tools installation, check the [or-tools guide](https://github.com/google/or-tools#installation)
+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 complete list and details of examples go to the 
-[examples folder](https://github.com/rodrigo-arenas/pyworkforce/tree/develop/examples)
+For runnable examples, see the
+[examples folder](https://github.com/rodrigo-arenas/pyworkforce/tree/develop/examples).
 
-## Features:
-pyworkforce currently includes:
+## 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.
+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
 
-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.
+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:
 
@@ -95,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
@@ -143,13 +174,13 @@ A brief introduction can be found in this [medium post](https://towardsdatascien
 ```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.2/pyworkforce.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=1.26.0
+ortools>=9.12.4544
+pandas>=2.2.0
+joblib>=1.4.0

{pyworkforce-0.5.1 → pyworkforce-0.5.2}/setup.py

@@ -25,12 +25,11 @@ setup(
     author_email="rodrigo.arenas456@gmail.com",
     license="MIT",
     classifiers=[
-        'License :: OSI Approved :: MIT License',
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
+        'License :: OSI Approved :: MIT License',
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
     ],
     project_urls={
         "Documentation": "https://pyworkforce.readthedocs.io/en/stable/",
@@ -39,11 +38,11 @@ setup(
     },
     packages=find_packages(include=['pyworkforce', 'pyworkforce.*']),
     install_requires=[
-        'numpy>=1.23.0',
-        'ortools>=9.2.9972',
-        'pandas>=1.3.5',
-        'joblib>0.17'
-    ],
-    python_requires=">=3.8",
+        'numpy>=1.26.0',
+        'ortools>=9.12.4544',
+        'pandas>=2.2.0',
+        'joblib>=1.4.0'
+    ],
+    python_requires=">=3.12,<3.15",
     include_package_data=True,
 )

pyworkforce-0.5.1/pyworkforce/_version.py

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

pyworkforce-0.5.1/pyworkforce.egg-info/requires.txt

@@ -1,4 +0,0 @@
-numpy>=1.23.0
-ortools>=9.2.9972
-pandas>=1.3.5
-joblib>0.17