refactor(app): split monolithic main.py into dedicated modules

Extract functionality from main.py and utils.py into single-responsibility
modules:
- app.py: MemberApp entry point
- file_io.py: file read/write helpers with error handling
- git_client.py: pygit2 clone/push/branch operations
- github_client.py: PyGitHub API interactions (fork, PR, token auth)
- markdown_builder.py: load/build member markdown files
- strings.py: i18n helper with pybabel
- constants.py: shared platform option tuples and directory constants
- styles.tcss: full Textual CSS stylesheet
- Remove now-empty utils.py and scripts/translate.py

Author: zodiacfireworks

TRANSLATIONS.md

@@ -0,0 +1,17 @@
+from textual.app import App
+
+from .screens.language import LanguageScreen
+
+
+class MemberApp(App):
+    CSS_PATH = "styles.tcss"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.original_repo = None
+        self.forked_repo = None
+        self.token = ""
+        self.repo_path = ""
+
+    def on_mount(self) -> None:
+        self.push_screen(LanguageScreen())

scripts/translate.py

@@ -10,3 +10,8 @@
 INSTAGRAM_OPTION = ("Instagram", "instagram")
 X_OPTION = ("X", "x")
 YOUTUBE_OPTION = ("YouTube", "youtube")
+
+# Repository Paths
+BLOG_DIR = "blog"
+MEMBERS_DIR = "members"
+AUTHORS_FILE = "AUTHORS"

src/edit_python_pe/app.py

@@ -0,0 +1,39 @@
+import os
+
+from .constants import AUTHORS_FILE
+
+
+def _read_file(file_path: str) -> str:
+    with open(file_path, encoding="utf-8") as fd:
+        return fd.read()
+
+
+def _append_file(file_content: str, file_path: str) -> None:
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+    with open(file_path, "a", encoding="utf-8") as fd:
+        fd.write(file_content)
+
+
+def _write_file(file_content: str, file_path: str) -> None:
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+    with open(file_path, "w", encoding="utf-8") as fd:
+        fd.write(file_content)
+
+
+def _write_authors_file(
+    repo_path: str,
+    aliases: list[str],
+    name: str,
+    email: str,
+) -> None:
+    file_path = os.path.join(repo_path, AUTHORS_FILE)
+
+    try:
+        contents = _read_file(file_path)
+    except FileNotFoundError:
+        contents = ""
+
+    alias = aliases[0] if aliases else name
+    file_content = f"\n{name}({alias}) <{email}>"
+    if file_content.strip() not in contents:
+        _append_file(file_content, file_path)

src/edit_python_pe/constants.py

@@ -0,0 +1,38 @@
+import pygit2
+
+
+def _commit_and_push(
+    repo_path: str,
+    token: str,
+    was_changed: bool,
+    name_file: str,
+    name: str,
+    email: str,
+) -> tuple[
+    str,
+    pygit2.repository.Repository,
+    pygit2.remotes.Remote,
+    pygit2.callbacks.RemoteCallbacks,
+]:
+    repo = pygit2.repository.Repository(repo_path)
+    repo.index.add_all()
+    repo.index.write()
+    author_sig = pygit2.Signature(name or "Unknown", email or "unknown@email")
+    tree_id = repo.index.write_tree()
+    parents = [] if repo.head_is_unborn else [repo.head.target]
+    commit_msg = f"Changed {name_file}" if was_changed else f"Added {name_file}"
+    repo.create_commit(
+        "HEAD",
+        author_sig,
+        author_sig,
+        commit_msg,
+        tree_id,
+        parents,
+    )
+
+    callbacks = pygit2.callbacks.RemoteCallbacks(
+        credentials=pygit2.UserPass(token, "x-oauth-basic")
+    )
+    remote = repo.remotes["origin"]
+    remote.push([repo.head.name], callbacks=callbacks)
+    return commit_msg, repo, remote, callbacks

src/edit_python_pe/file_io.py

@@ -0,0 +1,152 @@
+import os
+import shutil
+from time import sleep
+
+import pygit2
+from github import Auth, Github
+from github.GithubException import BadCredentialsException, GithubException
+from github.Repository import Repository
+from platformdirs import user_data_dir
+
+from .file_io import _write_authors_file
+from .git_client import _commit_and_push
+from .markdown_builder import _create_member_file
+from .strings import _
+
+
+def get_repo(token: str) -> tuple[str, Repository]:
+    auth = Auth.Token(token)
+    g = Github(auth=auth)
+
+    try:
+        return token, g.get_repo("pythonpe/python.pe")
+    except BadCredentialsException as err:
+        raise ValueError(
+            _("Unauthorized access. Please check your access token.")
+        ) from err
+    except GithubException as err:
+        raise ValueError(
+            _("Repository not found. Please check your access token.")
+        ) from err
+
+
+def fork_repo(token: str, original_repo: Repository) -> tuple[str, Repository]:
+    forked_repo = original_repo.create_fork()
+    forked_repo_url = forked_repo.clone_url
+    repo_path = user_data_dir(appname="edit-python-pe", appauthor="python.pe")
+
+    if os.path.exists(repo_path):
+        shutil.rmtree(repo_path, ignore_errors=True)
+
+    callbacks = pygit2.callbacks.RemoteCallbacks(
+        credentials=pygit2.UserPass(token, "x-oauth-basic")
+    )
+    sleep(3)
+    pygit2.clone_repository(forked_repo_url, repo_path, callbacks=callbacks)
+    return repo_path, forked_repo
+
+
+def create_pr(
+    file_content: str,
+    current_file: str | None,
+    repo_path: str,
+    original_repo: Repository,
+    forked_repo: Repository,
+    token: str,
+    aliases: list[str],
+    name: str,
+    email: str,
+) -> tuple[str, str | None]:
+    name_file, file_path = _create_member_file(
+        file_content,
+        current_file,
+        repo_path,
+        aliases,
+        name,
+        email,
+    )
+    _write_authors_file(
+        repo_path,
+        aliases,
+        name,
+        email,
+    )
+
+    # commit & push
+    commit_msg, repo, remote, callbacks = _commit_and_push(
+        repo_path,
+        token,
+        current_file is not None,
+        name_file,
+        name,
+        email,
+    )
+
+    # PR logic
+    pr_title = commit_msg
+    first_alias = aliases[0] if aliases else ""
+    pr_body = (
+        f"Changing an entry to `blog/members` for {name} (alias: {first_alias})."
+        if current_file
+        else (
+            f"Creating a new entry to `blog/members` for {name} (alias: {first_alias})."
+        )
+    )
+    fork_owner = forked_repo.owner.login
+    head_branch = f"{fork_owner}:main"
+    base_branch = "main"
+
+    pr_url = None
+
+    # If editing, retrieve PR by title and push to its branch
+    if current_file:
+        # Try to find an open PR with matching title
+        prs = original_repo.get_pulls(
+            state="open", sort="created", base=base_branch, head=head_branch
+        )
+        pr_found = None
+        for pr in prs:
+            if pr.title.endswith(current_file):
+                pr_found = pr
+                break
+        if pr_found:
+            # Push to the PR branch
+            remote.push([repo.head.name], callbacks=callbacks)
+            pr_url = pr_found.html_url
+            return (
+                _(
+                    "Woohoo! Changes to {name_file} were successfully sent to your "
+                    "existing PR! 🎉"
+                ).format(name_file=name_file),
+                pr_url,
+            )
+        else:
+            pr = original_repo.create_pull(
+                title=pr_title,
+                body=pr_body,
+                head=head_branch,
+                base=base_branch,
+            )
+            pr_url = pr.html_url
+            return (
+                _(
+                    "Woohoo! {name_file} was saved successfully and "
+                    "your new PR is ready! 🎉"
+                ).format(name_file=name_file),
+                pr_url,
+            )
+    else:
+        pr = original_repo.create_pull(
+            title=pr_title,
+            body=pr_body,
+            head=head_branch,
+            base=base_branch,
+        )
+        pr_url = pr.html_url
+        return (
+            _(
+                "Woohoo! {name_file} was saved successfully and "
+                "your new PR is ready! 🎉"
+            ).format(name_file=name_file),
+            pr_url,
+        )