In digital agencies, assigning project tasks fairly and transparently is essential for maintaining team morale and productivity. When a new client project begins, it is common to have a list of deliverables that must be distributed among available team members. If assignments are not handled equitably, some team members may become overloaded while others are underutilized, leading to frustration and inefficiency. A round-robin approach, where tasks are distributed one by one to each team member in turn, helps ensure that everyone receives a similar workload and that the assignment process is clearly understood by all.


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

class TestTask(unittest.TestCase):
    def test_round_robin_assignment(self):
        import user_code
        importlib.reload(user_code)
        tasks = ["Task1", "Task2", "Task3", "Task4", "Task5"]
        team_members = ["Ann", "Ben", "Cara"]

        f = io.StringIO()
        with redirect_stdout(f):
            user_code.assign_tasks(tasks, team_members)
        output = normalize_text(f.getvalue())
        # Round robin: Ann: Task1, Task4; Ben: Task2, Task5; Cara: Task3
        _dynamic_test(
            self,
            "ann:" in output and "ben:" in output and "cara:" in output,
            "All team members are included in output",
            f"Missing member in output: {output}"
        )
        _dynamic_test(
            self,
            "task1" in output and "task2" in output and "task3" in output and "task4" in output and "task5" in output,
            "All tasks appear in output",
            f"Not all tasks present in output: {output}"
        )
        # Check Ann gets Task1, Task4
        _dynamic_test(
            self,
            "ann: task1, task4" in output,
            "Ann is assigned Task1 and Task4",
            f"Ann assignment incorrect: {output}"
        )
        # Check Ben gets Task2, Task5
        _dynamic_test(
            self,
            "ben: task2, task5" in output,
            "Ben is assigned Task2 and Task5",
            f"Ben assignment incorrect: {output}"
        )
        # Check Cara gets Task3
        _dynamic_test(
            self,
            "cara: task3" in output,
            "Cara is assigned Task3",
            f"Cara assignment incorrect: {output}"
        )

    def test_tasks_appear_once(self):
        import user_code
        importlib.reload(user_code)
        tasks = ["Alpha", "Beta", "Gamma", "Delta"]
        team_members = ["Mia", "Noah"]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.assign_tasks(tasks, team_members)
        output = normalize_text(f.getvalue())
        for t in tasks:
            count = output.count(normalize_text(t))
            _dynamic_test(
                self,
                count == 1,
                f"Task '{t}' appears exactly once in output",
                f"Task '{t}' appears {count} times in output: {output}"
            )

    def test_no_tasks_assigned(self):
        import user_code
        importlib.reload(user_code)
        tasks = []
        team_members = ["Zoe", "Liam"]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.assign_tasks(tasks, team_members)
        output = normalize_text(f.getvalue())
        # Both should show 'No tasks assigned'
        _dynamic_test(
            self,
            "zoe: no tasks assigned" in output and "liam: no tasks assigned" in output,
            "Correct output for members with no tasks",
            f"Incorrect output for no tasks: {output}"
        )

    def test_more_members_than_tasks(self):
        import user_code
        importlib.reload(user_code)
        tasks = ["Logo"]
        team_members = ["Sam", "Kim", "Lee"]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.assign_tasks(tasks, team_members)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "sam: logo" in output,
            "Sam is assigned Logo",
            f"Sam assignment incorrect: {output}"
        )
        _dynamic_test(
            self,
            "kim: no tasks assigned" in output and "lee: no tasks assigned" in output,
            "Kim and Lee have no tasks assigned",
            f"Kim/Lee assignment incorrect: {output}"
        )

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

Learn how to leverage Python to solve real-world problems faced by digital agencies. This course covers automation, data analysis, and reporting techniques tailored for marketing, content, and analytics teams. Through engaging theory and hands-on challenges, you'll gain practical skills to streamline workflows, analyze campaign data, and generate actionable insights.

Discover how Python can automate repetitive tasks in digital agencies, from campaign scheduling to content management and client communication.

Learn how to use Python for analyzing campaign data, extracting insights, and making data-driven decisions in digital agencies.

Master the art of generating clear, insightful reports and visualizations for clients using Python.

Challenge: Automated Task Assignment

Oplossing

Challenge: Automated Task Assignment

Oplossing