【GitHub】Pythonでリポジトリの情報を取得するCloud Functionsを作る

1
def get_repo_info_in_format(repo) -> Repo_format:
2
    """
3
    Retrieves and formats repository data into a dictionary conforming to Repo_format.
4

5
    :param repo: The repository object to format.
6
    :return: A dictionary containing formatted repository data.
7
    :rtype: Repo_format
8
    """
9
    state_of_pulls = "all"
10
    created_at = repo.created_at
11
    updated_at = repo.updated_at
12
    created_at = f"{created_at.year:04}-{created_at.month:02}-{created_at.day:02}T{created_at.hour:02}:{created_at.minute:02}:{created_at.second:02}Z"
13
    updated_at = f"{updated_at.year:04}-{updated_at.month:02}-{updated_at.day:02}T{updated_at.hour:02}:{updated_at.minute:02}:{updated_at.second:02}Z"
14
    obj = {
15
        "name": repo.name,
16
        "description": repo.description,
17
        "is_private": repo.private,
18
        "html_url": repo.html_url,
19
        "issues_count": repo.open_issues_count,
20
        "forks_count": repo.forks_count,
21
        "stargazers_count": repo.stargazers_count,
22
        "subscribers_count": repo.subscribers_count,
23
        "size": repo.size,
24
        "is_archived": repo.archived,
25
        "created_at": created_at,
26
        "updated_at": updated_at,
27
        "language": repo.language,
28
        "languages": repo.get_languages(),
29
        "pulls_count": repo.get_pulls(state=state_of_pulls).totalCount
30
    }
31
    return obj

1
import threading
2
from pprint import pprint
3
from typing import TypedDict, Final
4
import datetime
5
import json
6
import requests
7
import os
8
from github import Github
9
from config import get_config, get_github_token, get_github_username, get_env_variable
10

11
from memory_profiler import profile
12

13
def fetch_repositories(github, fetch_type: str, username: str | None):
14
    """
15
    Fetches a list of repositories for a specified user or the authenticated user if no username is provided.
16

17
    :param github: The GitHub session object.
18
    :param fetch_type: The type of repositories to fetch ('all', 'owner', 'public', 'private', 'forks', etc.).
19
    :param username: The username of the GitHub user whose repositories are to be fetched. If None, fetches repositories of the authenticated user.
20
    :type username: str, optional
21
    :return: A list of Repository objects.
22
    :rtype: PaginatedList[Repository]
23
    :raises ValueError: if fetch_type is an empty string.
24
    """
25
    if fetch_type not in ["all", "owner", "public", "private", "forks"]:
26
        raise ValueError(f"'fetch_type' is not support '{fetch_type}'")
27
    if username == None:
28
        user = github.get_user()
29
    else:
30
        user = github.get_user(username)
31
    repos = user.get_repos(type=fetch_type)
32
    return repos
33

34
def store_repo_info(repo, results: list) -> None:
35
    """
36
    Processes and stores information about a repository in a list, intended for multi-threaded operations.
37

38
    :param repo: The repository object to process information from.
39
    :param results: The list where processed information will be stored.
40
    """
41
    obj: Repo_format = get_repo_info_in_format(repo)
42
    # gh_info.append(obj)
43
    results.append(obj)
44

45
# @profile
46
def get_repo_info(github, is_threading: bool = False, username: str | None = None) -> list[Repo_format]:
47
    """
48
    Starts multiple threads to process detailed information for 'owner' type repositories for a given user.
49

50
    :param github: The GitHub session object.
51
    :param username: The username of the GitHub user. If None, processes repositories for the authenticated user.
52
    :type username: str, optional
53
    :return: A list of processed repository information.
54
    :rtype: list[Repo_format]
55
    """
56
    repos = fetch_repositories(github, "owner", username)
57
    results = []
58
    if is_threading:
59
        threads = []
60
        for repo in repos:
61
            thread = threading.Thread(
62
                target=store_repo_info, args=(repo, results))
63
            threads.append(thread)
64
            thread.start()
65
        pprint(threads.__sizeof__())
66
        pprint("threads.__sizeof__()------------------------------------")
