NikGapps 3.28__py3-none-any.whl → 3.30__py3-none-any.whl

NikGapps/helper/C.py

@@ -1,16 +0,0 @@
-import os
-from pathlib import Path
-
-
-class C:
-    @staticmethod
-    def find_cwd():
-        cwd = os.getcwd()
-        if "requirements.txt" in os.listdir(cwd):
-            return cwd
-        parent_dir = str(Path(cwd).parent)
-        if "requirements.txt" in os.listdir(parent_dir):
-            return parent_dir
-        return cwd
-
-    ds = os.path.sep

NikGapps/helper/Cmd.py

@@ -1,296 +0,0 @@
-import os
-import sys
-from pathlib import Path
-from .Assets import Assets
-from .FileOp import FileOp
-import subprocess
-
-
-class Cmd:
-    commands_list = []
-    adb_path = ['adb']
-    if sys.platform.startswith('win32'):
-        commands_list = ['cmd', '/c']
-        adb_path = [Assets.adb_path]
-    aapt_path = [Assets.aapt_path]
-    if str(Assets.system_name).__eq__("Linux"):
-        aapt_path = [Assets.aapt_path]
-    elif str(Assets.system_name).__eq__("Darwin"):
-        aapt_path = [Assets.aapt_path]
-    sign_jar_path = Assets.sign_jar
-    COMMAND_ADB_DEVICES = adb_path + ["devices"]
-    COMMAND_ADB_KILL_SERVER = adb_path + ["kill-server"]
-    COMMAND_ADB_ROOT = adb_path + ["root"]
-    COMMAND_ADB_REMOUNT = adb_path + ["remount"]
-    COMMAND_ADB_PRODUCT_MODEL = adb_path + ["shell", "getprop", "ro.product.model"]
-    COMMAND_ADB_PRODUCT_NAME = adb_path + ["shell", "getprop", "ro.product.name"]
-    COMMAND_ADB_PRODUCT_DEVICE = adb_path + ["shell", "getprop", "ro.product.device"]
-    COMMAND_ADB_PULL = adb_path + ["pull", "source", "destination"]
-    COMMAND_ADB_PUSH = adb_path + ["push", "source", "destination"]
-    COMMAND_LIST_PACKAGES = adb_path + ["shell", "pm", "list", "packages"]
-    COMMAND_LIST_FILES = adb_path + ["shell", "ls", "-p", ""]
-    COMMAND_LIST_FILES_RECURSIVELY = adb_path + ["shell", "ls", "-R", ""]
-    COMMAND_LIST_PACKAGES_EXTENDED = adb_path + ["shell", "pm", "list", "packages", "-f"]
-    COMMAND_LIST_PACKAGES_SYSTEM = adb_path + ["shell", "pm", "list", "packages", "-s"]
-    COMMAND_PATH_PACKAGES = adb_path + ["shell", "pm", "path", "package"]
-    COMMAND_AAPT_DUMP_BADGING = aapt_path + ["dump", "badging", "apkFilePath"]
-    COMMAND_AAPT_DUMP_PACKAGENAME = aapt_path + ["dump", "packagename", "apkFilePath"]
-    COMMAND_AAPT_DUMP_PERMISSIONS = aapt_path + ["dump", "permissions", "apkFilePath"]
-    COMMAND_LIST_FILES_SU = adb_path + ["ls", "/data/app"]
-    COMMAND_ADB_SHELL_SU = adb_path + ["shell", "su"]
-    COMMAND_ANDROID_VERSION = adb_path + ["shell", "getprop", "ro.build.version.release"]
-    COMMAND_DEVICE_ARCHITECTURE = adb_path + ["shell", "getprop", "ro.product.cpu.abi"]
-    COMMAND_ADB_CONNECT_DEVICES = adb_path + ["connect", "IP"]
-    COMMAND_SIGN_ZIP = ["java", "-jar", sign_jar_path, "file_path", sign_jar_path, "false"]
-    COMMAND_BUILD_APK = ["java", "-jar", Assets.apktool_path, "b", "folder_name"]
-    COMMAND_DECOMPILE_APK = ["java", "-jar", Assets.apktool_path, "d", "apk_path", "-o", "folder_name"]
-    COMMAND_SIGN_APK = ["java", "-jar", Assets.apksigner_path, "sign", "--key", Assets.key_path, "--cert",
-                        Assets.cert_path, "-v", "outfile.apk"]
-    COMMAND_ZIPALIGN_APK = ["zipalign", "-p", "-f", "-v", "4", "infile.apk", "outfile.apk"]
-    COMMAND_ZIPALIGN_VERIFY = ["zipalign", "-c", "-v", "4", "outfile.apk"]
-
-    def build_apk(self, input_directory, output_file):
-        try:
-            subprocess.check_call(['apktool', 'b', input_directory, '-o', output_file])
-            print('APK built successfully')
-        except subprocess.CalledProcessError as e:
-            print('Failed to build APK: ', e)
-
-    def execute_adb_command(self, params):
-        return self.execute_cmd(self.adb_path + params)
-
-    def execute(self, command, capture_output=True, shell=False):
-        try:
-            command_to_execute = self.commands_list + command
-            result = subprocess.run(command_to_execute, encoding="utf-8", capture_output=capture_output, text=True,
-                                    shell=shell,
-                                    check=True)
-            return ['', result.stdout.split('\n'), True, result.returncode]
-        except subprocess.CalledProcessError as e:
-            return [e.stderr, e.stdout, False, e.returncode]
-        except Exception as e:
-            return [str(e), '', False, -1]
-
-    def execute_cmd(self, command):
-        command_to_execute = self.commands_list + command
-        p = subprocess.run(command_to_execute, encoding="utf-8", universal_newlines=True, stdout=subprocess.PIPE,
-                           stderr=subprocess.PIPE)
-        if p.returncode == 0:
-            return p.stdout.split('\n')
-        else:
-            exception_msg = "Exception occurred while executing " + str(command_to_execute) + " " + \
-                            p.stderr.split("\n")[0]
-            return [exception_msg, p.stdout]
-
-    def adb_has_root_permissions(self):
-        print("Checking for root permissions")
-        output_line = self.execute_cmd(self.COMMAND_ADB_REMOUNT)
-        if len(output_line) > 0:
-            for line in output_line:
-                if line.__contains__("Using a specified mount point") or line.__contains__("remount succeeded"):
-                    return True
-        return False
-
-    def build_overlay(self, folder_name):
-        print(f"Building {Path(folder_name).name} overlay")
-        self.COMMAND_BUILD_APK[4] = folder_name
-        built_apk = False
-        output_line = self.execute_cmd(self.COMMAND_BUILD_APK)
-        if len(output_line) > 0:
-            for line in output_line:
-                print(line)
-                if line.__contains__("Built apk"):
-                    built_apk = True
-                    break
-        apk_path = os.path.join(folder_name, "dist", f"{Path(folder_name).name}.apk")
-        if built_apk and FileOp.file_exists(apk_path):
-            print(f"Signing {Path(apk_path).name}")
-            signed_apk = False
-            self.COMMAND_SIGN_APK[9] = apk_path
-            output_line = self.execute_cmd(self.COMMAND_SIGN_APK)
-            if len(output_line) > 0:
-                for line in output_line:
-                    print(line)
-                    if line.__contains__("Signed"):
-                        signed_apk = True
-                        break
-            if signed_apk:
-                print(f"Zipaligning {apk_path}")
-                self.COMMAND_ZIPALIGN_APK[5] = apk_path
-                aligned_apk_path = os.path.join(folder_name, "dist", f"{Path(folder_name).name}-aligned.apk")
-                self.COMMAND_ZIPALIGN_APK[6] = aligned_apk_path
-                output_line = self.execute_cmd(self.COMMAND_ZIPALIGN_APK)
-                if len(output_line) > 0:
-                    for line in output_line:
-                        print(line)
-                        if line.__contains__("Verification succesful") or line.__contains__("Verification successful"):
-                            return aligned_apk_path
-        return ""
-
-    def decompile_apk(self, apk_path, output_folder):
-        self.COMMAND_DECOMPILE_APK[4] = apk_path
-        self.COMMAND_DECOMPILE_APK[6] = output_folder
-        print(f"Decompiling {Path(apk_path).name} with command {self.COMMAND_DECOMPILE_APK}")
-        output_line = self.execute_cmd(self.COMMAND_DECOMPILE_APK)
-        if len(output_line) > 0:
-            for line in output_line:
-                print(line)
-                if line.__contains__("Copying original files..."):
-                    return True
-        return False
-
-    def established_device_connection_as_root(self):
-        if self.adb_has_root_permissions():
-            return True
-        else:
-            print("Killing Adb Server")
-            self.execute_cmd(self.COMMAND_ADB_KILL_SERVER)
-            self.execute_cmd(self.COMMAND_ADB_DEVICES)
-            self.execute_cmd(self.COMMAND_ADB_ROOT)
-            print("Checking for root permissions again")
-            if self.adb_has_root_permissions():
-                print("Acquiring root permissions")
-                return True
-        return False
-
-    def get_package_path(self, package_name):
-        self.COMMAND_PATH_PACKAGES[4] = package_name
-        output_list = self.execute_cmd(self.COMMAND_PATH_PACKAGES)
-        if output_list.__len__() == 1 and output_list[0].startswith("Exception occurred"):
-            return ["Exception occurred"]
-        return_list = []
-        if output_list is not None:
-            for path in output_list:
-                if path.__contains__(":"):
-                    return_list.append(path.split(':')[1])
-        return return_list
-
-    def get_package_files(self, package_folder):
-        self.COMMAND_LIST_FILES_RECURSIVELY[4] = package_folder
-        output_list = self.execute_cmd(self.COMMAND_LIST_FILES_RECURSIVELY)
-        return_list = []
-        if output_list is not None:
-            for path in output_list:
-                return_list.append(path)
-        return return_list
-
-    def get_package_files_recursively(self, package_folder, return_list):
-        package_folder = str(package_folder).replace("\\", "/")
-        if package_folder.endswith("/"):
-            package_folder = package_folder[0:-1]
-        self.COMMAND_LIST_FILES[4] = package_folder
-        output_list = self.execute_cmd(self.COMMAND_LIST_FILES)
-        if output_list is not None:
-            for path in output_list:
-                if path.__contains__(".") and not path.__contains__("base.dm"):
-                    return_list.append(package_folder + '/' + path)
-                elif path.endswith("/") and path != "oat/":
-                    return_list = self.get_package_files_recursively(package_folder + '/' + path, return_list)
-        return return_list
-
-    def pull_package(self, source, destination):
-        self.COMMAND_ADB_PULL[2] = source
-        self.COMMAND_ADB_PULL[3] = destination
-        output_list = self.execute_cmd(self.COMMAND_ADB_PULL)
-        return_list = []
-        if output_list is not None:
-            for path in output_list:
-                # Output needs to contain "1 file pulled" in it for successful execution
-                return_list.append(path)
-        return return_list
-
-    def push_package(self, source, destination):
-        self.COMMAND_ADB_PUSH[2] = source
-        self.COMMAND_ADB_PUSH[3] = destination
-        output_list = self.execute_cmd(self.COMMAND_ADB_PUSH)
-        return_list = []
-        if output_list is not None:
-            for path in output_list:
-                return_list.append(path)
-        return return_list
-
-    def file_exists(self, file_path):
-        exists = False
-        self.COMMAND_LIST_FILES[4] = file_path
-        output_list = self.execute_cmd(self.COMMAND_LIST_FILES)
-        if output_list is not None:
-            for path in output_list:
-                if path == file_path:
-                    exists = True
-                    break
-        return exists
-
-    def get_white_list_permissions(self, apk_path):
-        self.COMMAND_AAPT_DUMP_PERMISSIONS[3] = apk_path
-        result = self.execute(self.COMMAND_AAPT_DUMP_PERMISSIONS)
-        return_list = set()
-        if result[2]:
-            keys = ["uses-permission", "permission"]
-            for line in result[1]:
-                if line.startswith(keys[0]):
-                    return_list.add(line.split('\'')[1])
-                elif line.startswith(keys[1]):
-                    return_list.add(line.split(' ')[1])
-        else:
-            return_list.add("Exception: " + str(result[0]))
-        return list(return_list)
-
-    def get_package_name(self, apk_path):
-        self.COMMAND_AAPT_DUMP_PERMISSIONS[3] = apk_path
-        result = self.execute(self.COMMAND_AAPT_DUMP_PERMISSIONS)
-        if result[2]:
-            key = "package:"
-            key_line = next((line for line in result[1] if line.startswith(key)), None)
-            if key_line:
-                value = key_line.split(" ")[1]
-                return value
-        else:
-            return "Exception: Package Name Not Found"
-
-    def get_package_version(self, apk_path):
-        self.COMMAND_AAPT_DUMP_BADGING[3] = apk_path
-        result = self.execute(self.COMMAND_AAPT_DUMP_BADGING)
-        if result[2]:
-            key = "versionName"
-            key_line = next((line for line in result[1] if line.__contains__(key)), None)
-            if key_line:
-                parts = key_line.split()
-                value = next((part.split('=')[1].strip("'") for part in parts if key in part), '')
-                return value
-        else:
-            return "Exception: Package Name Not Found"
-
-    def get_package_details(self, apk_path, key):
-        self.COMMAND_AAPT_DUMP_BADGING[3] = apk_path
-        result = self.execute(self.COMMAND_AAPT_DUMP_BADGING)
-        if result[2]:
-            key_line = next((line for line in result[1] if line.__contains__(key)), None)
-            if key_line:
-                parts = key_line.split()
-                value = next((part for part in parts if key in part), '')
-                return value.split('=')[1].strip("'")
-        else:
-            return f"Exception: {key} Not Found"
-
-    def get_package_version_code(self, apk_path):
-        self.COMMAND_AAPT_DUMP_BADGING[3] = apk_path
-        result = self.execute(self.COMMAND_AAPT_DUMP_BADGING)
-        if result[2]:
-            key = "versionCode="
-            key_line = next((line for line in result[1] if line.__contains__(key)), None)
-            if key_line:
-                parts = key_line.split()
-                value = next((part.split('=')[1].strip("'") for part in parts if key in part), '')
-                return value
-        else:
-            return "Exception: Package Version Code Not Found"
-
-    def sign_zip_file(self, zip_path):
-        zip_path = os.path.abspath(zip_path)
-        self.COMMAND_SIGN_ZIP[3] = zip_path
-        output_list = self.execute_cmd(self.COMMAND_SIGN_ZIP)
-        return_list = []
-        if output_list is not None:
-            for path in output_list:
-                return_list.append(path)
-        return return_list

