Merge pull request #37 from nikhilbadyal/cleanup

🧹 More Cleanup

.pre-commit-config.yaml

@@ -17,6 +17,7 @@ repos:
       - id: end-of-file-fixer
       - id: mixed-line-ending
       - id: trailing-whitespace
+      - id: requirements-txt-fixer
 
   - repo: https://github.com/psf/black
     rev: 22.8.0

main.py

@@ -3,6 +3,7 @@ import sys
 from environs import Env
 from loguru import logger
 
+from src.config import RevancedConfig
 from src.downloader import Downloader
 from src.parser import Parser
 from src.patches import Patches
@@ -10,13 +11,14 @@ from src.patches import Patches
 
 def main() -> None:
     env = Env()
+    config = RevancedConfig(env)
 
-    patcher = Patches(env)
+    patcher = Patches(config)
-    downloader = Downloader(env)
+    downloader = Downloader(config)
-    parser = Parser(patcher, env, downloader.temp_folder)
+    parser = Parser(patcher, config)
 
-    logger.info(f"Will Patch only {patcher.apps}")
+    logger.info(f"Will Patch only {patcher.config.apps}")
-    for app in patcher.apps:
+    for app in patcher.config.apps:
         try:
             logger.info("Trying to build %s" % app)
             app_all_patches, version, is_experimental = patcher.get_app_configs(app)

requirements.txt

@@ -1,6 +1,6 @@
+environs==9.5.0
+loguru==0.6.0
+pre-commit==2.20.0
 requests==2.28.1
 selectolax==0.3.11
 tqdm==4.64.1
-pre-commit==2.20.0
-loguru==0.6.0
-environs==9.5.0

src/config.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+from typing import List
+
+from environs import Env
+from requests import Session
+
+from src.utils import supported_apps
+
+
+class RevancedConfig:
+    def __init__(self, env: Env) -> None:
+        self.env = env
+        self.temp_folder = Path("apks")
+        self.session = Session()
+        self.session.headers["User-Agent"] = "anything"
+        self.build_extended = env.bool("BUILD_EXTENDED", False)
+        self.apk_mirror = "https://www.apkmirror.com"
+        self.upto_down = ["spotify"]
+        self.keystore_name = env.str("KEYSTORE_FILE_NAME", "revanced.keystore")
+        self.apps = env.list("PATCH_APPS", supported_apps)
+        self.extended_apps: List[str] = ["youtube", "youtube_music"]
+        self.normal_cli_jar = "revanced-cli.jar"
+        self.normal_patches_jar = "revanced-patches.jar"
+        self.normal_integrations_apk = "revanced-integrations.apk"
+        self.cli_jar = (
+            f"inotia00-{self.normal_cli_jar}"
+            if self.build_extended
+            else self.normal_cli_jar
+        )
+        self.patches_jar = (
+            f"inotia00-{self.normal_patches_jar}"
+            if self.build_extended
+            else self.normal_patches_jar
+        )
+        self.integrations_apk = (
+            f"inotia00-{self.normal_integrations_apk}"
+            if self.build_extended
+            else self.normal_integrations_apk
+        )
+        self.apk_mirror_urls = {
+            "reddit": f"{self.apk_mirror}/apk/redditinc/reddit/",
+            "twitter": f"{self.apk_mirror}/apk/twitter-inc/twitter/",
+            "tiktok": f"{self.apk_mirror}/apk/tiktok-pte-ltd/tik-tok-including-musical-ly/",
+            "warnwetter": f"{self.apk_mirror}/apk/deutscher-wetterdienst/warnwetter/",
+            "youtube": f"{self.apk_mirror}/apk/google-inc/youtube/",
+            "youtube_music": f"{self.apk_mirror}/apk/google-inc/youtube-music/",
+        }
+        self.apk_mirror_version_urls = {
+            "reddit": f"{self.apk_mirror_urls.get('reddit')}reddit",
+            "twitter": f"{self.apk_mirror_urls.get('twitter')}twitter",
+            "tiktok": f"{self.apk_mirror_urls.get('tiktok')}tik-tok-including-musical-ly",
+            "warnwetter": f"{self.apk_mirror_urls.get('warnwetter')}warnwetter",
+            "youtube": f"{self.apk_mirror_urls.get('youtube')}youtube",
+            "youtube_music": f"{self.apk_mirror_urls.get('youtube_music')}youtube-music",
+        }

