How to Mentor Junior Developers in 2026: 5 Strategies That Improve Retention by 40%

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from typing import List, Dict, Optional
import logging
from dataclasses import dataclass

# Configure logging to track matching decisions
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

@dataclass
class JuniorDev:
    id: str
    name: str
    skills: List[str]  # Current skill set (e.g., ["python", "docker"])
    skill_gaps: List[str]  # Skills they want to learn
    availability: int  # Hours per week available for mentorship
    learning_style: str  # "hands-on", "reading", "pairing"
    start_date: datetime  # Onboarding date

@dataclass
class Mentor:
    id: str
    name: str
    skills: List[str]  # Skills they can mentor in
    capacity: int  # Max juniors they can mentor simultaneously
    current_juniors: int  # Current number of mentees
    availability: int  # Hours per week available for mentorship
    preferred_learning_styles: List[str]
    last_matched: Optional[datetime]  # Last time they were assigned a mentee

class MentorshipMatcher:
    def __init__(self, min_match_score: float = 0.7):
        self.min_match_score = min_match_score
        self.juniors = []
        self.mentors = []
        logger.info(f"Initialized MentorshipMatcher with min match score {min_match_score}")

    def add_junior(self, junior: JuniorDev) -> None:
        """Add a junior developer to the matching pool"""
        if any(j.id == junior.id for j in self.juniors):
            logger.error(f"Junior with ID {junior.id} already exists in pool")
            raise ValueError(f"Duplicate junior ID: {junior.id}")
        self.juniors.append(junior)
        logger.info(f"Added junior {junior.name} (ID: {junior.id}) to pool")

    def add_mentor(self, mentor: Mentor) -> None:
        """Add a mentor to the matching pool"""
        if any(m.id == mentor.id for m in self.mentors):
            logger.error(f"Mentor with ID {mentor.id} already exists in pool")
            raise ValueError(f"Duplicate mentor ID: {mentor.id}")
        if mentor.current_juniors >= mentor.capacity:
            logger.warning(f"Mentor {mentor.name} is already at full capacity")
        self.mentors.append(mentor)
        logger.info(f"Added mentor {mentor.name} (ID: {mentor.id}) to pool")

    def _calculate_skill_overlap(self, junior: JuniorDev, mentor: Mentor) -> float:
        """Calculate percentage of junior's skill gaps covered by mentor's skills"""
        if not junior.skill_gaps:
            return 1.0
        overlapping = len(set(junior.skill_gaps) & set(mentor.skills))
        return overlapping / len(junior.skill_gaps)

    def _calculate_availability_match(self, junior: JuniorDev, mentor: Mentor) -> float:
        """Check if mentor has enough capacity and availability overlap"""
        if mentor.current_juniors >= mentor.capacity:
            return 0.0
        # Assume 2 hours per week per mentee minimum
        required_mentor_hours = 2 * (mentor.current_juniors + 1)
        if mentor.availability < required_mentor_hours:
            return 0.0
        if junior.availability < 2:
            return 0.0
        return 1.0

    def _calculate_learning_style_match(self, junior: JuniorDev, mentor: Mentor) -> float:
        """Check if mentor supports junior's learning style"""
        if junior.learning_style in mentor.preferred_learning_styles:
            return 1.0
        return 0.5  # Partial match if not explicitly preferred

    def calculate_match_score(self, junior: JuniorDev, mentor: Mentor) -> float:
        """Calculate overall match score between 0 and 1"""
        try:
            skill_score = self._calculate_skill_overlap(junior, mentor) * 0.5
            availability_score = self._calculate_availability_match(junior, mentor) * 0.3
            learning_style_score = self._calculate_learning_style_match(junior, mentor) * 0.2
            total = skill_score + availability_score + learning_style_score
            logger.debug(f"Match score for {junior.name} and {mentor.name}: {total:.2f}")
            return total
        except Exception as e:
            logger.error(f"Error calculating match score: {e}")
            return 0.0

    def match_all(self) -> Dict[str, Optional[str]]:
        """Match all juniors to best available mentor"""
        matches = {}
        # Sort mentors by last matched date to distribute load fairly
        sorted_mentors = sorted(self.mentors, key=lambda m: m.last_matched or datetime.min)
        for junior in self.juniors:
            best_mentor = None
            best_score = 0.0
            for mentor in sorted_mentors:
                score = self.calculate_match_score(junior, mentor)
                if score > best_score and score >= self.min_match_score:
                    best_score = score
                    best_mentor = mentor
            if best_mentor:
                matches[junior.id] = best_mentor.id
                best_mentor.current_juniors += 1
                best_mentor.last_matched = datetime.now()
                logger.info(f"Matched junior {junior.name} to mentor {best_mentor.name} (score: {best_score:.2f})")
            else:
                matches[junior.id] = None
                logger.warning(f"No suitable mentor found for junior {junior.name}")
        return matches

