Analyzing engagement metrics is a core responsibility for Customer Success Managers. By understanding how often customers use your product and interact with support, you can proactively identify those who might need more attention or are at risk of churning. Metrics such as **login frequency** and **support ticket submissions** offer clear signals of customer health and satisfaction. Regularly reviewing these numbers helps you prioritize outreach and tailor your engagement strategies for maximum impact.

# Sample customer activity data: each dictionary contains a customer's name, number of logins, and support tickets
customer_activities = [
    {"name": "Alice", "logins": 12, "tickets": 1},
    {"name": "Bob", "logins": 7, "tickets": 3},
    {"name": "Carla", "logins": 15, "tickets": 0},
    {"name": "David", "logins": 5, "tickets": 2},
    {"name": "Ella", "logins": 9, "tickets": 1}
]

To tackle this analysis, you will work with a list of dictionaries, where each dictionary represents a customer's activity. Begin by calculating the average number of logins across all customers. Then, compare each customer's login count to this average to flag those who may be less engaged. Next, for each customer, compute an engagement score by subtracting the number of support tickets from the number of logins—a simple way to balance product usage with potential friction. Finally, assemble a summary report that lists each customer's name, their engagement score, and whether their login count falls below the average. Use Python's built-in functions and control structures to iterate through the data, perform calculations, and print the results in a clear, readable format.


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 setUp(self):
        self.test_data = [
            {"name": "Alice", "logins": 12, "tickets": 1},
            {"name": "Bob", "logins": 7, "tickets": 3},
            {"name": "Carla", "logins": 15, "tickets": 0},
            {"name": "David", "logins": 5, "tickets": 2},
            {"name": "Ella", "logins": 9, "tickets": 1}
        ]

    def _run_user_code(self, data=None):
        import user_code
        importlib.reload(user_code)
        if data is None:
            data = self.test_data
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_engagement(data)
        return f.getvalue()

    def test_average_login_calculation(self):
        import user_code
        importlib.reload(user_code)
        # Simulate extracting the average from user function
        # We'll monkeypatch the function to return avg
        code = """
def analyze_engagement(activities):
    total_logins = sum(c['logins'] for c in activities)
    num_customers = len(activities)
    avg_logins = total_logins / num_customers
    return avg_logins
"""
        ns = {}
        exec(code, ns)
        avg_logins = ns['analyze_engagement'](self.test_data)
        expected_avg = (12+7+15+5+9)/5
        _dynamic_test(
            self,
            abs(avg_logins - expected_avg) < 1e-6,
            f"Correct average login calculation: {expected_avg}",
            f"Expected average {expected_avg}, got {avg_logins}",
        )

    def test_below_average_identification(self):
        output = self._run_user_code()
        below_avg_customers = ["Bob", "David", "Ella"]
        for name in below_avg_customers:
            # Find the line for the customer
            customer_line = None
            for line in output.split("\\n"):
                if line.strip().startswith(f"{name}:"):
                    customer_line = line
                    break
            _dynamic_test(
                self,
                customer_line is not None and "Below Average Logins" in customer_line,
                f"Customer {name} correctly flagged as below average",
                f"Customer {name} not flagged as below average in output: {output}",
            )
        for name in ["Alice", "Carla"]:
            customer_line = None
            for line in output.split("\\n"):
                if line.strip().startswith(f"{name}:"):
                    customer_line = line
                    break
            _dynamic_test(
                self,
                customer_line is not None and "Below Average Logins" not in customer_line,
                f"Customer {name} correctly not flagged as below average",
                f"Customer {name} incorrectly flagged as below average in output: {output}",
            )

    def test_engagement_score_calculation(self):
        output = self._run_user_code()
        expected_scores = {
            "Alice": 11,
            "Bob": 4,
            "Carla": 15,
            "David": 3,
            "Ella": 8
        }
        for name, score in expected_scores.items():
            _dynamic_test(
                self,
                f"{name}: Engagement Score = {score}" in output,
                f"Engagement score for {name} is correct",
                f"Engagement score for {name} is incorrect or missing in output: {output}",
            )

    def test_summary_report_format(self):
        output = self._run_user_code()
        # Normalize by removing whitespace and lowercasing
        lines = [normalize_text(line) for line in output.strip().split('\\n') if line.strip()]
        expected_lines = [
            "alice: engagement score = 11",
            "bob: engagement score = 4 (below average logins)",
            "carla: engagement score = 15",
            "david: engagement score = 3 (below average logins)",
            "ella: engagement score = 8 (below average logins)"
        ]
        for expected in expected_lines:
            _dynamic_test(
                self,
                any(expected in line for line in lines),
                f"Summary line present: {expected}",
                f"Expected summary line not found: {expected}\\nOutput: {lines}",
            )

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 automate, analyze, and optimize tasks relevant to Customer Success Managers. This course focuses on practical applications of Python for customer data analysis, reporting, and workflow automation, tailored for professionals with basic Python knowledge.

Explore foundational techniques for analyzing customer data using Python. Learn to summarize, filter, and extract insights from customer datasets relevant to Customer Success Managers.

Delve into methods for assessing customer health and predicting churn using Python. Learn to build simple models and interpret their results for proactive Customer Success management.

Discover how Python can automate repetitive tasks and streamline workflows for Customer Success Managers, from reporting to customer outreach.

Challenge: Analyze Customer Engagement

Soluzione