NikGapps 3.13__py3-none-any.whl → 3.15__py3-none-any.whl

NikGapps/build/Build.py

@@ -1,5 +1,8 @@
+import concurrent.futures
 import os
+from multiprocessing import cpu_count
 from pathlib import Path
+from threading import Lock
 
 from NikGapps.helper import Config
 from NikGapps.helper.Package import Package
@@ -7,6 +10,7 @@ from NikGapps.helper.FileOp import FileOp
 from NikGapps.helper.Cmd import Cmd
 from NikGapps.helper.AppSet import AppSet
 from NikGapps.helper.Statics import Statics
+from NikGapps.helper.T import T
 
 
 class Build:
@@ -15,115 +19,130 @@ class Build:
     # Just provide the package list, and it will pick them up from the directory and build them for you
     @staticmethod
     def build_from_directory(app_set_build_list, android_version, cached=False):
-        source_directory = Config.CACHED_SOURCE if cached else Config.APK_SOURCE
+        if cached:
+            return app_set_build_list
+        building = T()
+        source_directory = Config.APK_SOURCE
         print(f"Building from {source_directory}")
         cmd = Cmd()
         app_set_list = []
-        for app_set in app_set_build_list:
-            app_set: AppSet
-            name = app_set.title
-            app_set_path = os.path.join(source_directory, name)
-            package_list = []
-            for package in app_set.package_list:
-                package: Package
-                print(f"Setting up {name}/{package.package_title}")
-                pkg_to_build = package
-                package_title = pkg_to_build.package_title
-                pkg_path = os.path.join(str(app_set_path), package_title)
-                file_dict = dict()
-                folder_dict = dict()
-                install_list = []
-                package_name = None
-                app_type = None
-                primary_app_location = None
-                delete_files_list = []
-                delete_overlay_list = []
-                if float(android_version) >= 12.1:
-                    overlay_directory = Config.OVERLAY_SOURCE
-                    overlay_dir = overlay_directory + Statics.dir_sep + f"{package_title}Overlay"
-                    if FileOp.dir_exists(overlay_dir):
-                        for file in Path(overlay_dir).rglob("*.apk"):
-                            pkg_files_path = "overlay" + Statics.dir_sep + Path(file).name
-                            install_list.append(pkg_files_path.replace("___", "/"))
-                            file_dict_value = str(pkg_files_path.replace("___", "/")).replace("\\", "/")
-                            value = str(file_dict_value).split("/")
-                            file_dict[str(file)] = "___" + "___".join(value[:len(value) - 1]) + "/" + value[
-                                len(value) - 1]
-                for pkg_files in Path(pkg_path).rglob("*"):
-                    if Path(pkg_files).is_dir() or str(pkg_files).__contains__(".git") \
-                            or str(pkg_files).endswith(".gitattributes") or str(pkg_files).endswith("README.md"):
-                        continue
-                    if str(pkg_files).endswith(Statics.DELETE_FILES_NAME):
-                        for str_data in FileOp.read_string_file(pkg_files):
-                            delete_file = str_data[:-1]
-                            if delete_file not in pkg_to_build.delete_files_list:
-                                delete_files_list.append(delete_file)
-                        continue
-                    pkg_files_path = str(pkg_files)
-                    pkg_files_path = pkg_files_path[pkg_files_path.find("___") + 3:]
-                    if pkg_files_path.replace("\\", "/").__eq__(f"etc___permissions/{package.package_name}.xml"):
+        max_workers = cpu_count()
+        lock = Lock()
+
+        def process_package(app_set_obj, pkg_obj):
+            package_title = pkg_obj.package_title
+            app_set_path = os.path.join(source_directory, app_set_obj.title)
+            pkg_path = os.path.join(str(app_set_path), package_title)
+
+            print(f"Setting up {app_set_obj.title}/{package_title}")
+
+            file_dict = {}
+            folder_dict = {}
+            install_list = []
+            delete_files_list = []
+            delete_overlay_list = []
+            package_name = None
+            app_type = None
+            primary_app_location = None
+
+            if float(android_version) >= 12.1:
+                overlay_directory = Config.OVERLAY_SOURCE
+                overlay_dir = overlay_directory + Statics.dir_sep + f"{package_title}Overlay"
+                if FileOp.dir_exists(overlay_dir):
+                    for file in Path(overlay_dir).rglob("*.apk"):
+                        pkg_files_path = "overlay" + Statics.dir_sep + Path(file).name
+                        install_list.append(pkg_files_path.replace("___", "/"))
+                        file_dict_value = str(pkg_files_path.replace("___", "/")).replace("\\", "/")
+                        value = str(file_dict_value).split("/")
+                        file_dict[str(file)] = "___" + "___".join(value[:len(value) - 1]) + "/" + value[len(value) - 1]
+
+            for pkg_files in Path(pkg_path).rglob("*"):
+                if Path(pkg_files).is_dir() or str(pkg_files).__contains__(".git") \
+                        or str(pkg_files).endswith(".gitattributes") or str(pkg_files).endswith("README.md"):
+                    continue
+                if str(pkg_files).endswith(Statics.DELETE_FILES_NAME):
+                    for str_data in FileOp.read_string_file(pkg_files):
+                        delete_file = str_data.strip()
+                        if delete_file not in delete_files_list:
+                            delete_files_list.append(delete_file)
+                    continue
+                pkg_files_path = str(pkg_files)
+                pkg_files_path = pkg_files_path[pkg_files_path.find("___") + 3:]
+                if pkg_files_path.replace("\\", "/").__eq__(f"etc___permissions/{pkg_obj.package_name}.xml"):
+                    continue
+                if pkg_obj.package_name is not None and str(pkg_files_path).endswith(".apk") and not str(
+                        pkg_files).__contains__("split_") and not str(pkg_files).__contains__("___m") \
+                        and not str(pkg_files).__contains__("___overlay"):
+                    primary_app_location = pkg_files.absolute()
+                    package_name = cmd.get_package_details(primary_app_location, "name")
+                    if str(primary_app_location).__contains__("___priv-app___"):
+                        app_type = Statics.is_priv_app
+                    elif str(primary_app_location).__contains__("___app___"):
+                        app_type = Statics.is_system_app
+                for folder in FileOp.get_dir_list(pkg_files_path):
+                    if folder.startswith("system") or folder.startswith("vendor") \
+                            or folder.startswith("product") or folder.startswith("system_ext") \
+                            or folder.startswith("overlay"):
                         continue