if __name__ == "__main__":
    # Example usage
    matcher = MentorshipMatcher(min_match_score=0.6)
    # Add sample juniors
    juniors = [
        JuniorDev(
            id="j001",
            name="Alex Kim",
            skills=["python", "git"],
            skill_gaps=["kubernetes", "rust"],
            availability=4,
            learning_style="pairing",
            start_date=datetime(2026, 1, 15)
        ),
        JuniorDev(
            id="j002",
            name="Priya Patel",
            skills=["javascript", "react"],
            skill_gaps=["typescript", "nextjs"],
            availability=3,
            learning_style="hands-on",
            start_date=datetime(2026, 2, 1)
        )
    ]
    for j in juniors:
        matcher.add_junior(j)
    # Add sample mentors
    mentors = [
        Mentor(
            id="m001",
            name="Sam Rivera",
            skills=["python", "kubernetes", "rust"],
            capacity=3,
            current_juniors=1,
            availability=8,
            preferred_learning_styles=["pairing", "hands-on"],
            last_matched=datetime(2026, 1, 10)
        ),
        Mentor(
            id="m002",
            name="Jordan Lee",
            skills=["javascript", "typescript", "nextjs"],
            capacity=2,
            current_juniors=0,
            availability=6,
            preferred_learning_styles=["hands-on", "reading"],
            last_matched=None
        )
    ]
    for m in mentors:
        matcher.add_mentor(m)
    # Run matching
    matches = matcher.match_all()
    print("Mentorship Matches:")
    for jid, mid in matches.items():
        junior = next(j for j in juniors if j.id == jid)
        if mid:
            mentor = next(m for m in mentors if m.id == mid)
            print(f"{junior.name} -> {mentor.name}")
        else:
            print(f"{junior.name} -> No match found")

