undefined

undefined

undefined

undefined

from trello import TrelloClient
import os

client = TrelloClient(
    api_key=os.environ["TRELLO_API_KEY"],
    token=os.environ["TRELLO_TOKEN"]
)

undefined

undefined

**Python SDK - Boards:**
```python
from trello import TrelloClient
import os

client = TrelloClient(
    api_key=os.environ["TRELLO_API_KEY"],
    token=os.environ["TRELLO_TOKEN"]
)

undefined

undefined

**Python SDK - Lists:**
```python
from trello import TrelloClient
import os

client = TrelloClient(
    api_key=os.environ["TRELLO_API_KEY"],
    token=os.environ["TRELLO_TOKEN"]
)

board = client.get_board("BOARD_ID")

undefined

undefined

**Python SDK - Cards:**
```python
from trello import TrelloClient
from datetime import datetime, timedelta
import os

client = TrelloClient(
    api_key=os.environ["TRELLO_API_KEY"],
    token=os.environ["TRELLO_TOKEN"]
)

board = client.get_board("BOARD_ID")
target_list = board.get_list("LIST_ID")

undefined

undefined

**Python SDK - Labels:**
```python

undefined

undefined

**Python SDK - Checklists:**
```python

undefined

undefined

**Python SDK - Members:**
```python

undefined

undefined

**Webhook Handler Example:**
```python
from flask import Flask, request, jsonify
import json

app = Flask(__name__)

@app.route("/webhook/trello", methods=["HEAD", "POST"])
def trello_webhook():
    # HEAD request is for webhook verification
    if request.method == "HEAD":
        return "", 200

    # Process webhook payload
    data = request.json

    action = data.get("action", {})
    action_type = action.get("type")

    print(f"Received Trello webhook: {action_type}")

    # Handle different action types
    if action_type == "createCard":
        handle_card_created(action)
    elif action_type == "updateCard":
        handle_card_updated(action)
    elif action_type == "moveCardToBoard":
        handle_card_moved(action)
    elif action_type == "addMemberToCard":
        handle_member_assigned(action)
    elif action_type == "commentCard":
        handle_comment_added(action)
    elif action_type == "updateCheckItemStateOnCard":
        handle_checklist_item_updated(action)

    return jsonify({"status": "ok"})


def handle_card_created(action):
    card_data = action.get("data", {}).get("card", {})
    print(f"Card created: {card_data.get('name')}")


def handle_card_updated(action):
    card_data = action.get("data", {}).get("card", {})
    old_data = action.get("data", {}).get("old", {})
    print(f"Card updated: {card_data.get('name')}")

    # Check if moved to different list
    if "idList" in old_data:
        list_after = action.get("data", {}).get("listAfter", {})
        list_before = action.get("data", {}).get("listBefore", {})
        print(f"  Moved from '{list_before.get('name')}' to '{list_after.get('name')}'")


def handle_card_moved(action):
    card_data = action.get("data", {}).get("card", {})
    print(f"Card moved to different board: {card_data.get('name')}")


def handle_member_assigned(action):
    card_data = action.get("data", {}).get("card", {})
    member_data = action.get("data", {}).get("member", {})
    print(f"Member {member_data.get('username')} assigned to: {card_data.get('name')}")


def handle_comment_added(action):
    card_data = action.get("data", {}).get("card", {})
    text = action.get("data", {}).get("text", "")
    print(f"Comment on {card_data.get('name')}: {text[:100]}")


def handle_checklist_item_updated(action):
    card_data = action.get("data", {}).get("card", {})
    item = action.get("data", {}).get("checkItem", {})
    state = item.get("state")
    print(f"Checklist item '{item.get('name')}' marked {state}")


if __name__ == "__main__":
    app.run(port=5000)

undefined

# List events
"createList": "List created",
"updateList": "List updated (renamed, moved, archived)",
"moveListToBoard": "List moved to different board",

# Card events
"createCard": "Card created",
"updateCard": "Card updated (name, desc, due date, position, list)",
"deleteCard": "Card deleted",
"moveCardToBoard": "Card moved to different board",
"copyCard": "Card copied",
"convertToCardFromCheckItem": "Checklist item converted to card",

# Card member events
"addMemberToCard": "Member assigned to card",
"removeMemberFromCard": "Member removed from card",

# Card label events
"addLabelToCard": "Label added to card",
"removeLabelFromCard": "Label removed from card",

# Card attachment events
"addAttachmentToCard": "Attachment added",
"deleteAttachmentFromCard": "Attachment deleted",

# Comment events
"commentCard": "Comment added to card",
"updateComment": "Comment updated",
"deleteComment": "Comment deleted",

# Checklist events
"addChecklistToCard": "Checklist added to card",
"removeChecklistFromCard": "Checklist removed",
"updateChecklist": "Checklist updated",
"updateCheckItemStateOnCard": "Checklist item checked/unchecked",
"createCheckItem": "Checklist item created",
"deleteCheckItem": "Checklist item deleted",

undefined

undefined

**Python Custom Fields:**
```python
import requests
import os

