CommitJson.py

import os
import json
from collections import Counter
from datetime import datetime, timedelta
from concurrent.futures import ThreadPoolExecutor, as_completed

# 	GPL-3.0-only
# Création de deux types de JSON
# [✓] Le premier va être un JSON qui liste le nombre de commits par jour
# [✓~✗] Le second va être un JSON qui liste le total cumulatif de commits par jour
    
def get_commit_dates_from_project(proj) ->list[str]:
    """Cette fonction récupère la liste des commits fait par projet

    Args:
        proj (_type_): un projet récupérer par l'API

    Returns:
        list[str]: renvoie une liste de commit avec la date de leur création
    """
    try:
        return [
            commit.created_at[:10]
            for commit in proj.commits.list(all=True, iterator=True)
            if hasattr(commit, "created_at")
        ]
    except Exception as e:
        print(f"Erreur sur le projet {proj.name}: {e}")
        return []

def json_number_commit_create_everyday(years: list[int], projects) -> None:
    """Cette fonction permet de créer le JSON du nombre de commits par jour d'une année avec parallélisation (données journalières non cumulées).
    
    Utilise des threads pour accélérer la récupération des dates de commits à partir de nombreux projets.
    Crée un fichier JSON par année dans le répertoire courant (et non dans json/Commit/).

    Args:
        years (list[int]): Liste des années pour lesquelles on veut créer les JSON
        projects: Liste des projets GitLab depuis lesquels récupérer les commits
        
    Returns:
        None: La fonction écrit directement les fichiers JSON dans le système de fichiers
              et ne renvoie aucune valeur
    """
    os.makedirs("json/Commit", exist_ok=True)
    today = datetime.now().date()

    # Parallélisation de la récupération des dates de commits
    all_dates = []
    with ThreadPoolExecutor(max_workers=8) as executor:
        future_to_proj = {executor.submit(get_commit_dates_from_project, proj): proj for proj in projects}
        for future in as_completed(future_to_proj):
            all_dates.extend(future.result())

    date_counts = Counter(all_dates)

    for year in years:
        start_date = datetime(year, 1, 1).date()
        end_date = today if year == today.year else datetime(year, 12, 31).date()

        daily_data = [
            {"x": (day := (start_date + timedelta(days=i))).isoformat(),
             "y": date_counts.get(day.isoformat(), 0)}
            for i in range((end_date - start_date).days + 1)
        ]

        with open(f"json/Commit/{year}.json", "w", encoding="utf-8") as f:
            json.dump({str(year): {"year": year, "daily_data": daily_data}}, f, indent=4)

    

    
def json_cumulative_number_commit_everyday(json_files) -> json:
    """Cette fonction permet de créer le JSON du nombre de commit par jour d'une année (ce sont les données journalières cumulées).

    Args:
        json_files (_type_): Liste de fichiers JSON contenant les données journalières non cumulées

    Returns:
        json: renvoie un JSON qui va après être mis dans un fichier
    """
    cumulative_data = {}
    cumulative = 0

    # Chargement de toutes les données
    for file_path in json_files:
        with open(file_path, 'r') as f:
            data = json.load(f)

            # On suppose qu'il n'y a qu'une seule clé (par exemple "2023") dans chaque fichier
            year_key = list(data.keys())[0]
            daily_data = data[year_key]['daily_data']

            # Si l'année n'est pas encore dans le résultat, on l'ajoute
            if year_key not in cumulative_data:
                cumulative_data[year_key] = {
                    "year": int(year_key),
                    "daily_data": []
                }

            cumulative_data[year_key]["daily_data"].extend(daily_data)

    
    # Calcul du cumul global 
    for year, year_data in cumulative_data.items():
        year_data["daily_data"].sort(key=lambda x: datetime.strptime(x['x'], '%Y-%m-%d'))

        
        for day in year_data["daily_data"]:
            cumulative += day['y']
            day['y'] = cumulative

    # Création du résultat final
    result = {year: data for year, data in cumulative_data.items()}

    return json.dumps(result, indent=4)