import sqlite3
import datetime
import smtplib
import os
from email.mime.text import MIMEText
from typing import List, Dict, Optional
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class MentorshipTracker:
    def __init__(self, db_path: str = "mentorship.db"):
        self.db_path = db_path
        self._init_db()
        logger.info(f"Initialized MentorshipTracker with DB at {db_path}")

    def _init_db(self) -> None:
        """Create database tables if they don't exist"""
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                # Juniors table
                cursor.execute('''
                    CREATE TABLE IF NOT EXISTS juniors (
                        id TEXT PRIMARY KEY,
                        name TEXT NOT NULL,
                        start_date TEXT NOT NULL,
                        current_level TEXT DEFAULT 'junior'
                    )
                ''')
                # Mentors table
                cursor.execute('''
                    CREATE TABLE IF NOT EXISTS mentors (
                        id TEXT PRIMARY KEY,
                        name TEXT NOT NULL,
                        email TEXT NOT NULL UNIQUE
                    )
                ''')
                # Matches table (links juniors to mentors)
                cursor.execute('''
                    CREATE TABLE IF NOT EXISTS matches (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        junior_id TEXT NOT NULL,
                        mentor_id TEXT NOT NULL,
                        start_date TEXT NOT NULL,
                        end_date TEXT,
                        FOREIGN KEY (junior_id) REFERENCES juniors(id),
                        FOREIGN KEY (mentor_id) REFERENCES mentors(id)
                    )
                ''')
                # Milestones table (tracks progress)
                cursor.execute('''
                    CREATE TABLE IF NOT EXISTS milestones (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        match_id INTEGER NOT NULL,
                        milestone_type TEXT NOT NULL,  # e.g., "first_pr", "1:1_completed"
                        target_date TEXT NOT NULL,
                        completed_date TEXT,
                        FOREIGN KEY (match_id) REFERENCES matches(id)
                    )
                ''')
                # 1:1 logs table
                cursor.execute('''
                    CREATE TABLE IF NOT EXISTS one_on_ones (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        match_id INTEGER NOT NULL,
                        date TEXT NOT NULL,
                        notes TEXT,
                        action_items TEXT,
                        FOREIGN KEY (match_id) REFERENCES matches(id)
                    )
                ''')
                conn.commit()
                logger.info("Database tables initialized successfully")
        except sqlite3.Error as e:
            logger.error(f"Failed to initialize database: {e}")
            raise

    def add_junior(self, junior_id: str, name: str, start_date: datetime.datetime) -> None:
        """Add a junior developer to the tracker"""
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                cursor.execute('''
                    INSERT INTO juniors (id, name, start_date)
                    VALUES (?, ?, ?)
                ''', (junior_id, name, start_date.isoformat()))
                conn.commit()
                logger.info(f"Added junior {name} (ID: {junior_id})")
        except sqlite3.IntegrityError:
            logger.error(f"Junior with ID {junior_id} already exists")
            raise ValueError(f"Duplicate junior ID: {junior_id}")
        except sqlite3.Error as e:
            logger.error(f"Failed to add junior: {e}")
            raise

    def add_mentor(self, mentor_id: str, name: str, email: str) -> None:
        """Add a mentor to the tracker"""
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                cursor.execute('''
                    INSERT INTO mentors (id, name, email)
                    VALUES (?, ?, ?)
                ''', (mentor_id, name, email))
                conn.commit()
                logger.info(f"Added mentor {name} (ID: {mentor_id})")
        except sqlite3.IntegrityError:
            logger.error(f"Mentor with ID {mentor_id} or email {email} already exists")
            raise ValueError(f"Duplicate mentor ID or email")
        except sqlite3.Error as e:
            logger.error(f"Failed to add mentor: {e}")
            raise

    def create_match(self, junior_id: str, mentor_id: str, start_date: datetime.datetime) -> int:
        """Create a mentorship match, return match ID"""
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                # Check if junior and mentor exist
                cursor.execute('SELECT id FROM juniors WHERE id = ?', (junior_id,))
                if not cursor.fetchone():
                    raise ValueError(f"Junior {junior_id} not found")
                cursor.execute('SELECT id FROM mentors WHERE id = ?', (mentor_id,))
                if not cursor.fetchone():
                    raise ValueError(f"Mentor {mentor_id} not found")
                # Check for active match
                cursor.execute('''
                    SELECT id FROM matches 
                    WHERE junior_id = ? AND end_date IS NULL
                ''', (junior_id,))
                if cursor.fetchone():
                    raise ValueError(f"Junior {junior_id} already has an active match")
                cursor.execute('''
                    INSERT INTO matches (junior_id, mentor_id, start_date)
                    VALUES (?, ?, ?)
                ''', (junior_id, mentor_id, start_date.isoformat()))
                conn.commit()
                match_id = cursor.lastrowid
                logger.info(f"Created match ID {match_id} for junior {junior_id} and mentor {mentor_id}")
                return match_id
        except sqlite3.Error as e:
            logger.error(f"Failed to create match: {e}")
            raise

    def add_milestone(self, match_id: int, milestone_type: str, target_date: datetime.datetime) -> None:
        """Add a progress milestone for a match"""
        valid_types = ["first_pr", "first_code_review", "1:1_completed", "skill_assessment"]
        if milestone_type not in valid_types:
            raise ValueError(f"Invalid milestone type. Must be one of {valid_types}")
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                cursor.execute('''
                    INSERT INTO milestones (match_id, milestone_type, target_date)
                    VALUES (?, ?, ?)
                ''', (match_id, milestone_type, target_date.isoformat()))
                conn.commit()
                logger.info(f"Added milestone {milestone_type} for match {match_id}")
        except sqlite3.Error as e:
            logger.error(f"Failed to add milestone: {e}")
            raise

    def complete_milestone(self, milestone_id: int) -> None:
        """Mark a milestone as completed"""
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                cursor.execute('''
                    UPDATE milestones 
                    SET completed_date = ?
                    WHERE id = ? AND completed_date IS NULL
                ''', (datetime.datetime.now().isoformat(), milestone_id))
                if cursor.rowcount == 0:
                    raise ValueError(f"Milestone {milestone_id} not found or already completed")
                conn.commit()
                logger.info(f"Completed milestone ID {milestone_id}")
        except sqlite3.Error as e:
            logger.error(f"Failed to complete milestone: {e}")
            raise

    def send_alert(self, recipient_email: str, subject: str, body: str) -> None:
        """Send email alert for overdue milestones or issues"""
        smtp_server = os.getenv("SMTP_SERVER", "smtp.gmail.com")
        smtp_port = int(os.getenv("SMTP_PORT", 587))
        sender_email = os.getenv("SENDER_EMAIL")
        sender_password = os.getenv("SENDER_PASSWORD")
        if not all([smtp_server, smtp_port, sender_email, sender_password]):
            logger.error("SMTP credentials not configured")
            raise ValueError("Missing SMTP configuration")
        msg = MIMEText(body)
        msg["Subject"] = subject
        msg["From"] = sender_email
        msg["To"] = recipient_email
        try:
            with smtplib.SMTP(smtp_server, smtp_port) as server:
                server.starttls()
                server.login(sender_email, sender_password)
                server.send_message(msg)
                logger.info(f"Sent alert to {recipient_email}")
        except Exception as e:
            logger.error(f"Failed to send alert: {e}")
            raise

    def check_overdue_milestones(self) -> List[Dict]:
        """Check for milestones past their target date that are not completed"""
        try:
            with sqlite3.connect(self.db_path) as conn:
                conn.row_factory = sqlite3.Row
                cursor = conn.cursor()
                cursor.execute('''
                    SELECT m.id, m.milestone_type, m.target_date, ma.junior_id, ma.mentor_id
                    FROM milestones m
                    JOIN matches ma ON m.match_id = ma.id
                    WHERE m.completed_date IS NULL AND m.target_date < ?
                ''', (datetime.datetime.now().isoformat(),))
                overdue = [dict(row) for row in cursor.fetchall()]
                logger.info(f"Found {len(overdue)} overdue milestones")
                return overdue
        except sqlite3.Error as e:
            logger.error(f"Failed to check overdue milestones: {e}")
            raise

