Ultimate-Python-Bootcamp-50-Hands-On-Projects

```python
# Automated Lead Follow-Up System for Sales Teams
# Integrates with Sortd (Gmail Kanban) to track and automate email follow-ups
# Uses Python 3.10+, requests, and pytz for timezone handling

import os
import requests
from datetime import datetime, timedelta
import pytz
from typing import Dict, List
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class SortdAutomation:
    def __init__(self, api_key: str, board_id: str = None):
        """
        Initialize Sortd automation with API credentials
        :param api_key: Sortd API key from account settings
        :param board_id: Optional board ID to target specific workflows
        """
        self.api_key = api_key
        self.base_url = "https://api.sortd.com/v1"
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        self.board_id = board_id
        
    def get_cards_in_stage(self, stage_name: str) -> List[Dict]:
        """
        Retrieve all cards in a specific stage (column) of the Sortd board
        :param stage_name: Name of the stage/column (e.g., 'Follow Up', 'In Progress')
        :return: List of card dictionaries with metadata
        """
        try:
            # Get all boards to find the target board
            boards = self._get_boards()
            target_board = next((b for b in boards if self.board_id in [b['id'], None]), None)
            
            if not target_board:
                raise ValueError(f"Board with ID {self.board_id} not found")
                
            # Get columns for the board
            columns = self._get_columns(target_board['id'])
            target_column = next((c for c in columns if c['name'].lower() == stage_name.lower()), None)
            
            if not target_column:
                raise ValueError(f"Column '{stage_name}' not found in board")
                
            # Get cards in the column
            cards = self._get_cards(target_board['id'], target_column['id'])
            return cards
            
        except Exception as e:
            logger.error(f"Error retrieving cards: {str(e)}")
            return []
    
    def move_card_to_stage(self, card_id: str, stage_name: str, due_date: datetime = None) -> bool:
        """
        Move a card to a specific stage with optional due date
        :param card_id: ID of the card to move
        :param stage_name: Target stage name
        :param due_date: Optional due date for the card
        :return: Success status
        """
        try:
            boards = self._get_boards()
            target_board = next((b for b in boards if self.board_id in [b['id'], None]), None)
            
            if not target_board:
                raise ValueError(f"Board with ID {self.board_id} not found")
                
            columns = self._get_columns(target_board['id'])
            target_column = next((c for c in columns if c['name'].lower() == stage_name.lower()), None)
            
            if not target_column:
                raise ValueError(f"Column '{stage_name}' not found in board")
                
            payload = {
                "column_id": target_column['id'],
                "due_date": due_date.isoformat() if due_date else None
            }
            
            response = requests.put(
                f"{self.base_url}/cards/{card_id}",
                headers=self.headers,
                json=payload
            )
            
            if response.status_code == 200:
                logger.info(f"Successfully moved card {card_id} to {stage_name}")
                return True
            else:
                logger.error(f"Failed to move card: {response.text}")
                return False
                
        except Exception as e:
            logger.error(f"Error moving card: {str(e)}")
            return False
    
    def _get_boards(self) -> List[Dict]:
        """Internal method to fetch all boards"""
        response = requests.get(f"{self.base_url}/boards", headers=self.headers)
        response.raise_for_status()
        return response.json()
    
    def _get_columns(self, board_id: str) -> List[Dict]:
        """Internal method to fetch columns for a board"""
        response = requests.get(f"{self.base_url}/boards/{board_id}/columns", headers=self.headers)
        response.raise_for_status()
        return response.json()
    
    def _get_cards(self, board_id: str, column_id: str) -> List[Dict]:
        """Internal method to fetch cards in a column"""
        response = requests.get(
            f"{self.base_url}/boards/{board_id}/columns/{column_id}/cards",
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Example usage
if __name__ == "__main__":
    # Configuration - replace with your actual credentials
    API_KEY = os.getenv("SORTD_API_KEY", "your-api-key-here")
    BOARD_ID = os.getenv("SORTD_BOARD_ID", "sales-pipeline-board")
    
    # Initialize automation
    sortd_automation = SortdAutomation(api_key=API_KEY, board_id=BOARD_ID)
    
    # Get cards in 'Follow Up' stage
    follow_up_cards = sortd_automation.get_cards_in_stage("Follow Up")
    
    # Process each card
    for card in follow_up_cards:
        card_id = card['id']
        card_title = card['title']
        
        # Example: Automatically move cards older than 7 days to 'At Risk'
        created_at = datetime.fromisoformat(card['created_at'])
        if (datetime.now(pytz.UTC) - created_at) > timedelta(days=7):
            sortd_automation.move_card_to_stage(
                card_id=card_id,
                stage_name="At Risk",
                due_date=datetime.now(pytz.UTC) + timedelta(days=3)
            )
            logger.info(f"Moved overdue card '{card_title}' to At Risk stage")
```

## README.md

```markdown
# Sortd Python Automation Script

Automates sales pipeline management by integrating with Sortd's Gmail Kanban boards.

## Features

- Retrieve cards from specific stages in your Sortd board
- Move cards between stages with optional due dates
- Automate follow-up workflows based on card age
- Handle error cases and edge scenarios

## Prerequisites

- Python 3.10+
- Sortd API key (from Sortd account settings)
- Requests library (`pip install requests pytz`)

## Setup

1. Clone the repository:
   ```bash
   git clone https://github.com/your-repo/ultimate-python-bootcamp.git
   cd ultimate-python-bootcamp/sortd-automation
   ```

2. Create a `.env` file with your credentials:
   ```
   SORTD_API_KEY=your-api-key-here
   SORTD_BOARD_ID=sales-pipeline-board
   ```

3. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

## Usage

Run the automation script:
```bash
python sortd_automation.py
```

## Customization

Modify the `main` block to implement your specific automation logic:
- Change stage names to match your board
- Adjust time thresholds for card movement
- Add additional metadata processing

## Error Handling

The script includes comprehensive error handling for:
- Invalid API keys
- Missing boards/columns
- Network issues
- Rate limiting

## Advanced Integration

For production use, consider:
- Adding logging to a file
- Implementing retry logic for API calls
- Creating a configuration file for different environments
- Adding unit tests with pytest
```