src/downloader.py

@@ -1,72 +1,31 @@
 import re
 import sys
 from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
 from queue import PriorityQueue
 from time import perf_counter
 from typing import Tuple
 
 import requests
-from environs import Env
 from loguru import logger
-from requests import Session
 from selectolax.lexbor import LexborHTMLParser
 from tqdm import tqdm
 
+from src.config import RevancedConfig
+
 
 class Downloader(object):
-    def __init__(self, env: Env):
+    def __init__(self, config: RevancedConfig):
         self._CHUNK_SIZE = 2**21 * 5
         self._QUEUE: PriorityQueue[Tuple[float, str]] = PriorityQueue()
         self._QUEUE_LENGTH = 0
-        self.temp_folder = Path("apks")
+        self.config = config
-
-        self.session = Session()
-        self.session.headers["User-Agent"] = "anything"
-        self.build_extended = env.bool("BUILD_EXTENDED", False)
-        self.apk_mirror = "https://www.apkmirror.com"
-        self.normal_cli_jar = "revanced-cli.jar"
-        self.normal_patches_jar = "revanced-patches.jar"
-        self.normal_integrations_apk = "revanced-integrations.apk"
-        self.cli_jar = (
-            f"inotia00-{self.normal_cli_jar}"
-            if self.build_extended
-            else self.normal_cli_jar
-        )
-        self.patches_jar = (
-            f"inotia00-{self.normal_patches_jar}"
-            if self.build_extended
-            else self.normal_patches_jar
-        )
-        self.integrations_apk = (
-            f"inotia00-{self.normal_integrations_apk}"
-            if self.build_extended
-            else self.normal_integrations_apk
-        )
-        self.apk_mirror_urls = {
-            "reddit": f"{self.apk_mirror}/apk/redditinc/reddit/",
-            "twitter": f"{self.apk_mirror}/apk/twitter-inc/twitter/",
-            "tiktok": f"{self.apk_mirror}/apk/tiktok-pte-ltd/tik-tok-including-musical-ly/",
-            "warnwetter": f"{self.apk_mirror}/apk/deutscher-wetterdienst/warnwetter/",
-            "youtube": f"{self.apk_mirror}/apk/google-inc/youtube/",
-            "youtube_music": f"{self.apk_mirror}/apk/google-inc/youtube-music/",
-        }
-        self.apk_mirror_version_urls = {
-            "reddit": f"{self.apk_mirror_urls.get('reddit')}reddit",
-            "twitter": f"{self.apk_mirror_urls.get('twitter')}twitter",
-            "tiktok": f"{self.apk_mirror_urls.get('tiktok')}tik-tok-including-musical-ly",
-            "warnwetter": f"{self.apk_mirror_urls.get('warnwetter')}warnwetter",
-            "youtube": f"{self.apk_mirror_urls.get('youtube')}youtube",
-            "youtube_music": f"{self.apk_mirror_urls.get('youtube_music')}youtube-music",
-        }
-        self.upto_down = ["spotify"]
         self.download_revanced()
 
     def _download(self, url: str, file_name: str) -> None:
         logger.debug(f"Trying to download {file_name} from {url}")
         self._QUEUE_LENGTH += 1
         start = perf_counter()
-        resp = self.session.get(url, stream=True)
+        resp = self.config.session.get(url, stream=True)
         total = int(resp.headers.get("content-length", 0))
         bar = tqdm(
             desc=file_name,
@@ -76,7 +35,7 @@ class Downloader(object):
             unit_divisor=1024,
             colour="green",
         )