API_KEY = os.environ["TRELLO_API_KEY"]
TOKEN = os.environ["TRELLO_TOKEN"]

def get_custom_fields(board_id):
    """Get all custom fields for a board."""
    url = f"https://api.trello.com/1/boards/{board_id}/customFields"
    response = requests.get(url, params={"key": API_KEY, "token": TOKEN})
    return response.json()


def set_custom_field_value(card_id, field_id, value, field_type="text"):
    """Set custom field value on a card."""
    url = f"https://api.trello.com/1/cards/{card_id}/customField/{field_id}/item"

    # Build value based on type
    if field_type == "number":
        data = {"value": {"number": str(value)}}
    elif field_type == "text":
        data = {"value": {"text": value}}
    elif field_type == "checkbox":
        data = {"value": {"checked": str(value).lower()}}
    elif field_type == "date":
        data = {"value": {"date": value}}  # ISO format
    elif field_type == "list":
        data = {"idValue": value}  # Option ID for dropdown
    else:
        data = {"value": {"text": str(value)}}

    response = requests.put(
        url,
        json={**data, "key": API_KEY, "token": TOKEN}
    )
    return response.json()


def get_card_custom_fields(card_id):
    """Get all custom field values for a card."""
    url = f"https://api.trello.com/1/cards/{card_id}/customFieldItems"
    response = requests.get(url, params={"key": API_KEY, "token": TOKEN})
    return response.json()

undefined

#!/usr/bin/env python3
"""sprint_automation.py - Automate sprint board management"""

from trello import TrelloClient
from datetime import datetime, timedelta
import os
import json

