import stashy  # lib pour BitBucket

login = "Julien"
token = "AbCdEf01#"
server_url = "https://bitbucket.internal.corp:1234"
project_name = "AwesomeProject"  # contient plusieurs repo

stash = stashy.connect(server_url, login, token)

for repo_data in stash.projects[project_name].repos.list():
    repo_slug = repo_data["slug"]  # identifiant
    print("Repo " + repo_slug)
    for pr_data in (stash.projects[project_name]
            .repos[repo_slug].pull_requests.list()):
        title = pr_data["title"]
        author_name = pr_data["author"]["displayName"]
        print(f" - PR {title!r} de {author_name!s}")
        for reviewer_data in pr_data["reviewers"]:
            reviewer_name = reviewer_data["user"]["displayName"]
            has_approved = bool(reviewer_data["approved"])
            print(f"   - {'OK' if has_approved else '  '} {reviewer_name}")

Repo AlpesDHuez
 - PR "add foo to bar" de Elena
   - OK Gabin
   -    Julien
 - PR "remove qux from tez" de Julien
   - OK Gabin
Repo Bonneval
Repo Chamrousse
 - PR "increase pol to 4000" de Julien
   -    Elena
   -    Gabin
Repo GrandBornand
Repo Meribel
 - PR "doc for lud" de Elena
   - OK Agathe

my_id = "123456"

pr_author_id = pull_request_data["author"]["id"]
i_am_reviewer = my_id in (reviewer_data["user"]["id"]
                          for reviewer_data in pull_request_data["reviewers"])

if my_id == pr_author_id:
    print(f"Repo {repo_slug!s} PR {pr_title!r}")
    # afficher la liste des gens qui n'ont PAS approuvé, ou alors "à merger"
    reviewers_data_not_approved = tuple(reviewer_data
                                        for reviewer_data in pull_request_data["reviewers"]
                                        if not reviewer_data["approved"])
    if len(reviewers_data_not_approved) == 0:
        print(" -> à merger")
    else:
        print("\n".join(" -> relancer " + reviewer_data["user"]["displayName"]
                        for reviewer_data in reviewers_data_not_approved))
    
elif i_am_reviewer:
    print(f"Repo {repo_slug!s} PR {pr_title!r} de {pr_author_display_name!s}")
    print(" -> à relire")

Repo AlpesDHuez PR "add foo to bar" de Elena
 -> à relire
Repo AlpesDHuez PR "remove qux from tez"
 -> à merger
Repo Chamrousse PR "increase pol to 4000"
 -> relancer Elena
 -> relancer Gabin

def fetch_all_pull_requests(stash, my_project_name: str) -> Sequence[Repo]:
    ...  # assez identique à ce qui était fait avant, mais à la place de printer,
    return tuple(...)  # tout est stocké dans des objets et finalement returné

def print_my_personal_actions(repos: Sequence[Repo], my_id: str) -> None:
    ...  # on itère sur les données passées en paramètre, et on print les actions personnelles

def print_the_team_global_view(repos: Sequence[Repo]) -> None:
    ...  # on itère sur les données passées en paramètre, et on print la vue globale

def test__team_global_view__case07():
    # Given
    repos = load_from_file("master_record_07.json")  # avec quelles données
    
    # When
    actual_output = compute_the_team_global_view(repos)  # ce que j'obtiens maintenant
    
    # Then
    expected_output = load_from_file("master_record_07.txt")  # à quoi doit ressembler la sortie pour le cas 07
    assertStringEquals(expected_output, actual_output)  # ou la fonction appropriée de votre framework de test

class FakePullRequestsFetcher(PullRequestsFetcher):
    def __init__(self, filepath):
        self._pull_requests = load_from_file(filepath)  # on réutilise le code de test d'avant
    def fetch_pull_requests(self) -> Sequence[PullRequest]:
        return self._pull_requests

def test__team_global_view__case07():  # le même test qu'avant
    # given
    expected_output = load_from_file("master_record_07.txt")
    fake_fetcher = FakePullRequestsFetcher("pull_requests_07.json")  # on instancie notre fake
    pull_requests = fetch_pull_requests(fetchers=[fake_fetcher])  # pour créer nos données de test
    # when
    actual_output = compute_the_team_global_view(pull_requests)
    # then
    assertStringEquals(expected_output, actual_output)

@dataclass
class GlobalReport:
    ...
@dataclass
class PersonalReport:
    ...

def compute_global_report(pull_requests) -> GlobalReport:
    ...
def compute_personal_report(pull_requests, person) -> PersonalReport:
    ...

class ReportPrinter:  # classe abstraite
    def display_global_report(self, global_report) -> None:
        raise NotImplementedError  # méthode abstraite
    def display_personal_report(self, personal_report) -> None:
        raise NotImplementedError  # méthode abstraite

class StdoutPrinter(ReportPrinter):  # classe dérivée
    def display_global_report(self, global_report) -> None:
        ...
    def display_personal_report(self, personal_report) -> None:
        ...

class HtmlPrinter(ReportPrinter):  # classe dérivée
    ...  # implémentation des méthodes abstraites

def main__create_global_report(fetchers: Sequence[Fetcher], printer: ReportPrinter) -> None:
    printer.display_global_report(fetch_pull_requests(fetchers))
def main__create_personal_report(fetchers: Sequence[Fetcher], printer: ReportPrinter) -> None:
    printer.display_personal_report(fetch_pull_requests(fetchers))


def main():
    # je peux faire tout ce qui me plait !
    all_fetchers = [FakeFetcher(...), GitLabFetcher(...), BitBucketFetcher(...)]
    all_printers = [FakePrinter(...), StdoutPrinter(...), HtmlPrinter(...)]
    for fetchers in itertools.combinations(all_fetchers):
        for printer in all_printers:
            main__create_global_report(fetchers, printer)
            main__create_personal_report(fetchers, printer)

- core/  # le dossier contenant le domain métier
    - reports.py  # les fonctions de génération de rapport
    - fetching.py  # la classe abstraite Fetcher
    - printing.py  # la classe abstraite Printer
    - tests/  # les tests du code métier
        - fakes.py  # les classes Fake dérivées pour Fetcher et Printer
- fetchers/  # le dossier contenant toutes les classes de prod dérivées de Fetcher
    - gitlab.py
    - bitbucket.py
    - tests/  # les tests pour ces implémentations
- printers/  # le dossier contenant toutes les classes de prod dérivées de Printer
    - stdout.py
    - html.py
    - tests/  # les tests pour ces implémentations
- main.py  # le point d'entrée dans l'application

def generate_personal_report(username,
                             gitlab_credentials, gitlab_url,
                             bitbucket_credentials, bitbucket_url,
                             output_file_path) -> None:
    from core import compute_personal_report
    from fetchers import GitLabFetcher, BitBucketFetcher
    from printers import FilePrinter
    fetchers = [
        GitLabFetcher(gitlab_url, gitlab_credentials),
        BitBucketFetcher(bitbucket_url, bitbucket_credentials),
    ]
    personal_report = compute_personal_report(username, fetchers)
    printer = FilePrinter(output_file_path)
    printer.display_personal_report(personal_report)

def main():
    from argparse import ArgumentParser
    # configurer l'ArgumentParser
    args = parser.parse()
    if args.personal_report:
        # récupérer la config qu'il faut depuis les args
        # instancier tout ce qu'il faut : fetchers, printer, ...
        compute_personal_report(...)
        # ...
    elif args.global_report:
        # pareil
        compute_global_report(...)
        # ...
    else:
        # ...

from flask import Flask  # framework web simple et rapide
from core import compute_personal_report, compute_global_report
from fetchers import GitLabFetcher, BitBucketFetcher
from printers import JsonPrinter

app = Flask("web-API de génération de rapports")
# ...
FETCHERS = [GitLabFetcher(GITLAB_URL, GITLAB_CREDENTIALS),
            BitBucketFetcher(BITBUCKET_URL, BITBUCKET_CREDENTIALS)]
PRINTER = JsonPrinter()

@app.route("/personal_report/<str:username>")
def create_personal_report(username: str):
    return PRINTER.display_personal_report(compute_personal_report(username, FETCHERS))

@app.route("/global_report")
def create_global_report():
    return PRINTER.display_personal_report(compute_global_report(FETCHERS))

def main():
    app.run()