-        with self.temp_folder.joinpath(file_name).open("wb") as dl_file, bar:
+        with self.config.temp_folder.joinpath(file_name).open("wb") as dl_file, bar:
             for chunk in resp.iter_content(self._CHUNK_SIZE):
                 size = dl_file.write(chunk)
                 bar.update(size)
@@ -85,17 +44,17 @@ class Downloader(object):
 
     def extract_download_link(self, page: str, app: str) -> None:
         logger.debug(f"Extracting download link from\n{page}")
-        parser = LexborHTMLParser(self.session.get(page).text)
+        parser = LexborHTMLParser(self.config.session.get(page).text)
 
-        resp = self.session.get(
+        resp = self.config.session.get(
-            self.apk_mirror + parser.css_first("a.accent_bg").attributes["href"]
+            self.config.apk_mirror + parser.css_first("a.accent_bg").attributes["href"]
         )
         parser = LexborHTMLParser(resp.text)
 
         href = parser.css_first(
             "p.notes:nth-child(3) > span:nth-child(1) > a:nth-child(1)"
         ).attributes["href"]
-        self._download(self.apk_mirror + href, f"{app}.apk")
+        self._download(self.config.apk_mirror + href, f"{app}.apk")
         logger.debug("Finished Extracting link and downloading")
 
     def get_download_page(self, parser: LexborHTMLParser, main_page: str) -> str:
@@ -111,12 +70,12 @@ class Downloader(object):
                 f"Unable to find any apk on apkmirror_specific_version on {main_page}"
             )
             sys.exit(-1)
-        download_url = self.apk_mirror + sub_url
+        download_url = self.config.apk_mirror + sub_url
         return download_url
 
     def __upto_down_downloader(self, app: str) -> str:
         page = "https://spotify.en.uptodown.com/android/download"
-        parser = LexborHTMLParser(self.session.get(page).text)
+        parser = LexborHTMLParser(self.config.session.get(page).text)
         main_page = parser.css_first("#detail-download-button")
         download_url = main_page.attributes["data-url"]
         app_version: str = parser.css_first(".version").text()
@@ -127,8 +86,8 @@ class Downloader(object):
     def apkmirror_specific_version(self, app: str, version: str) -> str:
         logger.debug(f"Trying to download {app},specific version {version}")
         version = version.replace(".", "-")
-        main_page = f"{self.apk_mirror_version_urls.get(app)}-{version}-release/"
+        main_page = f"{self.config.apk_mirror_version_urls.get(app)}-{version}-release/"
-        parser = LexborHTMLParser(self.session.get(main_page).text)
+        parser = LexborHTMLParser(self.config.session.get(main_page).text)
         download_page = self.get_download_page(parser, main_page)
         self.extract_download_link(download_page, app)
         logger.debug(f"Downloaded {app} apk from apkmirror_specific_version")
@@ -136,11 +95,11 @@ class Downloader(object):
 
     def apkmirror_latest_version(self, app: str) -> str:
         logger.debug(f"Trying to download {app}'s latest version from apkmirror")
-        page = self.apk_mirror_urls.get(app)
+        page = self.config.apk_mirror_urls.get(app)
         if not page:
             logger.debug("Invalid app")
             sys.exit(1)
-        parser = LexborHTMLParser(self.session.get(page).text)
+        parser = LexborHTMLParser(self.config.session.get(page).text)
         main_page = parser.css_first(".appRowVariantTag>.accent_color").attributes[
             "href"
         ]
@@ -152,8 +111,8 @@ class Downloader(object):
         extra_release = main_page.rfind("release") - 1
         version: str = main_page[int_version:extra_release]
         version = version.replace("-", ".")
-        main_page = f"{self.apk_mirror}{main_page}"
+        main_page = f"{self.config.apk_mirror}{main_page}"
-        parser = LexborHTMLParser(self.session.get(main_page).text)
+        parser = LexborHTMLParser(self.config.session.get(main_page).text)
         download_page = self.get_download_page(parser, main_page)
         self.extract_download_link(download_page, app)
         logger.debug(f"Downloaded {app} apk from apkmirror_specific_version in rt")