if __name__ == "__main__":
    # Example usage
    tracker = MentorshipTracker(db_path="mentorship_tracker.db")
    # Add sample data
    tracker.add_junior("j001", "Alex Kim", datetime.datetime(2026, 1, 15))
    tracker.add_mentor("m001", "Sam Rivera", "sam.rivera@example.com")
    match_id = tracker.create_match("j001", "m001", datetime.datetime(2026, 1, 15))
    # Add first PR milestone (target 30 days after start)
    target = datetime.datetime(2026, 2, 14)
    tracker.add_milestone(match_id, "first_pr", target)
    # Check for overdue milestones
    overdue = tracker.check_overdue_milestones()
    if overdue:
        print(f"Found {len(overdue)} overdue milestones:")
        for item in overdue:
            print(f"Milestone {item['id']} ({item['milestone_type']}) is overdue")
    else:
        print("No overdue milestones")

import pandas as pd
import sqlite3
import datetime
import matplotlib.pyplot as plt
from typing import Dict, List
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class MentorshipAnalytics:
    def __init__(self, db_path: str = "mentorship.db"):
        self.db_path = db_path
        self.conn = None
        logger.info(f"Initialized MentorshipAnalytics with DB at {db_path}")

    def _connect(self) -> sqlite3.Connection:
        """Create a database connection"""
        try:
            conn = sqlite3.connect(self.db_path)
            return conn
        except sqlite3.Error as e:
            logger.error(f"Failed to connect to database: {e}")
            raise

    def get_retention_data(self, start_date: datetime.datetime, end_date: datetime.datetime) -> pd.DataFrame:
        """Get junior retention data for a given period"""
        query = '''
            SELECT j.id, j.name, j.start_date, m.end_date
            FROM juniors j
            LEFT JOIN matches ma ON j.id = ma.junior_id
            LEFT JOIN matches m ON j.id = m.junior_id AND m.end_date IS NOT NULL
            WHERE j.start_date BETWEEN ? AND ?
        '''
        try:
            with self._connect() as conn:
                df = pd.read_sql_query(query, conn, params=(start_date.isoformat(), end_date.isoformat()))
                # Calculate retention: if no end date, still employed
                df["is_retained"] = df["end_date"].isna()
                logger.info(f"Retrieved retention data for {len(df)} juniors")
                return df
        except Exception as e:
            logger.error(f"Failed to get retention data: {e}")
            raise

    def calculate_attrition_rate(self, start_date: datetime.datetime, end_date: datetime.datetime) -> float:
        """Calculate attrition rate for juniors in period"""
        df = self.get_retention_data(start_date, end_date)
        if len(df) == 0:
            return 0.0
        attrition = (~df["is_retained"]).sum()
        rate = (attrition / len(df)) * 100
        logger.info(f"Attrition rate: {rate:.2f}% for {len(df)} juniors")
        return rate

    def get_mentor_performance(self) -> pd.DataFrame:
        """Get performance metrics per mentor"""
        try:
            with self._connect() as conn:
                query = '''
                    SELECT me.id, me.name, COUNT(ma.id) as total_mentees,
                           SUM(CASE WHEN ma.end_date IS NULL THEN 1 ELSE 0 END) as active_mentees,
                           j.start_date, ma.end_date
                    FROM mentors me
                    LEFT JOIN matches ma ON me.id = ma.mentor_id
                    LEFT JOIN juniors j ON ma.junior_id = j.id
                    WHERE ma.id IS NOT NULL
                '''
                df = pd.read_sql_query(query, conn)
                df["start_date"] = pd.to_datetime(df["start_date"])
                df["end_date"] = pd.to_datetime(df["end_date"])
                df["tenure_days"] = (df["end_date"].fillna(datetime.datetime.now()) - df["start_date"]).dt.days
                perf_df = df.groupby(["id", "name"]).agg(
                    total_mentees=("id", "count"),
                    active_mentees=("end_date", lambda x: (x.isna()).sum()),
                    avg_tenure_days=("tenure_days", "mean")
                ).reset_index()
                logger.info(f"Retrieved performance data for {len(perf_df)} mentors")
                return perf_df
        except Exception as e:
            logger.error(f"Failed to get mentor performance: {e}")
            raise

    def generate_retention_report(self, output_path: str = "retention_report.html") -> None:
        """Generate HTML retention report with charts"""
        end_date = datetime.datetime.now()
        start_date = end_date - datetime.timedelta(days=365)
        df = self.get_retention_data(start_date, end_date)
        attrition_rate = self.calculate_attrition_rate(start_date, end_date)
        # Generate bar chart of retention by month
        df["start_month"] = pd.to_datetime(df["start_date"]).dt.to_period("M")
        retention_by_month = df.groupby("start_month")["is_retained"].mean().reset_index()
        plt.figure(figsize=(10, 6))
        plt.bar(retention_by_month["start_month"].astype(str), retention_by_month["is_retained"] * 100)
        plt.xlabel("Start Month")
        plt.ylabel("Retention Rate (%)")
        plt.title("Junior Retention Rate by Start Month")
        plt.xticks(rotation=45)
        plt.tight_layout()
        chart_path = "retention_chart.png"
        plt.savefig(chart_path)
        plt.close()
        # Generate HTML report
        html_content = f'''




            Mentorship Retention Report
            Period: {start_date.date()} to {end_date.date()}
            Overall Attrition Rate: {attrition_rate:.2f}%
            Total Juniors Tracked: {len(df)}
            Retention by Start Month

            Raw Data
            {df.to_html(index=False)}


        '''
        with open(output_path, "w") as f:
            f.write(html_content)
        logger.info(f"Generated retention report at {output_path}")

    def compare_strategies(self, strategy_a_df: pd.DataFrame, strategy_b_df: pd.DataFrame) -> Dict:
        """Compare retention between two mentorship strategies"""
        if len(strategy_a_df) == 0 or len(strategy_b_df) == 0:
            raise ValueError("Both strategy dataframes must be non-empty")
        a_attrition = (~strategy_a_df["is_retained"]).mean() * 100
        b_attrition = (~strategy_b_df["is_retained"]).mean() * 100
        improvement = a_attrition - b_attrition
        result = {
            "strategy_a_attrition": a_attrition,
            "strategy_b_attrition": b_attrition,
            "improvement_percentage_points": improvement,
            "relative_improvement": (improvement / a_attrition) * 100 if a_attrition > 0 else 0
        }
        logger.info(f"Strategy comparison: A attrition {a_attrition:.2f}%, B attrition {b_attrition:.2f}%")
        return result

