import stashy  # library for BitBucket

login = "Julien"
token = "AbCdEf01#"
server_url = "https://bitbucket.internal.corp:1234"
project_name = "AwesomeProject"  # containing several repositories

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

for repo_data in stash.projects[project_name].repos.list():
    repo_slug = repo_data["slug"]  # identifier
    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" by Elena
   - OK Gabin
   -    Julien
 - PR "remove qux from tez" by Julien
   - OK Gabin
Repo Bonneval
Repo Chamrousse
 - PR "increase pol to 4000" by Julien
   -    Elena
   -    Gabin
Repo GrandBornand
Repo Meribel
 - PR "doc for lud" by 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}")
    # display the list of persons that have NOT approved, or PRs that are ready to be merged
    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(" -> to merge")
    else:
        print("\n".join(" -> contact " + 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} by {pr_author_display_name!s}")
    print(" -> to review")

Repo AlpesDHuez PR "add foo to bar" de Elena
 -> to review
Repo AlpesDHuez PR "remove qux from tez"
 -> to merge
Repo Chamrousse PR "increase pol to 4000"
 -> contact Elena
 -> contact Gabin

def fetch_all_pull_requests(stash, my_project_name: str) -> Sequence[Repo]:
    ...  # quite similar to what we have done earlier, but instead of `print`
    return tuple(...)  # all is collected into objects and returned to caller

def print_my_personal_actions(repos: Sequence[Repo], my_id: str) -> None:
    ...  # we iterate over the `repos` parameter, and print only personal actions

def print_the_team_global_view(repos: Sequence[Repo]) -> None:
    ...  # we iterate over the `repos` parameter, and print the global view

def test__team_global_view__case07():
    # Given
    repos = load_from_file("master_record_07.json")  # what data we want to use
    
    # When
    actual_output = compute_the_team_global_view(repos)  # what is the result
    
    # Then
    expected_output = load_from_file("master_record_07.txt")  # what is the expected output of case 07
    assertStringEquals(expected_output, actual_output)  # or your testing framework's relevant method

class FakePullRequestsFetcher(PullRequestsFetcher):
    def __init__(self, filepath):
        self._pull_requests = load_from_file(filepath)  # reusing the same code as before
    def fetch_pull_requests(self) -> Sequence[PullRequest]:
        return self._pull_requests

def test__team_global_view__case07():  # the same test as before !
    # given
    expected_output = load_from_file("master_record_07.txt")
    fake_fetcher = FakePullRequestsFetcher("pull_requests_07.json")  # creating a `fake`
    pull_requests = fetch_pull_requests(fetchers=[fake_fetcher])  # creating test data
    # 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:  # abstract class
    def display_global_report(self, global_report) -> None:
        raise NotImplementedError  # abstract method
    def display_personal_report(self, personal_report) -> None:
        raise NotImplementedError  # abstract method

class StdoutPrinter(ReportPrinter):  # child class
    def display_global_report(self, global_report) -> None:
        ...
    def display_personal_report(self, personal_report) -> None:
        ...

class HtmlPrinter(ReportPrinter):  # child class
    ...  # implementing the abstract methods

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():
    # I can do whatever I want !
    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/  # folder containing the domain code
    - reports.py  # report generation functions
    - fetching.py  # abstract class: Fetcher
    - printing.py  # abstract class: Printer
    - tests/  # domain code tests
        - fakes.py  # Fake classes inheriting from Fetcher and Printer
- fetchers/  # folder containing the "production" classes inheriting from Fetcher
    - gitlab.py
    - bitbucket.py
    - tests/  # tests of these implementations
- printers/  # folder containing the "production" classes inheriting from Printer
    - stdout.py
    - html.py
    - tests/  # tests of these implementations
- main.py  # the app entry point

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
    # configure the ArgumentParser
    args = parser.parse()
    if args.personal_report:
        # grab the config values from the args
        # instatiate everything that is required : fetchers, printer, ...
        compute_personal_report(...)
        # ...
    elif args.global_report:
        # same
        compute_global_report(...)
        # ...
    else:
        # ...

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

app = Flask("web-API to generate reports")
# ...
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()