@@ -173,16 +132,16 @@ class Downloader(object):
 
     def download_revanced(self) -> None:
         assets = [
-            ["revanced", "revanced-cli", self.normal_cli_jar],
+            ["revanced", "revanced-cli", self.config.normal_cli_jar],
-            ["revanced", "revanced-integrations", self.normal_integrations_apk],
+            ["revanced", "revanced-integrations", self.config.normal_integrations_apk],
-            ["revanced", "revanced-patches", self.normal_patches_jar],
+            ["revanced", "revanced-patches", self.config.normal_patches_jar],
             ["inotia00", "VancedMicroG", "VancedMicroG.apk"],
         ]
-        if self.build_extended:
+        if self.config.build_extended:
             assets += [
-                ["inotia00", "revanced-cli", self.cli_jar],
+                ["inotia00", "revanced-cli", self.config.cli_jar],
-                ["inotia00", "revanced-integrations", self.integrations_apk],
+                ["inotia00", "revanced-integrations", self.config.integrations_apk],
-                ["inotia00", "revanced-patches", self.patches_jar],
+                ["inotia00", "revanced-patches", self.config.patches_jar],
             ]
         with ThreadPoolExecutor(7) as executor:
             executor.map(lambda repo: self.repository(*repo), assets)
@@ -198,7 +157,7 @@ class Downloader(object):
             return self.apkmirror_latest_version(app)
 
     def download_apk_to_patch(self, version: str, app: str) -> str:
-        if app in self.upto_down:
+        if app in self.config.upto_down:
             return self.upto_down_downloader(app)
         else:
             return self.download_from_apkmirror(version, app)

src/parser.py

@@ -1,43 +1,20 @@
 import sys
-from pathlib import Path
 from subprocess import PIPE, Popen
 from time import perf_counter
 from typing import List
 
-from environs import Env
 from loguru import logger
 
+from src.config import RevancedConfig
 from src.patches import Patches
 
 
 class Parser(object):
-    def __init__(self, patcher: Patches, env: Env, temp_folder: Path) -> None:
+    def __init__(self, patcher: Patches, config: RevancedConfig) -> None:
         self._PATCHES: List[str] = []
         self._EXCLUDED: List[str] = []
         self.patcher = patcher
-        self.keystore_name = env.str("KEYSTORE_FILE_NAME", "revanced.keystore")
+        self.config = config
-        self.build_extended = env.bool("BUILD_EXTENDED", False)
-        self.extended_apps = ["youtube", "youtube_music"]
-        self.keystore_name = env.str("KEYSTORE_FILE_NAME", "revanced.keystore")
-        self.normal_cli_jar = "revanced-cli.jar"
-        self.normal_patches_jar = "revanced-patches.jar"
-        self.normal_integrations_apk = "revanced-integrations.apk"
-        self.cli_jar = (
-            f"inotia00-{self.normal_cli_jar}"
-            if self.build_extended
-            else self.normal_cli_jar
-        )
-        self.patches_jar = (
-            f"inotia00-{self.normal_patches_jar}"
-            if self.build_extended
-            else self.normal_patches_jar
-        )
-        self.integrations_apk = (
-            f"inotia00-{self.normal_integrations_apk}"
-            if self.build_extended
-            else self.normal_integrations_apk
-        )
-        self.temp_folder = temp_folder
 
     def include(self, name: str) -> None:
         self._PATCHES.extend(["-i", name])
@@ -51,13 +28,13 @@ class Parser(object):
 
     def patch_app(self, app: str, version: str, is_experimental: bool = False) -> None:
         logger.debug(f"Sending request to revanced cli for building {app} revanced")