-                    if pkg_to_build.package_name is not None and str(pkg_files_path).endswith(".apk") and not str(
-                            pkg_files).__contains__("split_") and not str(pkg_files).__contains__("___m") \
-                            and not str(pkg_files).__contains__("___overlay"):
-                        primary_app_location = pkg_files.absolute()
-                        package_name = cmd.get_package_details(primary_app_location, "name")
-                        # print("File: " + package_name)
-                        # package_version = cmd.get_package_details(primary_app_location, "versionName")
-                        # print("Package Version: " + package_version)
-                        # package_code = cmd.get_package_details(primary_app_location, "versionCode")
-                        # print("Package Code: " + package_code)
-                        if str(primary_app_location).__contains__("___priv-app___"):
-                            app_type = Statics.is_priv_app
-                        elif str(primary_app_location).__contains__("___app___"):
-                            app_type = Statics.is_system_app
-                    for folder in FileOp.get_dir_list(pkg_files_path):
-                        if folder.startswith("system") or folder.startswith("vendor") \
-                                or folder.startswith("product") or folder.startswith("system_ext") \
-                                or folder.startswith("overlay"):
-                            continue
-                        folder_dict[folder] = folder
-                    # We don't need this but for the sake of consistency
-                    if str(pkg_files_path).endswith("xml") or str(pkg_files_path).endswith("prop"):
-                        FileOp.convert_to_lf(str(pkg_files.absolute()))
-                    install_list.append(pkg_files_path.replace("___", "/"))
-                    file_dict_value = str(pkg_files_path.replace("___", "/")).replace("\\", "/")
-                    value = str(file_dict_value).split("/")
-                    file_dict[pkg_files.absolute()] = "___" + "___".join(value[:len(value) - 1]) + "/" + value[
-                        len(value) - 1]
-                if primary_app_location is not None:
-                    title = os.path.basename(primary_app_location)[:-4]
-                else:
-                    title = package_title
-                pkg = Package(title, package_name, app_type, package_title)
-                pkg.install_list = install_list
-                pkg.partition = pkg_to_build.partition
-                pkg.clean_flash_only = pkg_to_build.clean_flash_only
-                pkg.file_dict = file_dict
-                pkg.folder_dict = folder_dict
-                pkg.addon_index = pkg_to_build.addon_index
-                pkg.additional_installer_script = pkg_to_build.additional_installer_script
-                pkg.primary_app_location = primary_app_location
-                # Generate priv-app permissions whitelist
-                if pkg.primary_app_location is not None and app_type == Statics.is_priv_app:
-                    permissions_list = cmd.get_white_list_permissions(primary_app_location)
-                    for perm in pkg_to_build.priv_app_permissions:
-                        permissions_list.append(perm)
-                    if permissions_list.__len__() >= 1 and not permissions_list[0].__contains__("Exception"):
-                        pkg.priv_app_permissions_str = pkg.generate_priv_app_whitelist(app_set.title, permissions_list,
-                                                                                       android_version=android_version,
-                                                                                       pkg_path=source_directory)
-                # Add the deleted files from the pkg_to_build object
-                for delete_file in pkg_to_build.delete_files_list:
-                    delete_files_list.append(delete_file)
-                pkg.delete_files_list = delete_files_list
-                for delete_overlay in pkg_to_build.delete_overlay_list:
-                    delete_overlay_list.append(delete_overlay)
-                pkg.delete_overlay_list = delete_overlay_list
-                pkg.validation_script = pkg_to_build.validation_script
-                pkg.overlay_list = pkg_to_build.overlay_list
-                package_list.append(pkg)
-            if package_list.__len__() > 0:
-                app_set_to_build = AppSet(app_set.title, package_list)
-                app_set_list.append(app_set_to_build)
+                    folder_dict[folder] = folder
+                # We don't need this but for the sake of consistency
+                if str(pkg_files_path).endswith("xml") or str(pkg_files_path).endswith("prop"):
+                    FileOp.convert_to_lf(str(pkg_files.absolute()))
+                install_list.append(pkg_files_path.replace("___", "/"))
+                file_dict_value = str(pkg_files_path.replace("___", "/")).replace("\\", "/")
+                value = str(file_dict_value).split("/")
+                file_dict[pkg_files.absolute()] = "___" + "___".join(value[:len(value) - 1]) + "/" + value[
+                    len(value) - 1]
+
+            if primary_app_location is not None:
+                title = os.path.basename(primary_app_location)[:-4]
+            else:
+                title = package_title
+
+            # Create a new Package object with the gathered data
+            pkg = Package(title, package_name, app_type, package_title)
+            pkg.install_list = install_list
+            pkg.partition = pkg_obj.partition
+            pkg.clean_flash_only = pkg_obj.clean_flash_only
+            pkg.file_dict = file_dict
+            pkg.folder_dict = folder_dict
+            pkg.addon_index = pkg_obj.addon_index
+            pkg.additional_installer_script = pkg_obj.additional_installer_script
+            pkg.primary_app_location = primary_app_location
+
+            if pkg.primary_app_location is not None and app_type == Statics.is_priv_app:
+                permissions_list = cmd.get_white_list_permissions(primary_app_location)
+                for perm in pkg_obj.priv_app_permissions:
+                    permissions_list.append(perm)
+                if permissions_list and not permissions_list[0].__contains__("Exception"):
+                    pkg.priv_app_permissions_str = pkg.generate_priv_app_whitelist(app_set_obj.title, permissions_list,
+                                                                                   android_version=android_version,
+                                                                                   pkg_path=source_directory)
+            pkg.delete_files_list = delete_files_list
+            pkg.delete_overlay_list = delete_overlay_list
+            pkg.validation_script = pkg_obj.validation_script
+            pkg.overlay_list = pkg_obj.overlay_list
+
+            return pkg
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            app_set_futures = {}
+
+            for app_set in app_set_build_list:
+                futures = []
+                for pkg_object in app_set.package_list:
+                    future = executor.submit(process_package, app_set, pkg_object)
+                    futures.append(future)
+                app_set_futures[app_set.title] = futures
+
+            for app_set_title, futures in app_set_futures.items():
+                package_list = []
+                for future in concurrent.futures.as_completed(futures):
+                    package_list.append(future.result())
+
+                if package_list:
+                    with lock:
+                        app_set_to_build = AppSet(app_set_title, package_list)
+                        app_set_list.append(app_set_to_build)
+        print(f"Total Time Taken: {building.taken()}")
         return app_set_list