def create_sprint_board(client, sprint_name, team_members=None):
    """
    Create a new sprint board with standard structure.

    Args:
        client: TrelloClient instance
        sprint_name: Name for the sprint
        team_members: List of member usernames to add

    Returns:
        Created board object
    """
    # Create board
    board = client.add_board(
        board_name=f"Sprint: {sprint_name}",
        permission_level="private"
    )
    print(f"Created board: {board.name}")

    # Create standard sprint lists
    lists_config = [
        {"name": "Backlog", "pos": "bottom"},
        {"name": "To Do", "pos": "bottom"},
        {"name": "In Progress", "pos": "bottom"},
        {"name": "In Review", "pos": "bottom"},
        {"name": "Done", "pos": "bottom"},
    ]

    created_lists = {}
    for list_cfg in lists_config:
        new_list = board.add_list(name=list_cfg["name"])
        created_lists[list_cfg["name"]] = new_list
        print(f"  Created list: {list_cfg['name']}")

    # Create standard labels
    labels_config = [
        {"name": "Bug", "color": "red"},
        {"name": "Feature", "color": "green"},
        {"name": "Enhancement", "color": "blue"},
        {"name": "Technical Debt", "color": "orange"},
        {"name": "Documentation", "color": "purple"},
        {"name": "Blocked", "color": "black"},
    ]

    for label_cfg in labels_config:
        board.add_label(name=label_cfg["name"], color=label_cfg["color"])
        print(f"  Created label: {label_cfg['name']}")

    # Add sprint info card
    sprint_end = datetime.now() + timedelta(days=14)
    info_card = created_lists["Backlog"].add_card(
        name="Sprint Information",
        desc=f"""# Sprint: {sprint_name}

**Start Date:** {datetime.now().strftime('%Y-%m-%d')}
**End Date:** {sprint_end.strftime('%Y-%m-%d')}

# Add checklist for sprint ceremonies
info_card.add_checklist(
    title="Sprint Ceremonies",
    items=[
        "Sprint Planning",
        "Daily Standup (Day 1-10)",
        "Sprint Review",
        "Sprint Retrospective"
    ]
)

return board, created_lists

Args:
    board: Board object
    lists: Dictionary of list objects by name
    tasks: List of task dictionaries
"""
labels = {label.name: label for label in board.get_labels()}

for task in tasks:
    list_name = task.get("list", "Backlog")
    target_list = lists.get(list_name)

    if not target_list:
        print(f"Warning: List '{list_name}' not found")
        continue

    # Create card
    card = target_list.add_card(
        name=task["name"],
        desc=task.get("description", ""),
        due=task.get("due_date")
    )

    # Add labels
    for label_name in task.get("labels", []):
        if label_name in labels:
            card.add_label(labels[label_name])

    # Add checklist if provided
    if "checklist" in task:
        card.add_checklist(
            title=task["checklist"].get("name", "Tasks"),
            items=task["checklist"].get("items", [])
        )

    print(f"  Created task: {task['name']}")

for lst in lists:
    cards = lst.list_cards()
    list_cards[lst.name] = cards

total_cards = sum(len(cards) for cards in list_cards.values())
done_cards = len(list_cards.get("Done", []))

report = {
    "board_name": board.name,
    "generated_at": datetime.now().isoformat(),
    "total_tasks": total_cards,
    "completed_tasks": done_cards,
    "completion_percentage": round(done_cards / total_cards * 100, 1) if total_cards > 0 else 0,
    "by_list": {}
}

for list_name, cards in list_cards.items():
    report["by_list"][list_name] = {
        "count": len(cards),
        "cards": [{"name": c.name, "due": str(c.due_date)} for c in cards]
    }

return report

# Create sprint board
board, lists = create_sprint_board(
    client,
    sprint_name="2025-W05",
    team_members=["user1", "user2"]
)

# Add sample tasks
tasks = [
    {
        "name": "Implement user authentication",
        "description": "Add JWT-based authentication",
        "list": "To Do",
        "labels": ["Feature"],
        "due_date": "2025-02-07",
        "checklist": {
            "name": "Implementation Steps",
            "items": ["Design API", "Implement backend", "Add tests", "Update docs"]
        }
    },
    {
        "name": "Fix login page bug",
        "description": "Users can't login with special characters",
        "list": "To Do",
        "labels": ["Bug"],
        "due_date": "2025-02-03"
    },
    {
        "name": "Refactor database queries",
        "description": "Optimize slow queries",
        "list": "Backlog",
        "labels": ["Technical Debt"]
    }
]

add_sprint_tasks(board, lists, tasks)

# Generate report
report = generate_sprint_report(board)
print(f"\n{'='*50}")
print(f"Sprint Report: {report['board_name']}")
print(f"{'='*50}")
print(f"Total Tasks: {report['total_tasks']}")
print(f"Completed: {report['completed_tasks']} ({report['completion_percentage']}%)")

undefined

#!/usr/bin/env python3
"""card_migration.py - Migrate cards between boards"""

from trello import TrelloClient
import os
import json
from datetime import datetime

def migrate_cards(
    client,
    source_board_id,
    target_board_id,
    list_mapping,
    include_labels=True,
    include_checklists=True,
    include_attachments=False,
    archive_source=False
):
    """
    Migrate cards from source board to target board.

    Args:
        client: TrelloClient instance
        source_board_id: Source board ID
        target_board_id: Target board ID
        list_mapping: Dict mapping source list names to target list names
        include_labels: Copy labels to new cards
        include_checklists: Copy checklists to new cards
        include_attachments: Copy attachments (URLs only)
        archive_source: Archive source cards after migration

    Returns:
        Migration report dictionary
    """
    source_board = client.get_board(source_board_id)
    target_board = client.get_board(target_board_id)

    # Build target lists lookup
    target_lists = {lst.name: lst for lst in target_board.list_lists()}

    # Build target labels lookup
    target_labels = {}
    if include_labels:
        for label in target_board.get_labels():
            target_labels[label.name] = label

    report = {
        "started_at": datetime.now().isoformat(),
        "source_board": source_board.name,
        "target_board": target_board.name,
        "migrated": [],
        "skipped": [],
        "errors": []
    }

    # Process each source list
    for source_list in source_board.list_lists():
        source_list_name = source_list.name

        # Check if this list should be migrated
        if source_list_name not in list_mapping:
            print(f"Skipping list: {source_list_name} (not in mapping)")
            continue

        target_list_name = list_mapping[source_list_name]
        target_list = target_lists.get(target_list_name)

        if not target_list:
            print(f"Warning: Target list '{target_list_name}' not found")
            continue

        print(f"\nMigrating: {source_list_name} -> {target_list_name}")

        # Migrate each card
        for card in source_list.list_cards():
            try:
                # Create new card
                new_card = target_list.add_card(
                    name=card.name,
                    desc=card.description,
                    due=str(card.due_date) if card.due_date else None
                )

                # Copy labels
                if include_labels:
                    for label in card.labels or []:
                        if label.name in target_labels:
                            new_card.add_label(target_labels[label.name])

                # Copy checklists
                if include_checklists:
                    for checklist in card.fetch_checklists():
                        items = [item["name"] for item in checklist.items]
                        new_checklist = new_card.add_checklist(
                            title=checklist.name,
                            items=items
                        )
                        # Copy checked state
                        for item in checklist.items:
                            if item["checked"]:
                                new_checklist.set_checklist_item(
                                    item["name"],
                                    checked=True
                                )

                # Archive source card if requested
                if archive_source:
                    card.set_closed(True)

                report["migrated"].append({
                    "name": card.name,
                    "source_list": source_list_name,
                    "target_list": target_list_name,
                    "new_card_id": new_card.id
                })

                print(f"  Migrated: {card.name}")

            except Exception as e:
                report["errors"].append({
                    "name": card.name,
                    "error": str(e)
                })
                print(f"  Error migrating {card.name}: {e}")

    report["completed_at"] = datetime.now().isoformat()
    report["total_migrated"] = len(report["migrated"])
    report["total_errors"] = len(report["errors"])

    return report

# Define list mapping
list_mapping = {
    "Backlog": "Product Backlog",
    "To Do": "Sprint Backlog",
    "In Progress": "In Development",
    "Done": "Completed"
}

report = migrate_cards(
    client=client,
    source_board_id="SOURCE_BOARD_ID",
    target_board_id="TARGET_BOARD_ID",
    list_mapping=list_mapping,
    include_labels=True,
    include_checklists=True,
    archive_source=False
)

# Save report
with open("migration_report.json", "w") as f:
    json.dump(report, f, indent=2)

print(f"\n{'='*50}")
print(f"Migration Complete!")
print(f"Migrated: {report['total_migrated']} cards")
print(f"Errors: {report['total_errors']}")

undefined

#!/usr/bin/env python3
"""board_analytics.py - Generate board analytics"""

from trello import TrelloClient
from datetime import datetime, timedelta
from collections import defaultdict
import os
import json

def analyze_board(client, board_id, days_back=30):
    """
    Generate comprehensive analytics for a board.

    Args:
        client: TrelloClient instance
        board_id: Board ID to analyze
        days_back: Number of days of history to analyze

    Returns:
        Analytics dictionary
    """
    board = client.get_board(board_id)
    cutoff_date = datetime.now() - timedelta(days=days_back)

    analytics = {
        "board_name": board.name,
        "analyzed_at": datetime.now().isoformat(),
        "period_days": days_back,
        "summary": {},
        "lists": {},
        "labels": {},
        "members": {},
        "cards": {
            "total": 0,
            "with_due_date": 0,
            "overdue": 0,
            "completed": 0
        }
    }

    # Analyze lists
    lists = board.list_lists()
    for lst in lists:
        cards = lst.list_cards()
        analytics["lists"][lst.name] = {
            "card_count": len(cards),
            "cards": []
        }

        for card in cards:
            analytics["cards"]["total"] += 1

            card_info = {
                "name": card.name,
                "has_due": card.due_date is not None,
                "labels": [l.name for l in (card.labels or [])],
                "members": len(card.member_ids) if card.member_ids else 0,
                "checklists": len(card.fetch_checklists())
            }

            if card.due_date:
                analytics["cards"]["with_due_date"] += 1
                if card.due_date < datetime.now() and not card.is_due_complete:
                    analytics["cards"]["overdue"] += 1
                    card_info["overdue"] = True

            analytics["lists"][lst.name]["cards"].append(card_info)

    # Identify done list (common names)
    done_lists = ["Done", "Completed", "Finished", "Closed"]
    for done_name in done_lists:
        if done_name in analytics["lists"]:
            analytics["cards"]["completed"] = analytics["lists"][done_name]["card_count"]
            break

    # Analyze labels
    labels = board.get_labels()
    label_usage = defaultdict(int)

    for lst_data in analytics["lists"].values():
        for card in lst_data["cards"]:
            for label in card["labels"]:
                label_usage[label] += 1

    analytics["labels"] = dict(label_usage)

    # Calculate summary metrics
    total = analytics["cards"]["total"]
    analytics["summary"] = {
        "total_cards": total,
        "total_lists": len(lists),
        "total_labels": len(labels),
        "completion_rate": round(
            analytics["cards"]["completed"] / total * 100, 1
        ) if total > 0 else 0,
        "overdue_rate": round(
            analytics["cards"]["overdue"] / total * 100, 1
        ) if total > 0 else 0,
        "due_date_coverage": round(
            analytics["cards"]["with_due_date"] / total * 100, 1
        ) if total > 0 else 0
    }

    return analytics


def generate_report_markdown(analytics):
    """Generate markdown report from analytics."""
    report = f"""# Board Analytics Report

**Board:** {analytics['board_name']}
**Generated:** {analytics['analyzed_at']}
**Period:** Last {analytics['period_days']} days

for list_name, list_data in analytics["lists"].items():
    report += f"### {list_name} ({list_data['card_count']} cards)\n\n"

    if list_data["cards"]:
        for card in list_data["cards"][:5]:  # Show top 5
            overdue_marker = " [OVERDUE]" if card.get("overdue") else ""
            report += f"- {card['name']}{overdue_marker}\n"
        if len(list_data["cards"]) > 5:
            report += f"- ... and {len(list_data['cards']) - 5} more\n"
    report += "\n"

report += "## Label Usage\n\n"
report += "| Label | Count |\n"
report += "|-------|-------|\n"

for label, count in sorted(
    analytics["labels"].items(),
    key=lambda x: x[1],
    reverse=True
):
    report += f"| {label} | {count} |\n"

return report

# Analyze board
analytics = analyze_board(
    client=client,
    board_id="BOARD_ID",
    days_back=30
)

# Save JSON
with open("board_analytics.json", "w") as f:
    json.dump(analytics, f, indent=2, default=str)

# Generate markdown report
report = generate_report_markdown(analytics)
with open("board_report.md", "w") as f:
    f.write(report)

print("Analytics generated!")
print(f"Total cards: {analytics['summary']['total_cards']}")
print(f"Completion rate: {analytics['summary']['completion_rate']}%")

undefined

undefined

undefined

#!/usr/bin/env python3
"""trello_slack_integration.py - Notify Slack on Trello updates"""

import os
import requests
from flask import Flask, request, jsonify

app = Flask(__name__)

SLACK_WEBHOOK_URL = os.environ["SLACK_WEBHOOK_URL"]

@app.route("/webhook/trello", methods=["HEAD", "POST"])
def trello_webhook():
    if request.method == "HEAD":
        return "", 200

    data = request.json
    action = data.get("action", {})
    action_type = action.get("type")

    # Build Slack message
    message = None

    if action_type == "createCard":
        card = action["data"]["card"]
        list_name = action["data"]["list"]["name"]
        member = action["memberCreator"]["fullName"]

        message = {
            "text": f"New card created by {member}",
            "blocks": [
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": f"*New Card Created*\n"
                                f"*Card:* {card['name']}\n"
                                f"*List:* {list_name}\n"
                                f"*By:* {member}"
                    }
                }
            ]
        }

    elif action_type == "updateCard" and "listAfter" in action["data"]:
        card = action["data"]["card"]
        list_before = action["data"]["listBefore"]["name"]
        list_after = action["data"]["listAfter"]["name"]
        member = action["memberCreator"]["fullName"]

        message = {
            "text": f"Card moved by {member}",
            "blocks": [
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": f"*Card Moved*\n"
                                f"*Card:* {card['name']}\n"
                                f"*From:* {list_before} -> *To:* {list_after}\n"
                                f"*By:* {member}"
                    }
                }
            ]
        }

    if message:
        requests.post(SLACK_WEBHOOK_URL, json=message)

    return jsonify({"status": "ok"})


if __name__ == "__main__":
    app.run(port=5000)