-        cli = self.normal_cli_jar
+        cli = self.config.normal_cli_jar
-        patches = self.normal_patches_jar
+        patches = self.config.normal_patches_jar
-        integrations = self.normal_integrations_apk
+        integrations = self.config.normal_integrations_apk
-        if self.build_extended and app in self.extended_apps:
+        if self.config.build_extended and app in self.config.extended_apps:
-            cli = self.cli_jar
+            cli = self.config.cli_jar
-            patches = self.patches_jar
+            patches = self.config.patches_jar
-            integrations = self.integrations_apk
+            integrations = self.config.integrations_apk
         args = [
             "-jar",
             cli,
@@ -70,12 +47,12 @@ class Parser(object):
             "-o",
             f"Re-{app}-{version}-output.apk",
             "--keystore",
-            self.keystore_name,
+            self.config.keystore_name,
         ]
         if is_experimental:
             logger.debug("Using experimental features")
             args.append("--experimental")
-        args[1::2] = map(lambda i: self.temp_folder.joinpath(i), args[1::2])
+        args[1::2] = map(lambda i: self.config.temp_folder.joinpath(i), args[1::2])
 
         if self._PATCHES:
             args.extend(self._PATCHES)

src/patches.py

@@ -2,11 +2,10 @@ import subprocess
 import sys
 from typing import Any, Dict, List, Tuple
 
-from environs import Env
 from loguru import logger
 from requests import Session
 
-from src.utils import supported_apps
+from src.config import RevancedConfig
 
 
 class Patches(object):
@@ -54,7 +53,7 @@ class Patches(object):
                     p["app"] = compatible_package
                     p["version"] = version[-1] if version else "all"
                     getattr(self, app_name).append(p)
-        if self.build_extended:
+        if self.config.build_extended:
             url = "https://raw.githubusercontent.com/inotia00/revanced-patches/revanced-extended/patches.json"
         else:
             url = "https://raw.githubusercontent.com/revanced/revanced-patches/main/patches.json"
@@ -88,13 +87,10 @@ class Patches(object):
             n_patches = len(getattr(self, app_id))
             logger.debug(f"Total patches in {app_name} are {n_patches}")
 
-    def __init__(self, env: Env) -> None:
+    def __init__(self, config: RevancedConfig) -> None:
-        self.env = env
+        self.config = config
-        self.apps = env.list("PATCH_APPS", supported_apps)
-        self.build_extended = env.bool("BUILD_EXTENDED", False)
         self.check_java()
         self.fetch_patches()
-        self.extended_apps: List[str] = ["youtube", "youtube_music"]
 
     def get(self, app: str) -> Tuple[List[Dict[str, str]], str]:
         logger.debug("Getting patches for %s" % app)
@@ -123,12 +119,12 @@ class Patches(object):
         self, app: str, arg_parser: Any, app_patches: List[Dict[str, str]]
     ) -> None:
         logger.debug(f"Excluding patches for app {app}")
-        if self.build_extended and app in self.extended_apps:
+        if self.config.build_extended and app in self.config.extended_apps:
-            excluded_patches = self.env.list(
+            excluded_patches = self.config.env.list(
                 f"EXCLUDE_PATCH_{app}_EXTENDED".upper(), []
             )
         else:
-            excluded_patches = self.env.list(f"EXCLUDE_PATCH_{app}".upper(), [])
+            excluded_patches = self.config.env.list(f"EXCLUDE_PATCH_{app}".upper(), [])
         for patch in app_patches:
             arg_parser.include(patch["name"]) if patch[
                 "name"
@@ -142,7 +138,7 @@ class Patches(object):
     def get_app_configs(self, app: str) -> Tuple[List[Dict[str, str]], str, bool]:
         experiment = False
         total_patches, recommended_version = self.get(app=app)
-        env_version = self.env.str(f"{app}_VERSION".upper(), None)
+        env_version = self.config.env.str(f"{app}_VERSION".upper(), None)
         if env_version:
             logger.debug(f"Picked {app} version {env_version} from env.")
             if env_version == "latest" or env_version > recommended_version: