cookiecutter-django/scripts/update_contributors.py

import json
from pathlib import Path

import requests
from jinja2 import Template

CURRENT_FILE = Path(__file__)
ROOT = CURRENT_FILE.parents[1]
BOT_LOGINS = ["pyup-bot"]

# Jinja template for CONTRIBUTORS.md
CONTRIBUTORS_TEMPLATE = """
# Contributors

## Core Developers

These contributors have commit flags for the repository, and are able to
accept and merge pull requests.

<table>
  <tr>
    <th>Name</th>
    <th>Github</th>
    <th>Twitter</th>
  </tr>
  {%- for contributor in core_contributors %}
  <tr>
    <td>{{ contributor.name }}</td>
    <td>
      <a href="https://github.com/{{ contributor.github_login }}">{{ contributor.github_login }}</a>
    </td>
    <td>{{ contributor.twitter_username }}</td>
  </tr>
  {%- endfor %}
</table>

*Audrey is also the creator of Cookiecutter. Audrey and Daniel are on
the Cookiecutter core team.*

## Other Contributors

Listed in alphabetical order.

<table>
  <tr>
    <th>Name</th>
    <th>Github</th>
    <th>Twitter</th>
  </tr>
  {%- for contributor in other_contributors %}
  <tr>
    <td>{{ contributor.name }}</td>
    <td>
      <a href="https://github.com/{{ contributor.github_login }}">{{ contributor.github_login }}</a>
    </td>
    <td>{{ contributor.twitter_username }}</td>
  </tr>
  {%- endfor %}
</table>

### Special Thanks

The following haven't provided code directly, but have provided
guidance and advice.

-   Jannis Leidel
-   Nate Aune
-   Barry Morrison
"""


def main() -> None:
    """
    Script entry point.

    1. Fetch recent contribtors from the Github API
    2. Add missing ones to the JSON file
    3. Generate Markdown from JSON file
    """
    # Use Github API to fetch recent authors rather than
    # git CLI because we need to know their GH username
    gh = GitHub()
    recent_authors = set(gh.iter_recent_authors())

    # Add missing users to the JSON file
    contrib_file = ContributorsJSONFile()
    for username in recent_authors:
        print(f"Checking if {username} should be added")
        if username not in contrib_file and username not in BOT_LOGINS:
            user_data = gh.fetch_user_info(username)
            contrib_file.add_contributor(user_data)
            print(f"Added {username} to contributors")
    contrib_file.save()

    # Generate MD file from JSON file
    write_md_file(contrib_file.content)


class GitHub:
    """Small wrapper around Github REST API."""

    base_url = "https://api.github.com"

    def __init__(self) -> None:
        self.session = requests.Session()

    def request(self, endpoint):
        response = self.session.get(f"{self.base_url}{endpoint}")
        response.raise_for_status()
        return response.json()

    def iter_recent_authors(self):
        commits = self.request("/repos/pydanny/cookiecutter-django/commits")
        for commit in commits:
            login = commit["author"]["login"]
            if login not in BOT_LOGINS:
                yield login

    def fetch_user_info(self, username):
        return self.request(f"/users/{username}")


class ContributorsJSONFile:
    """Helper to interact with the JSON file."""

    file_path = ROOT / ".github" / "contributors.json"
    content = None

    def __init__(self) -> None:
        """Read initial content."""
        self.content = json.loads(self.file_path.read_text())

    def __contains__(self, github_login: str):
        """Provide a nice API to do: `username in file`."""
        return any(github_login == contrib["github_login"] for contrib in self.content)

    def add_contributor(self, user_data):
        """Append the contributor data we care about at the end."""
        contributor_data = {
            "name": user_data["name"],
            "github_login": user_data["login"],
            "twitter_username": user_data["twitter_username"],
        }
        self.content.append(contributor_data)

    def save(self):
        """Write the file to disk with indentation."""
        text_content = json.dumps(self.content, indent=2, ensure_ascii=False)
        self.file_path.write_text(text_content)


def write_md_file(contributors):
    """Generate markdown file from Jinja template."""
    template = Template(CONTRIBUTORS_TEMPLATE, autoescape=True)
    core_contributors = [c for c in contributors if c.get("is_core", False)]
    other_contributors = (c for c in contributors if not c.get("is_core", False))
    other_contributors = sorted(other_contributors, key=lambda c: c["name"].lower())
    content = template.render(
        core_contributors=core_contributors, other_contributors=other_contributors
    )

    file_path = ROOT / "CONTRIBUTORS.md"
    file_path.write_text(content)


if __name__ == "__main__":
    main()