NikGapps/helper/FileOp.py

@@ -1,235 +0,0 @@
-import hashlib
-import os.path
-import shutil
-import stat
-from pathlib import Path
-
-
-class FileOp:
-    @staticmethod
-    def create_file_dir(file_path):
-        parent_dir = str(Path(file_path).parent)
-        if not os.path.exists(parent_dir):
-            os.makedirs(parent_dir)
-
-    @staticmethod
-    def make_dir(dir_path):
-        if not os.path.exists(dir_path):
-            os.makedirs(dir_path)
-
-    @staticmethod
-    def copy_file(source, destination):
-        FileOp.create_file_dir(destination)
-        shutil.copy2(source, destination)
-
-    @staticmethod
-    def move_file(source, destination):
-        FileOp.create_file_dir(destination)
-        shutil.move(source, destination)
-
-    @staticmethod
-    def dir_exists(dir_path):
-        if os.path.exists(dir_path):
-            return True
-        return False
-
-    @staticmethod
-    def file_exists(file_path):
-        if os.path.exists(file_path):
-            return True
-        return False
-
-    @staticmethod
-    def remove_dir(dir_path):
-        if os.path.exists(dir_path):
-            shutil.rmtree(dir_path, onerror=FileOp.remove_readonly)
-            return True
-        return False
-
-    @staticmethod
-    def remove_readonly(func, path, exc_info):
-        if not os.access(path, os.W_OK):
-            os.chmod(path, stat.S_IWUSR)
-            func(path)
-        else:
-            raise exc_info[1]
-
-    @staticmethod
-    def remove_file(file_path):
-        if FileOp.file_exists(file_path):
-            os.remove(file_path)
-            return True
-        return False
-
-    @staticmethod
-    def convert_unit(size_in_bytes, unit):
-        """ Convert the size from bytes to other units like KB, MB or GB"""
-        if unit == "KB":
-            return size_in_bytes / 1024
-        elif unit == "MB":
-            return size_in_bytes / (1024 * 1024)
-        elif unit == "GB":
-            return size_in_bytes / (1024 * 1024 * 1024)
-        else:
-            return size_in_bytes
-
-    @staticmethod
-    def get_file_size(file_name, size_type="MB"):
-        """ Get file in size in given unit like KB, MB or GB"""
-        try:
-            size = os.path.getsize(file_name)
-        except Exception as e:
-            size = 0
-            print("Exception occurred while calculating file size: " + str(e))
-        return FileOp.convert_unit(size, size_type)
-
-    @staticmethod
-    def get_dir_list(file_path):
-        return_list = []
-        dir_list = ""
-        file_path = str(file_path.replace("___", "/")).replace("\\", "/")
-        for path in str(file_path).split("/"):
-            dir_list = str(dir_list) + "/" + path
-            if not str(dir_list).__eq__("/") \
-                    and not str(dir_list).__contains__(".") \
-                    and not str(dir_list).endswith("/system") \
-                    and not str(dir_list).endswith("/product") \
-                    and not str(dir_list).endswith("/etc") \
-                    and not str(dir_list).endswith("/framework") \
-                    and not str(dir_list).startswith("/usr/srec/en-US/") \
-                    and not str(dir_list).endswith("system_ext_seapp_contexts") \
-                    and not str(dir_list).endswith("/priv-app"):
-                return_list.append(dir_list[1:])
-        return return_list
-
-    @staticmethod
-    def read_priv_app_temp_file(file_path, encoding='cp437'):
-        return_list = []
-        if FileOp.file_exists(file_path):
-            file = open(file_path, encoding=encoding)
-            text = file.readlines()
-            for line in text:
-                if line.startswith("uses-permission:"):
-                    try:
-                        permissions = line.split('\'')
-                        if permissions.__len__() > 1:
-                            return_list.append(permissions[1])
-                    except Exception as e:
-                        return_list = ["Exception: " + str(e)]
-            file.close()
-            FileOp.remove_file(file_path)
-        else:
-            return_list.append("Exception: " + str(1001))
-        return return_list
-
-    @staticmethod
-    def read_package_name(file_path, encoding='cp437'):
-        if FileOp.file_exists(file_path):
-            file = open(file_path, encoding=encoding)
-            text = file.readline()
-            if text.startswith("package:"):
-                index1 = text.find("'")
-                if index1 == -1:
-                    text = text.replace("package:", "").strip()
-                else:
-                    text = text[index1 + 1: -1]
-                    index1 = text.find("'")
-                    text = text[0: index1]
-            file.close()
-            FileOp.remove_file(file_path)
-        else:
-            text = "Exception: " + str(1001)
-        return text
-
-    @staticmethod
-    def read_package_version(file_path, encoding='cp437'):
-        if FileOp.file_exists(file_path):
-            file = open(file_path, encoding=encoding)
-            text = file.readline()
-            if text.__contains__("versionName="):
-                index1 = text.find("versionName='")
-                text = text[index1 + 13: -1]
-                index1 = text.find("'")
-                text = text[0: index1]
-            file.close()
-            FileOp.remove_file(file_path)
-        else:
-            text = "Exception: " + str(1001)
-        return text
-
-    @staticmethod
-    def read_key(file_path, key, encoding='cp437'):
-        if FileOp.file_exists(file_path):
-            file = open(file_path, encoding=encoding)
-            text = file.readline()
-            if text.__contains__(f"{key}="):
-                index1 = text.find(f"{key}='")
-                text = text[index1 + len(key) + 2: -1]
-                index1 = text.find("'")
-                text = text[0: index1]
-            file.close()
-            FileOp.remove_file(file_path)
-        else:
-            text = "Exception: " + str(1001)
-        return text
-
-    @staticmethod
-    def write_string_file(str_data, file_path):
-        FileOp.create_file_dir(file_path)
-        if FileOp.file_exists(file_path):
-            os.remove(file_path)
-        file = open(file_path, "w")
-        file.write(str_data)
-        file.close()
-
-    @staticmethod
-    def convert_to_lf(filename):
-        with open(filename, 'r', newline='\n', encoding='utf-8') as file:
-            content = file.read()
-        content = content.replace('\r\n', '\n')
-        with open(filename, 'w', newline='\n', encoding='utf-8') as file:
-            file.write(content)
-
-    @staticmethod
-    def write_string_in_lf_file(str_data, file_path):
-        FileOp.create_file_dir(file_path)
-        if FileOp.file_exists(file_path):
-            os.remove(file_path)
-        file = open(file_path, "w", newline='\n')
-        file.write(str_data)
-        file.close()
-
-    @staticmethod
-    def read_string_file(file_path):
-        if FileOp.file_exists(file_path):
-            file = open(file_path, "r", encoding='cp437')
-            lines = file.readlines()
-            file.close()
-            return lines
-        else:
-            print("File: " + file_path + " not found!")
-            return ['File Not Found']
-
-    @staticmethod
-    def read_binary_file(file_path):
-        if FileOp.file_exists(file_path):
-            file = open(file_path, "rb")
-            lines = file.readlines()
-            file.close()
-            return lines
-        else:
-            print("File: " + file_path + " not found!")
-            return ['File Not Found']
-
-    @staticmethod
-    def get_md5(file_path):
-        if FileOp.file_exists(file_path):
-            md5_hash = hashlib.md5()
-            a_file = open(file_path, "rb")
-            content = a_file.read()
-            md5_hash.update(content)
-            digest = md5_hash.hexdigest()
-            a_file.close()
-            return digest
-        else:
-            return "File Not Found"