67
        for thread in threads:
68
            thread.join()
69
    else:
70
        for repo in repos:
71
            info: Repo_format = get_repo_info_in_format(repo)
72
            results.append(info)
73

74
    return results

1
name: pytest-integration
2

3
on:
4
  push:
5

6
permissions: write-all
7

8
env:
9
  PYTHON_VERSION: '3.10'
10
  PYTHON_VERSION_JSON: 'python-version.json'
11
  LICENSE: 'Apache'
12
  LICENSE_JSON: 'license.json'
13
  TEST_DIR: 'pytest_results'
14
  GIST_ID: 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
15
  PYTHON_COVERAGE_COMMENT_JSON: 'pytest-coverage-comment.json'
16

17
jobs:
18
  test:
19
    runs-on: ubuntu-latest
20
    steps:
21
      - name: Checkout
22
        uses: actions/checkout@v4
23
      - name: Set up Python
24
        uses: actions/setup-python@v5
25
        with:
26
          python-version: ${{ env.PYTHON_VERSION }}
27
          architecture: 'x64'
28
      - name: Get Python version
29
        run: python -V
30
      - name: Install dependencies
31
        run: pip install --no-cache-dir -r requirements/dev.txt
32
      - name: Set environment variables
33
        run: |
34
          echo 'PYTHONPATH=./' >> .env
35
          mkdir -p ${{ env.TEST_DIR }}
36
      - name: Run pytest
37
        run: |
38
          python -m pytest -n auto --cov=src --cov-branch --cov-report=term-missing:skip-covered --tb=short --junitxml=./${{ env.TEST_DIR }}/junit.xml | tee ./${{ env.TEST_DIR }}/coverage.txt
39
      - name: Create Coverage Comment
40
        id: coverageComment
41
        uses: MishaKav/pytest-coverage-comment@main
42
        with:
43
          github-token: ${{ secrets.GITHUB_TOKEN }}
44
          pytest-coverage-path: ./${{ env.TEST_DIR }}/coverage.txt
45
          junitxml-path: ./${{ env.TEST_DIR }}/junit.xml
46
      - name: Create Coverage Badge
47
        uses: schneegans/dynamic-badges-action@v1.7.0
48
        with:
49
          auth: ${{ secrets.ACCESS_BADGE_IN_GIST }}
50
          gistID: ${{ env.GIST_ID }}
51
          filename: ${{ env.PYTHON_COVERAGE_COMMENT_JSON }}
52
          label: Coverage
53
          message: ${{ steps.coverageComment.outputs.coverage }}
54
          color: ${{ steps.coverageComment.outputs.color }}
55
          namedLogo: pytest
56
      - name: Generate Python version json
57
        uses: jsdaniell/create-json@v1.2.3
58
        with:
59
          name: ${{ env.PYTHON_VERSION_JSON }}
60
          json: '{"label":"Python","message":"${{ env.PYTHON_VERSION }}","schemaVersion":1,"color":"blue","namedLogo":"python","style":"flat"}'
61
          dir: './'
62
      - name: Deploy Python version json to Gist
63
        uses: exuanbo/actions-deploy-gist@v1.1.4
64
        with:
65
          token: ${{ secrets.ACCESS_BADGE_IN_GIST }}
66
          gist_id: ${{ env.GIST_ID }}
67
          file_path: ${{ env.PYTHON_VERSION_JSON }}
68
          file_type: text
69
      - name: Generate License json
70
        uses: jsdaniell/create-json@v1.2.3
71
        with:
72
          name: ${{ env.LICENSE_JSON }}
73
          json: '{"label":"license","message":"${{ env.LICENSE }}","schemaVersion":1,"color":"skyblue","namedLogo":"apache","style":"flat"}'
74
          dir: './'
75
      - name: Deploy License json to Gist
76
        uses: exuanbo/actions-deploy-gist@v1.1.4
77
        with:
78
          token: ${{ secrets.ACCESS_BADGE_IN_GIST }}
79
          gist_id: ${{ env.GIST_ID }}
80
          file_path: ${{ env.LICENSE_JSON }}
81
          file_type: text