When you manage multiple freelance projects, keeping clients informed with **personalized updates** is essential for building trust and ensuring smooth collaboration. Python can help you automate this process by generating clear status updates for each client and project, saving you time and ensuring consistency in your communications. You will create a script that uses **hardcoded data** to represent your active projects, the clients you are working with, and the current status of each project. The script will then output friendly, tailored messages that summarize progress and outline the next steps for each client.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io

class TestTask(unittest.TestCase):
    def test_projects_list_exists_and_is_list(self):
        import user_code
        importlib.reload(user_code)
        projects = getattr(user_code, 'projects', None)
        _dynamic_test(
            self,
            isinstance(projects, list),
            "'projects' is defined as a list.",
            f"Expected 'projects' to be a list, got {type(projects)}."
        )

    def test_projects_has_at_least_two_dicts(self):
        import user_code
        importlib.reload(user_code)
        projects = getattr(user_code, 'projects', None)
        _dynamic_test(
            self,
            isinstance(projects, list) and len(projects) >= 2,
            "'projects' contains at least two dictionaries.",
            f"Expected at least two projects, got {len(projects) if isinstance(projects, list) else 'not a list'}."
        )
        for project in projects:
            _dynamic_test(
                self,
                isinstance(project, dict),
                "Each item in 'projects' is a dictionary.",
                f"Project item is not a dictionary: {project}"
            )

    def test_projects_dict_keys(self):
        import user_code
        importlib.reload(user_code)
        projects = getattr(user_code, 'projects', None)
        required_keys = {"client_name", "project_name", "status", "next_steps"}
        for i, project in enumerate(projects):
            _dynamic_test(
                self,
                isinstance(project, dict),
                f"Project {i} is a dictionary.",
                f"Project {i} is not a dictionary."
            )
            has_keys = required_keys.issubset(set(project.keys()))
            _dynamic_test(
                self,
                has_keys,
                f"Project {i} contains all required keys.",
                f"Project {i} missing required keys: {set(project.keys())}" 
            )

    def test_output_contains_personalized_messages(self):
        import user_code
        importlib.reload(user_code)
        projects = getattr(user_code, 'projects', None)
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        importlib.reload(user_code)
        sys.stdout = sys_stdout
        output = normalize_text(f.getvalue())
        for project in projects:
            expected_name = normalize_text(f"hello {project['client_name']},")
            expected_project = normalize_text(f"project: {project['project_name']}")
            expected_status = normalize_text(f"current status: {project['status']}")
            expected_next = normalize_text(f"next steps: {project['next_steps']}")
            _dynamic_test(
                self,
                expected_name in output,
                f"Output contains greeting for {project['client_name']}.",
                f"Greeting for {project['client_name']} not found in output."
            )
            _dynamic_test(
                self,
                expected_project in output,
                f"Output contains project name for {project['project_name']}.",
                f"Project name '{project['project_name']}' not found in output."
            )
            _dynamic_test(
                self,
                expected_status in output,
                f"Output contains status for {project['project_name']}.",
                f"Status for '{project['project_name']}' not found in output."
            )
            _dynamic_test(
                self,
                expected_next in output,
                f"Output contains next steps for {project['project_name']}.",
                f"Next steps for '{project['project_name']}' not found in 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

Unlock the power of Python to streamline, automate, and enhance your freelance workflow. This course is designed for freelancers who already know basic Python syntax and want to apply their skills to real-world freelance scenarios, from automating repetitive tasks to analyzing client data and visualizing project progress.

Learn how to use Python to automate repetitive and time-consuming freelance tasks, such as time tracking, invoice generation, and email reminders.

Master the use of Python for analyzing and visualizing your freelance business data, helping you make informed decisions and present results to clients.

Explore advanced Python techniques to optimize your freelance business, including pricing analysis, workload balancing, and client communication automation.

Challenge: Automated Status Updates

解答