if __name__ == "__main__":
    # Example usage
    analytics = MentorshipAnalytics(db_path="mentorship_tracker.db")
    # Calculate attrition for last 6 months
    end = datetime.datetime.now()
    start = end - datetime.timedelta(days=180)
    attrition = analytics.calculate_attrition_rate(start, end)
    print(f"Attrition rate (last 6 months): {attrition:.2f}%")
    # Generate report
    analytics.generate_retention_report()
    print("Retention report generated: retention_report.html")
    # Get mentor performance
    perf = analytics.get_mentor_performance()
    print("\nMentor Performance:")
    print(perf.to_string(index=False))

# Adjust scoring weights for capacity-constrained teams
def calculate_match_score(self, junior: JuniorDev, mentor: Mentor) -> float:
    skill_score = self._calculate_skill_overlap(junior, mentor) * 0.3  # Reduced from 0.5
    availability_score = self._calculate_availability_match(junior, mentor) * 0.5  # Increased from 0.3
    learning_style_score = self._calculate_learning_style_match(junior, mentor) * 0.2
    return skill_score + availability_score + learning_style_score

# Webhook handler to auto-complete first PR milestone
def handle_github_pr_webhook(pr_data: dict, tracker: MentorshipTracker):
    if pr_data["action"] == "merged" and pr_data["author"]["id"] in junior_ids:
        junior_id = pr_data["author"]["id"]
        # Find active match for junior
        match_id = get_active_match_id(junior_id)
        # Get first_pr milestone for match
        milestone_id = get_milestone_id(match_id, "first_pr")
        tracker.complete_milestone(milestone_id)
        logger.info(f"Auto-completed first PR milestone for junior {junior_id}")

# Compare control group vs new training program
control_df = analytics.get_retention_data(control_start, control_end)
test_df = analytics.get_retention_data(test_start, test_end)
results = analytics.compare_strategies(control_df, test_df)
print(f"Attrition improvement: {results['improvement_percentage_points']:.1f} percentage points")

mentorship-2026/
├── matcher/                # Mentorship matching algorithm
│   ├── __init__.py
│   ├── matcher.py          # MentorshipMatcher class
│   └── tests/              # Unit tests for matcher
│       └── test_matcher.py
├── tracker/                # Progress tracking and alerts
│   ├── __init__.py
│   ├── tracker.py          # MentorshipTracker class
│   └── tests/
│       └── test_tracker.py
├── analytics/              # Reporting and analytics
│   ├── __init__.py
│   ├── analytics.py        # MentorshipAnalytics class
│   └── tests/
│       └── test_analytics.py
├── data/                   # Sample data and benchmarks
│   ├── sample_juniors.csv
│   ├── sample_mentors.csv
│   └── 2026_benchmark_data.csv
├── docs/                   # Documentation and case studies
│   └── CASE_STUDY_FINTECH.md
├── requirements.txt        # Python dependencies
└── README.md               # Setup and usage instructions