NikGapps/build/Release.py

@@ -51,7 +51,6 @@ class Release:
             config_obj.config_package_list = []
             z = Export(file_name=file_name, sign=sign_zip)
             zip_result = z.zip(config_obj=config_obj, send_zip_device=Config.SEND_ZIP_DEVICE,
-                               fresh_build=Config.FRESH_BUILD,
                                telegram=telegram, compression_mode=Modes.DEFAULT)
             if zip_result[1] and Config.UPLOAD_FILES:
                 print(f"Uploading {zip_result[0]}")

NikGapps/helper/FileOp.py

@@ -2,14 +2,13 @@ import hashlib
 import os.path
 import shutil
 import stat
-
-from .Statics import Statics
+from pathlib import Path
 
 
 class FileOp:
     @staticmethod
     def create_file_dir(file_path):
-        parent_dir = str(Statics.get_parent_path(file_path))
+        parent_dir = str(Path(file_path).parent)
         if not os.path.exists(parent_dir):
             os.makedirs(parent_dir)
 

NikGapps/helper/Statics.py

@@ -14,7 +14,8 @@ class Statics:
         '12': {'sdk': '31', 'code': 'S'},
         '12.1': {'sdk': '32', 'code': 'SL'},
         '13': {'sdk': '33', 'code': 'T'},
-        '14': {'sdk': '34', 'code': 'U'}
+        '14': {'sdk': '34', 'code': 'U'},
+        '15': {'sdk': '35', 'code': 'V'},
     }
     is_system_app = 1
     is_priv_app = 2

NikGapps/helper/SystemStat.py

@@ -1,11 +1,12 @@
 import os
 import platform
+import shutil
 import subprocess
-from datetime import datetime
+from multiprocessing import cpu_count
 
 import psutil
-import pytz
 
+from . import Config
 from .Assets import Assets
 from .P import P
 from .T import T
@@ -35,6 +36,38 @@ class SystemStat:
         else:
             P.green(f"{location}: {time_str}")
 
+    @staticmethod
+    def get_disk_usage(path="/"):
+        total, used, free = shutil.disk_usage(path)
+        return total, used, free
+
+    @staticmethod
+    def print_disk_usage():
+        os_type = platform.system()
+
+        if os_type == "Windows":
+            # On Windows, you can specify a drive letter, e.g., "C:\\"
+            path = "C:\\"
+            total, used, free = SystemStat.get_disk_usage(path)
+        elif os_type == "Linux" or os_type == "Darwin":
+            # On Linux and macOS, use the root path
+            path = "/"
+            total, used, free = SystemStat.get_disk_usage(path)
+        else:
+            print(f"Unsupported OS: {os_type}")
+            return
+
+        # Convert bytes to gigabytes
+        total_gb = total / (2 ** 30)
+        used_gb = used / (2 ** 30)
+        free_gb = free / (2 ** 30)
+
+        print(f"Operating System: {os_type}")
+        print(f"Disk Usage for {path}")
+        print(f"Total: {total_gb:.2f} GiB")
+        print(f"Used: {used_gb:.2f} GiB")
+        print(f"Free: {free_gb:.2f} GiB")
+
     @staticmethod
     def show_stats():
         # Memory and CPU info
@@ -43,20 +76,20 @@ class SystemStat:
         total_ram_in_gb = round(mem.total / 1073741824, 2)
         P.green("---------------------------------------")
         P.green(f"Ram: {total_ram_in_bytes} bytes, {total_ram_in_gb} Gb")
-        P.green(f"# of CPUs: {os.cpu_count()}")
+        P.green(f"# of CPUs: {os.cpu_count()}({cpu_count()})")
         P.green("---------------------------------------")
-        P.green(f"Running on system: {platform.system()}")
+        SystemStat.print_disk_usage()
         # Versions of Java, ADB, and AAPT
         # java_version = SystemStat.run_command(["java", "-version"])
-        adb_version = SystemStat.run_command([f"{Assets.adb_path}", "version"])
-        aapt_version = SystemStat.run_command([f"{Assets.aapt_path}", "version"])
-        P.green("---------------------------------------")
         # P.green(f"Java version: {java_version}")
         # P.green("---------------------------------------")
-        P.green(f"ADB version: {adb_version}")
+        if (not Config.ENVIRONMENT_TYPE == "production") and Config.ENVIRONMENT_TYPE == "dev":
+            adb_version = SystemStat.run_command([f"{Assets.adb_path}", "version"])
+            P.green("---------------------------------------")
+            P.green(f"ADB version: {adb_version}")
         P.green("---------------------------------------")
+        aapt_version = SystemStat.run_command([f"{Assets.aapt_path}", "version"])
         P.green(f"AAPT version: {aapt_version}")
-
         P.green("---------------------------------------")
         t = T()
         local_time = t.get_local_date_time("%a, %m/%d/%Y, %I:%M:%S %p")

NikGapps/helper/compression/Export.py

@@ -1,14 +1,18 @@
-from .. import Config
-from ..P import P
-from ..FileOp import FileOp
-from ..Assets import Assets
-from ..Package import Package
-from ..AppSet import AppSet
-from ..Cmd import Cmd
+import concurrent.futures
+import concurrent.futures
 import os
-from .Zip import Zip
+import threading
+from multiprocessing import cpu_count
+from threading import Lock
+
 from .CompOps import CompOps
 from .Modes import Modes
+from .Zip import Zip
+from .. import Config
+from ..Assets import Assets
+from ..Cmd import Cmd
+from ..FileOp import FileOp
+from ..P import P
 from ..Statics import Statics
 from ..T import T
 from ..web.TelegramApi import TelegramApi
@@ -21,111 +25,102 @@ class Export:
         self.z = Zip(self.file_name, sign=sign, private_key_path=Assets.private_key_pem)
 
     def zip(self, config_obj: NikGappsConfig, telegram: TelegramApi = TelegramApi(None, None),
-            compression_mode=Modes.DEFAULT, send_zip_device=Config.SEND_ZIP_DEVICE, fresh_build=Config.FRESH_BUILD):
-        app_set_list = config_obj.config_package_list
-        config_string = config_obj.get_nikgapps_config()
-        android_version = config_obj.android_version
-        total_packages = 0
-        print_progress = ""
+            compression_mode=Modes.DEFAULT, send_zip_device=Config.SEND_ZIP_DEVICE):
+
         build_zip = T()
+        app_set_list = config_obj.config_package_list
+        max_workers = cpu_count()
+        lock = Lock()
+        total_packages = sum(len(app_set.package_list) for app_set in app_set_list)
+        completed_packages = 0
         file_sizes = ""
         zip_execution_status = False
-        arch = "" if config_obj.arch == "arm64" else "_" + config_obj.arch
-        cache_source_dir = Statics.pwd + Statics.dir_sep + str(android_version) + arch + f"_{Config.RELEASE_TYPE}" + (
-            f"_cached" if Config.USE_CACHED_APKS else "")
-        try:
-            app_set_count = len(app_set_list)
-            app_set_index = 1
-            telegram.message("- Gapps is building...")
+        telegram.message(f"Progress {0:.2f}% ({completed_packages}/{total_packages})")
+
+        def compress_and_add_file(appset, pakg, compressionmode):
+            nonlocal completed_packages
+            nonlocal file_sizes
+            thread_id = threading.get_ident()
+
+            pkg_zip_path = (
+                    Statics.get_temp_packages_directory(config_obj.android_version, arch=config_obj.arch)
+                    + Statics.dir_sep + "Packages" + Statics.dir_sep + str(pakg.package_title) + compressionmode
+            )
+            pkg_txt_path = pkg_zip_path.replace(compression_mode, "") + "_" + compression_mode[1:] + ".txt"
+
+            if Config.USE_CACHED_APKS:
+                print(f"Using cached package: {os.path.basename(pkg_zip_path)}")
+                cached_pkg_zip_path = os.path.join(Config.CACHED_SOURCE, appset.title,
+                                                   f"{pakg.package_title}{compression_mode}")
+                if FileOp.file_exists(cached_pkg_zip_path):
+                    pkg_zip_path = cached_pkg_zip_path
+                    pkg_txt_path = pkg_zip_path.replace(compression_mode, "") + "_" + compression_mode[
+                                                                                      1:] + ".txt"
+                else:
+                    print(cached_pkg_zip_path + " doesn't exist!")
+            else:
+                CompOps.compress_package(pkg_zip_path, pakg, compression_mode)
+
+            for size_on_file in FileOp.read_string_file(pkg_txt_path):
+                pkg_size = size_on_file
+                pakg.pkg_size = pkg_size
+
+            with lock:
+                self.z.add_file(pkg_zip_path, f"AppSet/{appset.title}/{pakg.package_title}{compressionmode}")
+                file_sizes = file_sizes + str(pakg.package_title) + "=" + str(pakg.pkg_size) + "\n"
+                completed_packages += 1
+                progress = (completed_packages / total_packages) * 100
+                telegram.message(f"Progress {progress:.2f}% ({completed_packages}/{total_packages})",
+                                 replace_last_message=True)
+                P.blue(f"Progress {progress:.2f}% ({completed_packages}/{total_packages}): "
+                       f"{appset.title}/{pakg.package_title} (Thread {thread_id})")
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = []
             for app_set in app_set_list:
-                app_set: AppSet
-                app_set_progress = round(float(100 * app_set_index / app_set_count))
-                telegram.message(
-                    f"- Gapps is building... {str(app_set_progress)}% done",
-                    replace_last_message=True)
-                package_count = len(app_set.package_list)
-                package_index = 0
                 for pkg in app_set.package_list:
-                    pkg_size = 0
-                    # Creating <Packages>.zip for all the packages
-                    pkg: Package
-                    package_progress = round(float(100 * package_index / package_count))
-                    pkg_zip_path = (Statics.get_temp_packages_directory(android_version, arch=config_obj.arch)
-                                    + Statics.dir_sep + "Packages" + Statics.dir_sep + str(
-                                pkg.package_title) + compression_mode)
-                    pkg_txt_path = pkg_zip_path.replace(compression_mode, "") + "_" + compression_mode[1:] + ".txt"
-                    print_value = (f"AppSet ({str(app_set_progress)}%): {app_set.title} "
-                                   f"Zipping ({str(package_progress)}%): {pkg.package_title}")
-                    print(print_value)
-                    print_progress = print_progress + "\n" + print_value
-                    if Config.USE_CACHED_APKS:
-                        print(f"Using cached package: {os.path.basename(pkg_zip_path)}")
-                        cached_pkg_zip_path = os.path.join(cache_source_dir, app_set.title,
-                                                           f"{pkg.package_title}{compression_mode}")
-                        if FileOp.file_exists(cached_pkg_zip_path):
-                            pkg_zip_path = cached_pkg_zip_path
-                            pkg_txt_path = pkg_zip_path.replace(compression_mode, "") + "_" + compression_mode[
-                                                                                              1:] + ".txt"
-                        else:
-                            print(cached_pkg_zip_path + " doesn't exist!")
-                    else:
-                        CompOps.compress_package(pkg_zip_path, pkg, compression_mode)
-                    for size_on_file in FileOp.read_string_file(pkg_txt_path):
-                        pkg_size = size_on_file
-                        pkg.pkg_size = pkg_size
-                    self.z.add_file(pkg_zip_path,
-                                    "AppSet/" + str(app_set.title) + "/" + str(pkg.package_title) + compression_mode)
-                    package_index = package_index + 1
-                    total_packages += 1
-                    file_sizes = file_sizes + str(pkg.package_title) + "=" + str(pkg_size) + "\n"
-                app_set_index = app_set_index + 1
-            # Writing additional script files to the zip
-            self.z.add_string(self.get_installer_script(total_packages, app_set_list, compression_mode),
-                              "common/install.sh")
-            self.z.add_string("#MAGISK", Statics.meta_inf_dir + "updater-script")
-            self.z.add_file(Assets.magisk_update_binary, Statics.meta_inf_dir + "update-binary")
-            self.z.add_string(config_string, "afzc/nikgapps.config")
-            debloater_config_lines = ""
-            for line in Assets.get_string_resource(Assets.debloater_config):
-                debloater_config_lines += line
-            for line in config_obj.debloater_list:
-                debloater_config_lines += line + "\n"
-            self.z.add_string(debloater_config_lines, "afzc/debloater.config")
-            self.z.add_file(Assets.changelog, "changelog.yaml")
-            self.z.add_file(Assets.addon_path, "common/addon.sh")
-            self.z.add_file(Assets.header_path, "common/header.sh")
-            self.z.add_file(Assets.functions_path, "common/functions.sh")
-            self.z.add_string(file_sizes, "common/file_size.txt")
-            self.z.add_file(Assets.nikgapps_functions, "common/nikgapps_functions.sh")
-            self.z.add_file(Assets.mount_path, "common/mount.sh")
-            self.z.add_file(Assets.mtg_mount_path, "common/mtg_mount.sh")
-            self.z.add_file(Assets.unmount_path, "common/unmount.sh")
-            self.z.add_string(os.path.basename(os.path.splitext(self.file_name)[0]), "zip_name.txt")
-            self.z.add_string(f"Created by {config_obj.creator}".center(38, ' '), "creator.txt")
-            self.z.add_string(self.get_customize_sh(self.file_name), "customize.sh")
-            self.z.add_file(Assets.module_path, "module.prop")
-            self.z.add_file(Assets.busybox, "busybox")
-            zip_execution_status = True
-            P.green('The zip ' + self.file_name + ' is created successfully!')
-        except Exception as e:
-            print("Exception occurred while creating the zip " + str(e))
-        finally:
-            self.z.close()
-            time_taken = build_zip.taken("Total time taken to build the zip")
-            telegram.message("- Completed in: " + T.format_time(round(time_taken)))
-            file_name = self.file_name
-            if send_zip_device:
-                send_zip_device_time = T()
-                cmd = Cmd()
-                device_path = f"{Config.SEND_ZIP_LOCATION}/Afzc-" + str(
-                    android_version) + "/" + T.get_current_time() + "/" + os.path.basename(
-                    file_name)
-                message = f"Sending {os.path.basename(file_name)} to device at: " + device_path
-                print(message)
-
-                cmd.push_package(file_name, device_path)
-                send_zip_device_time.taken("Total time taken to send the zip to device")
-            return file_name, zip_execution_status
+                    futures.append(executor.submit(compress_and_add_file, app_set, pkg, compression_mode))
+
+        self.z.add_string(self.get_installer_script(total_packages, app_set_list, compression_mode),
+                          "common/install.sh")
+        self.z.add_string("#MAGISK", Statics.meta_inf_dir + "updater-script")
+        self.z.add_file(Assets.magisk_update_binary, Statics.meta_inf_dir + "update-binary")
+        self.z.add_string(config_obj.get_nikgapps_config(), "afzc/nikgapps.config")
+        debloater_config_lines = ""
+        for line in Assets.get_string_resource(Assets.debloater_config):
+            debloater_config_lines += line
+        for line in config_obj.debloater_list:
+            debloater_config_lines += line + "\n"
+        self.z.add_string(debloater_config_lines, "afzc/debloater.config")
+        self.z.add_file(Assets.changelog, "changelog.yaml")
+        self.z.add_file(Assets.addon_path, "common/addon.sh")
+        self.z.add_file(Assets.header_path, "common/header.sh")
+        self.z.add_file(Assets.functions_path, "common/functions.sh")
+        self.z.add_string(file_sizes, "common/file_size.txt")
+        self.z.add_file(Assets.nikgapps_functions, "common/nikgapps_functions.sh")
+        self.z.add_file(Assets.mount_path, "common/mount.sh")
+        self.z.add_file(Assets.mtg_mount_path, "common/mtg_mount.sh")
+        self.z.add_file(Assets.unmount_path, "common/unmount.sh")
+        self.z.add_string(os.path.basename(os.path.splitext(self.file_name)[0]), "zip_name.txt")
+        self.z.add_string(f"Created by {config_obj.creator}".center(38, ' '), "creator.txt")
+        self.z.add_string(self.get_customize_sh(self.file_name), "customize.sh")
+        self.z.add_file(Assets.module_path, "module.prop")
+        self.z.add_file(Assets.busybox, "busybox")
+        self.z.close()
+        zip_execution_status = True
+        P.green('The zip ' + self.file_name + ' is created successfully!')
+        time_taken = build_zip.taken("Total time taken to build the zip")
+        telegram.message("- Completed in: " + T.format_time(round(time_taken)))
+        if send_zip_device:
+            send_zip_device_time = T()
+            cmd = Cmd()
+            device_path = f"{Config.SEND_ZIP_LOCATION}/Afzc-" + str(
+                config_obj.android_version) + "/" + T.get_current_time() + "/" + os.path.basename(self.file_name)
+            message = f"Sending {os.path.basename(self.file_name)} to device at: " + device_path
+            print(message)
+            cmd.push_package(self.file_name, device_path)
+            send_zip_device_time.taken("Total time taken to send the zip to device")
+        return self.file_name, zip_execution_status
 
     @staticmethod
     def get_installer_script(total_packages, app_set_list, compression_mode=Modes.DEFAULT):

NikGapps/main.py

@@ -3,7 +3,6 @@ from NikGapps.build.Release import Release
 from NikGapps.helper.Args import Args
 from NikGapps.helper import Config
 from NikGapps.helper.SystemStat import SystemStat
-from NikGapps.helper.P import P
 from NikGapps.helper.T import T
 from NikGapps.helper.compression.Modes import Modes
 from NikGapps.helper.git.GitOperations import GitOperations

{NikGapps-3.13.dist-info → NikGapps-3.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NikGapps
-Version: 3.13
+Version: 3.15
 Summary: A short description of your project
 Home-page: https://github.com/nikgapps/project
 Author: Nikhil Menghani

{NikGapps-3.13.dist-info → NikGapps-3.15.dist-info}/RECORD

@@ -3,15 +3,15 @@ NikGapps/build_config.py,sha256=rPJqsSuzHZfZXTYfIoIyJ62kIlao5ytyJQQqAIVwNgQ,3103
 NikGapps/cache.py,sha256=VBp5T4_DKGxdBtWrLfaBVXFTi4LeI24L-31CszLhVYs,4124
 NikGapps/config_upload.py,sha256=0HE7txm73XXxat_cR0JDXWtQUmg1IYK_SktwJS6N34s,652
 NikGapps/copy_repos.py,sha256=5YygTyuFW-DRnLPLGVcndQO6JqBW4JsN7O6cVWDQ4pE,1379
-NikGapps/main.py,sha256=bUatevHVBbu88VtJUFCiMhEQ1bLC4xQuKPdU7e5OC3w,2684
+NikGapps/main.py,sha256=o10A9vjGN-C6kFf0BynssIybpuC8bRPon_49DWBUPYg,2652
 NikGapps/overlay_control.py,sha256=57m6DvzOczttXyfo8QAFeXGZo1TynB4w6Gjf1i0scfY,2873
 NikGapps/test.py,sha256=eXEeyM5xOpSKyUjb7OTP8BL37bqTE0eTKwnD1zT33rY,687
-NikGapps/build/Build.py,sha256=XBMAVce8VzsmVwLxo7fj8y8yBrpdVT-FFuaZ9LBWtxY,7917
+NikGapps/build/Build.py,sha256=5ru8mOUpZTJNqjfeVkppUPEvbj8XqMcdaGZlR74IOw4,7547
 NikGapps/build/NikGappsManager.py,sha256=U9eCJj8Gzj9wvondtaKyz77AiK0mkSzpKAjOZY50HhA,18643
 NikGapps/build/NikGappsOverlays.py,sha256=ApyO2bnPpsG80uEvuB_XoeVn7TRDGCCWtl5myJcVrFI,526
 NikGapps/build/NikGappsPackages.py,sha256=samBrWZxNWVi5U28vgvfRNENLSdbK37oYo1oe2EI-HA,56928
 NikGapps/build/PackageConstants.py,sha256=-vmkiAWXoD5Ba1lmqd71ueEkivY7ne0zXSU3dzCfYLc,15847
-NikGapps/build/Release.py,sha256=Ask__sJzxzJyZhzDsUq5zi8N3J5W3ZLbwzdmLo0fdko,4909
+NikGapps/build/Release.py,sha256=FChsFVmrFndEuvNk5nc288KCkFONUJ7SwsphgejVER4,4846
 NikGapps/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 NikGapps/config/NikGappsConfig.py,sha256=TSfwPWqxR4SE80lz-Jrn41yuTfSQcwi-jFh7iGmZFQQ,20411
 NikGapps/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -23,12 +23,12 @@ NikGapps/helper/C.py,sha256=MvRvtXLu-gjsJIXcMH73CSdbf_R-_LrmqS-ZKOtLrCU,354
 NikGapps/helper/Cmd.py,sha256=Fc4mywiDrJk9MI_Pw1Ow26gdpFL23D8EF2XbB1WmyBo,13540
 NikGapps/helper/Config.py,sha256=iCTMt5Zd3g3Rq0Y14u4i5e2-hCv9SKcSl4xMJ1KhYJE,2606
 NikGapps/helper/ConfigObj.py,sha256=ep9--o1SPgGXkElrjkf7hjF96KGSrmcQ9oGCpicN7D4,462
-NikGapps/helper/FileOp.py,sha256=rl0XnQxGuPpZqV50VZ_2uKWwgrhAjRmbrllXheBSiEg,7859
+NikGapps/helper/FileOp.py,sha256=vPgXFBUdzDCo36OyHLCn8Jt62Fhf29_OPPwvh6kv7Sc,7842
 NikGapps/helper/Json.py,sha256=pgkXXHMBGs0Pl6YjTXjDSqPdIXryWzl5c0YyR-2YPYQ,973
 NikGapps/helper/P.py,sha256=S3dTkLQcOhS1SEE9WZVIVQUAVtSIGhO8TDH72SxWLb8,516
 NikGapps/helper/Package.py,sha256=yYOm5kUf_a6HOo1UA78_qkm2b0pqn5RCPqLt4yR3B10,9236
-NikGapps/helper/Statics.py,sha256=BsUwa66wlZb74iS8z6TD9q7kMegU3ypGq6YwDXEdJy8,6850
-NikGapps/helper/SystemStat.py,sha256=tRxEHAJYkTrJ4xNk4iL3O0vFdUkNKRv3CCLoLvhgJKs,2891
+NikGapps/helper/Statics.py,sha256=dU19il9CmBO2QTksQH-Zo5qh6JFzJG1Z9gY4_Qgl8TM,6893
+NikGapps/helper/SystemStat.py,sha256=f5H5L8FOZVLe-7SKYdCtjnjVXsgaJ2Eo9c3akiYjJLM,4074
 NikGapps/helper/T.py,sha256=tp2VAVfy_lbIJKIbYsGFtDck65BUo8JiHqOokpkpaKE,2898
 NikGapps/helper/XmlOp.py,sha256=ZcaO6JSriNDiOvom6gs6XwucnFInjIXaigUiehgVpQY,1632
 NikGapps/helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -70,7 +70,7 @@ NikGapps/helper/assets/bin/Windows/aapt2.exe,sha256=a9gpiuyjWXrN-hy5ccATpT9gFXRu
 NikGapps/helper/assets/bin/Windows/aapt_64.exe,sha256=03cpoqV1bV_-cLR988i4VLK3Nwi9KvP5jTWCII02s0Y,1704960
 NikGapps/helper/assets/bin/Windows/adb.exe,sha256=LacPG0nNZJNWiYVnNTfKU13r3TGeo60pOd9YFQVE9Mo,3233280
 NikGapps/helper/compression/CompOps.py,sha256=ZcmtU957E0BOU1yKQKXvwHNK3Xtp6BIyXBjjvz0Rq6E,1768
-NikGapps/helper/compression/Export.py,sha256=2XvurJzl6Jaa99Qs8qNBxTVZ_CUXJ0tBcyJAXb1Isho,10178
+NikGapps/helper/compression/Export.py,sha256=9T9ul5euwLHXJEYfnniAydjBwGiUPrKWZbT-yVUxqWg,9237
 NikGapps/helper/compression/Modes.py,sha256=ifHezKw2uiBgmY33_7es_ox-WBHENYxdRB11jwVLOvU,71
 NikGapps/helper/compression/Tar.py,sha256=ooXkLJ1Ow0Ap9rhT_yMoOs7KalYA9CTC6-UVh9RpVsA,794
 NikGapps/helper/compression/Zip.py,sha256=4dDQIFyyewdeBTnO6ZnLkJrY7AvAeMqwYWWAcIiuSuQ,3766
@@ -99,9 +99,9 @@ NikGapps/helper/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 NikGapps/helper/web/Requests.py,sha256=HaZUHe_xi_7LjPLOYBUwK3uwOYOcVaW2E1zazjw2wow,5502
 NikGapps/helper/web/TelegramApi.py,sha256=XREdngh0vPvPMUOJsCJ3wSqXMFqS8q3qJUhmFMY6SH8,4743
 NikGapps/helper/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-NikGapps-3.13.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-NikGapps-3.13.dist-info/METADATA,sha256=_8mo_Kjnu2ZFdkG51Guu8vDllH3aFH0b479PcnIAwdw,4070
-NikGapps-3.13.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-NikGapps-3.13.dist-info/entry_points.txt,sha256=iKbeOiuELwTDu5kmQHrU9XBVASWRR6_TuRIRva2UnAY,286
-NikGapps-3.13.dist-info/top_level.txt,sha256=CD7RpCb7bzjyvpQLt8hh2gU6X1wj3Z0NIErVkg-nJI4,9
-NikGapps-3.13.dist-info/RECORD,,
+NikGapps-3.15.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+NikGapps-3.15.dist-info/METADATA,sha256=TqpCkmeU0XPkz_aZnwhO2kGaaMvmiU6VCt-m3NcE1tc,4070
+NikGapps-3.15.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+NikGapps-3.15.dist-info/entry_points.txt,sha256=iKbeOiuELwTDu5kmQHrU9XBVASWRR6_TuRIRva2UnAY,286
+NikGapps-3.15.dist-info/top_level.txt,sha256=CD7RpCb7bzjyvpQLt8hh2gU6X1wj3Z0NIErVkg-nJI4,9
+NikGapps-3.15.dist-info/RECORD,,

{NikGapps-3.13.dist-info → NikGapps-3.15.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any