Merge pull request #32 from IMXEren/refactor/changelogs-format

refactor: modify the format for changelog doc

Author: IMXEren

.env

@@ -17,7 +17,7 @@ EXTRA_FILES=https://github.com/WSTxda/MicroG-RE/releases/latest@MicroG-RE.apk
 # YOUTUBE_KEYSTORE_FILE_NAME=revanced.keystore
 # YOUTUBE_ARCHS_TO_BUILD=arm64-v8a
 YOUTUBE_CLI_DL=https://github.com/inotia00/revanced-cli/releases/latest
-YOUTUBE_PATCHES_DL=https://github.com/inotia00/revanced-patches/releases/latest
+YOUTUBE_PATCHES_DL=https://github.com/revanced/revanced-patches/releases/latest
 # YOUTUBE_SPACE_FORMATTED_PATCHES=True
 YOUTUBE_INCLUDE_PATCH=change-version-code
 YOUTUBE_EXCLUDE_PATCH=custom-package-name,materialyou,custom-branding-name-for-youtube,custom-header-for-youtube,force-hide-player-buttons-background,hide-shortcuts

.github/workflows/auto-release.yml

@@ -58,6 +58,17 @@ jobs:
           output=$(python check_resource_updates.py)
           should_build="$(grep -m1 '^PATCH_APPS=' <<< "$output" | cut -d= -f2- | tr -d '\r' || printf '')"
           echo "SHOULD_BUILD=$should_build" >> $GITHUB_OUTPUT
+
+      - name: Upload patch updates changelog
+        uses: actions/upload-artifact@main
+        if: ${{ steps.should_build.outputs.SHOULD_BUILD != '' }}
+        with:
+          name: Patch-Updates
+          path: |
+            patch-updates.md
+          if-no-files-found: error
+          retention-days: 0
+
     outputs:
       SHOULD_BUILD: ${{ steps.should_build.outputs.SHOULD_BUILD }}
 
@@ -72,4 +83,4 @@ jobs:
       cancel-in-progress: true
     with:
       TELEGRAM_NO_ROOT_UPLOAD: ${{ inputs.TELEGRAM_NO_ROOT_UPLOAD || false }}
-      PREFERRED_PATCH_APPS: ${{ needs.release-check.outputs.SHOULD_BUILD }}
+      PREFERRED_PATCH_APPS: ${{ needs.release-check.outputs.SHOULD_BUILD }}

.github/workflows/build-apk.yml

@@ -135,11 +135,27 @@ jobs:
         uses: actions/download-artifact@main
         with:
           name: Built-APKs
+
+      - name: Check if patch updates changelog
+        id: check-patch-updates
+        uses: softwareforgood/check-artifact-v4-existence@v0
+        with:
+          name: Patch-Updates
+
+      - name: Download patch updates changelog
+        uses: actions/download-artifact@main
+        if: ${{ steps.check-patch-updates.outputs.exists == 'true' }}
+        with:
+          name: Patch-Updates
+
       - name: Get Date
         id: get-date
         run: |
           echo "date=$(TZ='Asia/Kolkata' date +"%Y.%m.%d-%H.%M.%S")" >> $GITHUB_OUTPUT
-          curl "https://raw.githubusercontent.com/${{ github.repository }}/check-updates/changelog.md" > changelog.md
+          # curl "https://raw.githubusercontent.com/${{ github.repository }}/check-updates/patch-updates.md" > patch-updates.md
+          if [ ! -f ./patch-updates.md ]; then
+              cp ./changelog.md ./patch-updates.md
+          fi
 
       - name: Delete Older Releases
         uses: nikhilbadyal/ghaction-rm-releases@v0.0.5
@@ -155,7 +171,7 @@ jobs:
           artifacts: "apks/*-output.apk,updates.json,changelog.json,changelog.md"
           token: ${{ secrets.GITHUB_TOKEN }}
           tag: Build-${{ steps.get-date.outputs.date }}
-          bodyFile: changelog.md
+          bodyFile: patch-updates.md
           artifactErrorsFailBuild: true
           prerelease: ${{ inputs.PRE_RELEASE }}
 

check_resource_updates.py

@@ -1,22 +1,34 @@
 """Check patching resource updates."""
 
+from pathlib import Path
 from threading import Lock
 
+import requests
 from environs import Env
 from loguru import logger
 
 from main import get_app
+from src.app import APP
 from src.config import RevancedConfig
+from src.downloader.github import Github
 from src.manager.github import GitHubManager
-from src.utils import default_build, patches_dl_list_key, patches_versions_key
+from src.metadata.github import GithubSourceMetadata
+from src.utils import (
+    default_build,
+    format_changelog,
+    handle_request_response,
+    patches_dl_list_key,
+    patches_versions_key,
+    request_timeout,
+)
 
 
 def check_if_build_is_required() -> bool:
     """Read resource version."""
     env = Env()
     env.read_env()
     config = RevancedConfig(env)
-    needs_to_repatched = []
+    needs_to_repatched: list[APP] = []
     resource_cache: dict[str, tuple[str, str]] = {}
     resource_lock = Lock()
     for app_name in env.list("PATCH_APPS", default_build):
@@ -49,7 +61,7 @@ def check_if_build_is_required() -> bool:
             logger.info(
                 f"New build can be triggered due to change in number of patch bundles or sources, info: {caused_by}",
             )
-            needs_to_repatched.append(app_name)
+            needs_to_repatched.append(app_obj)
             continue
 
         for old_version, old_source, new_version, new_source in zip(
@@ -73,13 +85,53 @@ def check_if_build_is_required() -> bool:
                     },
                 }
                 logger.info(f"New build can be triggered caused by {caused_by}")
-                needs_to_repatched.append(app_name)
+                needs_to_repatched.append(app_obj)
                 break
-    logger.info(f"{needs_to_repatched} are need to repatched.")
+    needs_to_repatched_names = [app.app_name for app in needs_to_repatched]
+    logger.info(f"{needs_to_repatched_names} are need to repatched.")
     if needs_to_repatched:
-        print(f"PATCH_APPS={",".join(needs_to_repatched)}")  # noqa: T201
+        print(f"PATCH_APPS={','.join(needs_to_repatched_names)}")  # noqa: T201
+        write_patch_updates_changelog(config, needs_to_repatched)
         return True
     return False
 
 
+def _fetch_metadata(url: str, access_token: str | None = None) -> GithubSourceMetadata:
+    owner, repo_name, release_tag = Github._extract_repo_owner_and_tag(url)  # noqa: SLF001
+    repo_url = f"https://api.github.com/repos/{owner}/{repo_name}/releases/{release_tag}"
+    headers = {
+        "Content-Type": "application/vnd.github.v3+json",
+    }
+    if access_token:
+        logger.debug("Using personal access token")
+        headers["Authorization"] = f"Bearer {access_token}"
+    logger.debug(f"Fetching metadata from {repo_url}")
+    response = requests.get(repo_url, headers=headers, timeout=request_timeout)
+    handle_request_response(response, repo_url)
+    return GithubSourceMetadata.from_json(response.json())
+
+
+def write_patch_updates_changelog(config: RevancedConfig, apps: list[APP]) -> None:
+    """Write patch updates changelog."""
+    patches_dl_set: set[str] = set()
+    for app_obj in apps:
+        for dl in app_obj.patches_dl_list:
+            if dl.startswith("https://github.com/"):
+                patches_dl_set.add(dl)
+
+    metadata_set: set[GithubSourceMetadata] = set()
+    for dl in patches_dl_set:
+        metadata_set.add(_fetch_metadata(dl, config.personal_access_token))
+
+    changelog_doc = ""
+    changelog_doc_file = "patch-updates.md"
+    sorted_metadata_list = GithubSourceMetadata.sort_by_latest_release(metadata_set)
+    if sorted_metadata_list:
+        logger.info(f"Writing patch updates changelog to {changelog_doc_file}.")
+    for app_data in sorted_metadata_list:
+        changelog_doc += format_changelog(app_data)
+    with Path(changelog_doc_file).open("w", encoding="utf_8") as file1:
+        file1.write(changelog_doc)
+
+
 check_if_build_is_required()

src/metadata/__init__.py

@@ -0,0 +1 @@
+"""Represents metadata of downloaded resources."""

src/metadata/github.py

@@ -0,0 +1,59 @@
+"""Github Source Metadata."""
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import Self
+
+
+@dataclass(unsafe_hash=True)
+class GithubSourceMetadata:
+    """Represents github release tag metadata."""
+
+    name: str
+    tag: str
+    body: str
+    html_url: str
+    published_at: datetime
+
+    @classmethod
+    def from_json(cls: type[Self], response: dict[str, str]) -> Self:
+        """Create a GithubSourceMetadata instance from a GitHub release JSON response.
+
+        Parameters
+        ----------
+        response : dict[str, str]
+            JSON response for a GitHub release as returned by the API; expected to
+            contain the keys 'html_url', 'tag_name', 'body' and 'published_at'.
+
+        Returns
+        -------
+        GithubSourceMetadata
+            A new instance populated from the response.
+
+        Raises
+        ------
+        KeyError
+            If required keys are missing in the response.
+        """
+        name = "/".join(response["html_url"].split("/")[3:5])
+        tag = response["tag_name"]
+        body = response["body"]
+        html_url = response["html_url"]
+        published_at = datetime.strptime(response["published_at"], "%Y-%m-%dT%H:%M:%SZ").astimezone(UTC)
+        return cls(name, tag, body, html_url, published_at)
+
+    def get_release_date(self) -> str:
+        """Return the release date as a formatted UTC string.
+
+        Returns
+        -------
+        str
+            The published date formatted as "Month DD, YYYY, HH:MM:SS UTC".
+        """
+        return self.published_at.strftime("%B %d, %Y, %H:%M:%S UTC")
+
+    @staticmethod
+    def sort_by_latest_release(items: Iterable["GithubSourceMetadata"]) -> list["GithubSourceMetadata"]:
+        """Sort by latest release first."""
+        return sorted(items, key=lambda m: m.published_at, reverse=True)

src/utils.py

@@ -1,6 +1,5 @@
 """Utilities."""
 
-import inspect
 import json
 import re
 import subprocess
@@ -28,6 +27,7 @@
 
 from src.downloader.sources import APK_MIRROR_APK_CHECK
 from src.exceptions import ScrapingError
+from src.metadata.github import GithubSourceMetadata
 
 default_build = [
     "youtube",
@@ -57,7 +57,7 @@
 
 updates_file = "updates.json"
 updates_file_url = "https://raw.githubusercontent.com/{github_repository}/{branch_name}/{updates_file}"
-changelogs: dict[str, dict[str, str]] = {}
+changelogs: dict[str, GithubSourceMetadata] = {}
 time_zone = "Asia/Kolkata"
 app_version_key = "app_version"
 patches_versions_key = "patches_versions"
@@ -97,60 +97,49 @@ def update_changelog(name: str, response: dict[str, str]) -> None:
     in the dictionary represent the type of change (e.g., "bug fix", "feature", "documentation"), and
     the values represent the specific changes made for each type.
     """
-    app_change_log = format_changelog(name, response)
-    changelogs[name] = app_change_log
+    source_metadata = GithubSourceMetadata.from_json(response)
+    changelogs[name] = source_metadata
 
 
-def format_changelog(name: str, response: dict[str, str]) -> dict[str, str]:
+def format_changelog(metadata: GithubSourceMetadata) -> str:
     """The `format_changelog` returns formatted changelog string.
 
     Parameters
     ----------
-    name : str
-        The `name` parameter is a string that represents the name of the changelog. It is used to create a
-    collapsible section in the formatted changelog.
-    response : Dict[str, str]
-        The `response` parameter is a dictionary that contains information about a release. It has the
-    following keys:
+    metadata : GithubSourceMetadata
+        Represents the release metadata with sufficient info.
 
     Returns
     -------
-        a formatted changelog as a dict.
+        a formatted changelog as str
     """
-    final_name = f"[{name}]({response['html_url']})"
-    return {
-        "ResourceName": final_name,
-        "Version": response["tag_name"],
-        "Changelog": response["body"],
-        "PublishedOn": response["published_at"],
-    }
+    content = (
+        f"# {metadata.name}\n\n"
+        f"***Release Version: [{metadata.tag}]({metadata.html_url})***  \n"
+        f"***Release Date: {metadata.get_release_date()}***  \n"
+        f"<details>\n<summary><b><i>Changelog:</i></b></summary>\n\n{metadata.body}</details>\n\n"
+    )
+    return f"{content}"
 
 
 def write_changelog_to_file(updates_info: dict[str, Any]) -> None:
     """The function `write_changelog_to_file` writes a given changelog json to a file."""
-    markdown_table = inspect.cleandoc(
-        """
-    | Resource Name | Version | Changelog | Published On | Build By|
-    |---------------|---------|-----------|--------------|---------|
-    """,
-    )
-    for app_data in changelogs.values():
-        name_link = app_data["ResourceName"]
-        version = app_data["Version"]
-        changelog = app_data["Changelog"]
-        published_at = app_data["PublishedOn"]
-        built_by = get_parent_repo()
-
-        # Clean up changelog for markdown
-        changelog = changelog.replace("\r\n", "<br>")
-        changelog = changelog.replace("\n", "<br>")
-        changelog = changelog.replace("|", "\\|")
-
-        # Add row to the Markdown table string
-        markdown_table += f"\n| {name_link} | {version} | {changelog} | {published_at} | {built_by} |"
+    changelog_doc = ""
+    metadata_list = GithubSourceMetadata.sort_by_latest_release(changelogs.values())
+    for data in metadata_list:
+        changelog_doc += format_changelog(data)
     with Path(changelog_file).open("w", encoding="utf_8") as file1:
-        file1.write(markdown_table)
-    Path(changelog_json_file).write_text(json.dumps(changelogs, indent=4) + "\n")
+        file1.write(changelog_doc)
+
+    def encoder_default(obj: Any) -> Any:
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        if hasattr(obj, "__dict__"):
+            return obj.__dict__
+        msg = f"Object of type {type(obj).__name__} is not JSON serializable"
+        raise TypeError(msg)
+
+    Path(changelog_json_file).write_text(json.dumps(changelogs, default=encoder_default, indent=4) + "\n")
     Path(updates_file).write_text(json.dumps(updates_info, indent=4, default=str) + "\n")