NikGapps/helper/Json.py

@@ -1,34 +0,0 @@
-import json
-import os
-
-
-class Json:
-
-    @staticmethod
-    def print_json_dict(json_dict):
-        print(json.dumps(json_dict, indent=2, sort_keys=True))
-
-    @staticmethod
-    def write_dict_to_file(json_dict, file_name):
-        if not os.path.exists(os.path.dirname(file_name)):
-            os.makedirs(os.path.dirname(file_name))
-        try:
-            with open(file_name, 'w') as file:
-                json_dumps_str = json.dumps(json_dict, indent=4, sort_keys=True)
-                print(json_dumps_str, file=file)
-                return True
-        except Exception as e:
-            print(e)
-            return False
-
-    @staticmethod
-    def read_dict_from_file(file_name):
-        try:
-            if not os.path.exists(file_name):
-                return {}
-            with open(file_name, 'r') as file:
-                json_dict = json.load(file)
-                return json_dict
-        except Exception as e:
-            print(e)
-            return None

NikGapps/helper/P.py

@@ -1,23 +0,0 @@
-from colorama import Fore
-
-
-class P:
-    @staticmethod
-    def yellow(message):
-        print(Fore.YELLOW + str(message) + Fore.RESET)
-
-    @staticmethod
-    def red(message):
-        print(Fore.RED + str(message) + Fore.RESET)
-
-    @staticmethod
-    def green(message):
-        print(Fore.GREEN + str(message) + Fore.RESET)
-
-    @staticmethod
-    def blue(message):
-        print(Fore.BLUE + message + Fore.RESET)
-
-    @staticmethod
-    def magenta(message):
-        print(Fore.MAGENTA + str(message) + Fore.RESET)