Efficient shift scheduling is a core challenge for operations managers, especially when balancing worker availability with the need for complete shift coverage. When resources are limited and demand fluctuates, ensuring that each shift is adequately staffed—without overworking any team member—can be the difference between smooth operations and costly gaps. **Fair resource allocation** not only prevents burnout but also boosts morale and productivity, making it a vital goal in any scheduling process.

```
Final Shift Schedule:
Monday:
  09:00-13:00: Alice
  13:00-17:00: Bob
  17:00-21:00: Charlie

Tuesday:
  09:00-13:00: Alice
  13:00-17:00: Bob
  17:00-21:00: Unassigned

Wednesday:
  09:00-13:00: Unassigned
  13:00-17:00: Bob
  17:00-21:00: Charlie

```

When working with scheduling data, it is important to iterate through each worker's availability and match them with open shifts. Assigning shifts efficiently means checking if a worker is available for a specific time slot and ensuring that no worker is given more shifts than they can handle. Prioritize filling all shifts while keeping assignments fair and balanced. Keeping your data structures organized—such as using dictionaries for availability and schedules—can make the assignment process much more manageable.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")
        importlib.reload(self.user_code)
        self.workers = {
            "Alice": [("Monday", "09:00-13:00"), ("Tuesday", "09:00-13:00")],
            "Bob": [("Monday", "13:00-17:00"), ("Tuesday", "13:00-17:00"), ("Wednesday", "13:00-17:00")],
            "Charlie": [("Monday", "17:00-21:00"), ("Wednesday", "17:00-21:00")]
        }
        self.shifts = [
            ("Monday", "09:00-13:00"),
            ("Monday", "13:00-17:00"),
            ("Monday", "17:00-21:00"),
            ("Tuesday", "09:00-13:00"),
            ("Tuesday", "13:00-17:00"),
            ("Tuesday", "17:00-21:00"),
            ("Wednesday", "09:00-13:00"),
            ("Wednesday", "13:00-17:00"),
            ("Wednesday", "17:00-21:00")
        ]

    def test_output_structure_and_all_shifts(self):
        importlib.reload(self.user_code)
        func = getattr(self.user_code, "optimize_shift_schedule", None)
        _dynamic_test(
            self,
            callable(func),
            "optimize_shift_schedule is defined and callable",
            "Function optimize_shift_schedule is not defined or not callable",
        )
        schedule = func(self.workers, self.shifts)
        _dynamic_test(
            self,
            isinstance(schedule, dict),
            "Schedule is a dictionary",
            f"Schedule should be a dictionary, got {type(schedule)}",
        )
        # Check all shifts are present
        all_scheduled = set()
        for day, slots in schedule.items():
            for time, worker in slots:
                all_scheduled.add((day, time))
        missing = set(self.shifts) - all_scheduled
        _dynamic_test(
            self,
            not missing,
            "All input shifts are present in the output schedule",
            f"Missing shifts in schedule: {missing}",
        )

    def test_no_worker_overbooked(self):
        importlib.reload(self.user_code)
        func = getattr(self.user_code, "optimize_shift_schedule", None)
        schedule = func(self.workers, self.shifts)
        worker_count = {w: 0 for w in self.workers}
        for day in schedule:
            for time, worker in schedule[day]:
                if worker in worker_count:
                    worker_count[worker] += 1
        overbooked = [w for w, c in worker_count.items() if c > 3]
        _dynamic_test(
            self,
            not overbooked,
            "No worker is assigned to more than three shifts",
            f"Workers overbooked: {overbooked}",
        )

    def test_unassigned_when_no_available_worker(self):
        importlib.reload(self.user_code)
        func = getattr(self.user_code, "optimize_shift_schedule", None)
        # Remove Charlie's Wednesday availability
        workers = {
            "Alice": [("Monday", "09:00-13:00"), ("Tuesday", "09:00-13:00")],
            "Bob": [("Monday", "13:00-17:00"), ("Tuesday", "13:00-17:00"), ("Wednesday", "13:00-17:00")],
            "Charlie": [("Monday", "17:00-21:00")]
        }
        schedule = func(workers, self.shifts)
        found = False
        for slot in schedule.get("Wednesday", []):
            if slot[0] == "17:00-21:00" and slot[1] == "Unassigned":
                found = True
        _dynamic_test(
            self,
            found,
            'Shift is marked as "Unassigned" when no worker is available',
            'Shift not marked as "Unassigned" when no worker is available',
        )

    def test_assignment_matches_availability(self):
        importlib.reload(self.user_code)
        func = getattr(self.user_code, "optimize_shift_schedule", None)
        schedule = func(self.workers, self.shifts)
        # Every assigned worker must be available for that shift
        for day in schedule:
            for time, worker in schedule[day]:
                if worker != "Unassigned":
                    _dynamic_test(
                        self,
                        (day, time) in self.workers[worker],
                        f"{worker} only assigned to available shift {day}, {time}",
                        f"{worker} assigned to unavailable shift {day}, {time}",
                    )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

This course empowers operations managers to leverage Python for streamlining workflows, analyzing operational data, and making data-driven decisions. Through practical examples and real-world challenges, you'll learn how to automate repetitive tasks, visualize key metrics, and optimize processes using Python's powerful libraries.

Learn how to use Python to automate repetitive tasks, streamline data handling, and improve efficiency in daily operations management.

Master the use of Python for analyzing operational data, identifying trends, and supporting data-driven decision-making.

Apply Python to solve classic operations management problems such as process optimization, demand forecasting, and resource allocation.

Challenge: Optimize Shift Scheduling

Soluzione