NikGapps 3.29__py3-none-any.whl → 3.31__py3-none-any.whl

NikGapps/helper/Statics.py

@@ -1,166 +0,0 @@
-import glob
-import math
-import os
-from pathlib import Path
-from .C import C
-from .T import T
-
-
-class Statics:
-    time = T.get_london_date_time("%y%m%d%H%M")
-    android_versions = {
-        '10': {'sdk': '29', 'code': 'Q'},
-        '11': {'sdk': '30', 'code': 'R'},
-        '12': {'sdk': '31', 'code': 'S'},
-        '12.1': {'sdk': '32', 'code': 'SL'},
-        '13': {'sdk': '33', 'code': 'T'},
-        '14': {'sdk': '34', 'code': 'U'},
-        '15': {'sdk': '35', 'code': 'V'},
-    }
-    is_system_app = 1
-    is_priv_app = 2
-    system_root_dir = "/system/product"
-    cwd = C.find_cwd()
-    pwd = str(Path(cwd).parent)
-    dir_sep = os.path.sep
-    DELETE_FILES_NAME = "DeleteFilesData"
-    meta_inf_dir = "META-INF/com/google/android/"
-    nikgapps_config = "nikgapps.config"
-    release_tracker_url = "https://raw.githubusercontent.com/nikgapps/tracker/main/release_tracker.json"
-    folder_access_url = "https://raw.githubusercontent.com/nikgapps/tracker/main/folder_access.json"
-    admin_access_url = "https://raw.githubusercontent.com/nikgapps/tracker/main/admin_access.txt"
-    admin_access = None
-    folder_access = None
-    in_progress = "○"
-    completed = "●"
-    package_details = {}
-    # "■ ▤ □ ▥ ▧ ▨ ▩ ▦ ▣ ◈ ◇ ◆ ◉ ◊ ○ ◌ ◍ ◎ ● ◐ ◑ ◒ ◓ ◔ ◕ ◖ ◗ ◘ ◙ ◚ ◛"
-
-    @staticmethod
-    def display_progress(percentage):
-        percentage = max(1, min(100, percentage))
-        completed_steps = int(percentage / 10)
-        in_progress_steps = 10 - completed_steps
-        progress_str = Statics.completed * completed_steps + Statics.in_progress * in_progress_steps
-        elegant_progress_str = ' '.join(progress_str)
-        return f"( {elegant_progress_str} )" if percentage != 100 else ""
-
-    @staticmethod
-    def get_import_path(app_set, pkg, install_path, target_version, export_directory=None):
-        base_name = os.path.basename(install_path)
-        dir_name = Statics.get_parent_path(install_path)
-        dir_name = str(dir_name).replace("\\system_ext", "").replace("/system_ext", "") \
-            .replace("\\system", "").replace("/system", "") \
-            .replace("\\product", "").replace("/product", "")
-        if export_directory is not None:
-            output = export_directory + os.path.sep
-        else:
-            output = Statics.pwd + os.path.sep + "Export" + os.path.sep + str(
-                target_version) + os.path.sep + T.get_london_date_time("%Y%m%d") + os.path.sep
-        if app_set is not None:
-            output += app_set + os.path.sep
-        output += str(pkg) + os.path.sep + str(dir_name).replace("\\", "___").replace(
-            os.path.sep, "___") + os.path.sep + base_name
-        if not os.path.exists(Path(output).parent):
-            os.makedirs(Path(output).parent)
-        return Path(output)
-
-    @staticmethod
-    def get_parent_path(file_path):
-        return Path(file_path).parent
-
-    @staticmethod
-    def find_latest_aapt():
-        # Try to get the Android SDK path from environment variables
-        sdk_path = os.environ.get("ANDROID_HOME") or os.environ.get("ANDROID_SDK_ROOT")
-        if not sdk_path:
-            raise EnvironmentError("Android SDK path not found. "
-                                   "Set ANDROID_HOME or ANDROID_SDK_ROOT environment variable.")
-        # Build the search pattern
-        search_pattern = os.path.join(sdk_path, "build-tools", "*", "aapt")
-        # Find all matching paths
-        aapt_paths = glob.glob(search_pattern)
-        # Sort the paths to find the latest
-        if aapt_paths:
-            latest_aapt_path = max(aapt_paths, key=os.path.getmtime)
-            return str(latest_aapt_path)
-        else:
-            return None
-
-    @staticmethod
-    def get_download_link(file_name, sf_path):
-        sf_prefix = "https://sourceforge.net/projects/nikgapps/files/"
-        download_link = sf_prefix + sf_path[len("/home/frs/project/nikgapps/"):] + "/" + os.path.basename(
-            file_name) + "/download"
-        return download_link
-
-    @staticmethod
-    def get_file_bytes(file_name):
-        file_stats = os.stat(file_name)
-        # 1000 instead of 1024 because it's better to require more size than what gapps exactly takes
-        return math.ceil(file_stats.st_size / 1000)
-
-    @staticmethod
-    def get_temp_packages_directory(android_version, arch="arm64"):
-        return Statics.pwd + os.path.sep + "TempPackages" + os.path.sep + str(android_version) + os.path.sep + arch
-
-    @staticmethod
-    def get_overlay_source_directory(android_version):
-        return Statics.pwd + os.path.sep + f"overlays_{android_version}_source"
-
-    @staticmethod
-    def get_overlay_source_repo(android_version):
-        return f"git@gitlab.com:nikgapps/overlays_{android_version}_source.git"
-
-    @staticmethod
-    def get_overlay_directory(android_version):
-        return Statics.pwd + os.path.sep + f"overlays_{android_version}"
-
-    @staticmethod
-    def get_overlay_repo(android_version):
-        return f"git@gitlab.com:nikgapps/overlays_{android_version}.git"
-
-    @staticmethod
-    def get_temp_overlay_directory(android_version):
-        return Statics.get_temp_packages_directory(android_version) + os.path.sep + "Overlays"
-
-    @staticmethod
-    def get_release_directory(android_version):
-        return Statics.pwd + os.path.sep + "Releases" + os.path.sep + str(android_version)
-
-    @staticmethod
-    def get_android_code(android_version):
-        return Statics.android_versions[str(android_version)]['code']
-
-    @staticmethod
-    def get_android_sdk(android_version):
-        return Statics.android_versions[str(android_version)]['sdk']
-
-    @staticmethod
-    def get_package_details(android_version):
-        return f"{android_version}{Statics.dir_sep}package_details.json"
-
-    @staticmethod
-    def get_sourceforge_release_directory(release_dir):
-        sourceforge_root_directory = "/home/frs/project/nikgapps"
-        match release_dir:
-            case ("config"):
-                return f"{sourceforge_root_directory}/Config-Releases"
-            case ("canary"):
-                return f"{sourceforge_root_directory}/Swift-Releases"
-            case ("swift"):
-                return f"{sourceforge_root_directory}/Swift-Releases"
-            case ("stable"):
-                return f"{sourceforge_root_directory}/Releases"
-            case ("beta"):
-                return f"{sourceforge_root_directory}/Next-Releases"
-            case ("next"):
-                return f"{sourceforge_root_directory}/Next-Releases"
-            case _:
-                return f"{sourceforge_root_directory}/{release_dir}"
-
-    @staticmethod
-    def get_partition(android_version, partition):
-        if float(android_version) <= 10:
-            return "product"
-        return partition

NikGapps/helper/SystemStat.py

@@ -1,103 +0,0 @@
-import os
-import platform
-import shutil
-import subprocess
-from multiprocessing import cpu_count
-
-import psutil
-
-from . import Config
-from .Assets import Assets
-from .P import P
-from .T import T
-
-
-class SystemStat:
-
-    @staticmethod
-    def run_command(command):
-        result = None
-        try:
-            result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-            # Check both stdout and stderr for output, as some commands might output version info to stderr
-            output = result.stdout.strip() if result.stdout.strip() else result.stderr.strip()
-            return output
-        except subprocess.CalledProcessError as e:
-            # If the command fails (e.g., command not found), return the error message from stderr or a custom message
-            error_message = result.stderr.strip() if result.stderr.strip() else "Command failed without error output"
-            return f"Failed to execute {command}: {e} - {error_message}"
-        except Exception as e:
-            return f"Failed to execute {command}: {e}"
-
-    @staticmethod
-    def display_time(location, time_str):
-        if "AM" in time_str:
-            P.yellow(f"{location}: {time_str}")
-        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
-        mem = psutil.virtual_memory()
-        total_ram_in_bytes = mem.total
-        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()}({cpu_count()})")
-        P.green("---------------------------------------")
-        SystemStat.print_disk_usage()
-        # Versions of Java, ADB, and AAPT
-        # java_version = SystemStat.run_command(["java", "-version"])
-        # P.green(f"Java version: {java_version}")
-        # P.green("---------------------------------------")
-        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")
-        ny_time = t.get_new_york_date_time("%a, %m/%d/%Y, %I:%M:%S %p")
-        london_time = t.get_london_date_time().strftime("%a, %m/%d/%Y, %I:%M:%S %p")
-
-        SystemStat.display_time("Local", local_time)
-        SystemStat.display_time("NY", ny_time)
-        SystemStat.display_time("London", london_time)
-        P.green("---------------------------------------")
-        print(" ")

NikGapps/helper/T.py

@@ -1,82 +0,0 @@
-import math
-import os
-import time
-from datetime import datetime
-
-import pytz
-
-from .P import P
-
-
-class T:
-
-    def __init__(self):
-        self.t = time.time()
-
-    def taken(self, message=None):
-        start_time = self.t
-        P.yellow("---------------------------------------")
-        if message is not None:
-            P.yellow("--- " + message + " ---")
-        sec = round(time.time() - start_time, 0)
-        seconds = int(math.fmod(sec, 60))
-        minutes = int(sec // 60)
-        time_diff = (time.time() - start_time)
-        P.yellow(f"--- {time_diff} seconds --- ")
-        P.yellow(f"--- %s minutes %s seconds --- " % (minutes, seconds))
-        P.yellow("---------------------------------------")
-        return time_diff
-
-    @staticmethod
-    def get_london_date_time(date_format=None):
-        dt_london = datetime.now(pytz.timezone('Europe/London'))
-        return dt_london if date_format is None else dt_london.strftime(date_format)
-
-    @staticmethod
-    def get_new_york_date_time(date_format=None):
-        tz_ny = pytz.timezone('America/New_York')
-        datetime_ny = datetime.now(tz_ny)
-        return datetime_ny if date_format is None else datetime_ny.strftime(date_format)
-
-    @staticmethod
-    def get_local_date_time(date_format=None):
-        local = datetime.now()
-        return local if date_format is None else local.strftime(date_format)
-
-    @staticmethod
-    def get_file_name(nikgappstype, android_version, arch="arm64"):
-        current_time = T.get_current_time()
-        return "NikGapps-" + nikgappstype + f"-{arch}-" + str(android_version) + "-" + current_time + ".zip"
-
-    @staticmethod
-    def get_current_time():
-        tz_london = pytz.timezone('Europe/London')
-        datetime_london = datetime.now(tz_london)
-        return datetime_london.strftime("%Y%m%d")
-
-    @staticmethod
-    def get_path(user_name, android_version):
-        tz_london = pytz.timezone('Europe/London')
-        datetime_london = datetime.now(tz_london)
-        return user_name + "/" + "Android-" + str(android_version) + "/" + str(datetime_london.strftime("%d-%b-%Y"))
-
-    @staticmethod
-    def get_mtime(pkg_zip_path):
-        return datetime.fromtimestamp(os.path.getmtime(pkg_zip_path))
-
-    @staticmethod
-    def format_time(seconds):
-        seconds = int(seconds)
-        minutes, seconds = divmod(seconds, 60)
-        hours, minutes = divmod(minutes, 60)
-        days, hours = divmod(hours, 24)
-        parts = []
-        if days > 0:
-            parts.append(f"{days} {'day' if days == 1 else 'days'}")
-        if hours > 0:
-            parts.append(f"{hours} {'hour' if hours == 1 else 'hours'}")
-        if minutes > 0:
-            parts.append(f"{minutes} {'minute' if minutes == 1 else 'minutes'}")
-        if seconds > 0 or not parts:
-            parts.append(f"{seconds} {'second' if seconds == 1 else 'seconds'}")
-        return ', '.join(parts)

NikGapps/helper/XmlOp.py

@@ -1,40 +0,0 @@
-from xml.etree.ElementTree import Element, SubElement, ElementTree, tostring
-import xml.dom.minidom
-
-
-class XmlOp:
-    def __init__(self, package_name, permissions_list, import_path=None):
-        self.root = Element("permissions")
-        self.doc = SubElement(self.root, "privapp-permissions", package=package_name)
-        for permission in permissions_list:
-            SubElement(self.doc, "permission", name=permission)
-        XmlOp.indent(self.root)
-        if import_path is not None:
-            with open(import_path, 'wb') as f:
-                self.tree = ElementTree(self.root)
-                self.tree.write(f)
-
-    @staticmethod
-    def indent(elem, level=0):
-        i = "\n" + level * "  "
-        if len(elem):
-            if not elem.text or not elem.text.strip():
-                elem.text = i + "  "
-            if not elem.tail or not elem.tail.strip():
-                elem.tail = i
-            for elem in elem:
-                XmlOp.indent(elem, level + 1)
-            if not elem.tail or not elem.tail.strip():
-                elem.tail = i
-        else:
-            if level and (not elem.tail or not elem.tail.strip()):
-                elem.tail = i
-
-    def to_string(self):
-        xml_str = tostring(self.root, 'utf-8')
-        parsed_str = xml.dom.minidom.parseString(xml_str)
-        pretty_str = parsed_str.toprettyxml(encoding="utf-8").decode("utf-8")
-        pretty_str = "\n".join(
-            line for line in pretty_str.splitlines() if line.strip() and not line.__contains__("utf-8"))
-        pretty_str = pretty_str.replace("\r\n", "\n")  # Ensure LF line endings
-        return pretty_str

NikGapps/helper/compression/Modes.py

@@ -1,4 +0,0 @@
-class Modes:
-    TAR_XZ = ".tar.xz"
-    ZIP = ".zip"
-    DEFAULT = ZIP

NikGapps/helper/compression/Tar.py

@@ -1,25 +0,0 @@
-import tarfile
-from io import BytesIO
-from ..FileOp import FileOp
-
-
-class Tar:
-
-    def __init__(self, file_name, folder_to_compress=None):
-        if folder_to_compress is None:
-            self.folder = folder_to_compress
-        self.tarfile = str(file_name) if str(file_name).endswith("tar.xz") else str(file_name) + ".tar.xz"
-        FileOp.create_file_dir(self.tarfile)
-        self.tar = tarfile.open(self.tarfile, "w:xz")
-
-    def add_file(self, file_to_add, zippath):
-        self.tar.add(file_to_add, arcname=zippath)
-
-    def add_string(self, text, file_name):
-        data = text.encode('utf-8')
-        info = tarfile.TarInfo(name=file_name)
-        info.size = len(data)
-        self.tar.addfile(tarinfo=info, fileobj=BytesIO(data))
-
-    def close(self):
-        self.tar.close()

NikGapps/helper/compression/Zip.py

@@ -1,97 +0,0 @@
-import os
-import zipfile
-from cryptography.hazmat.primitives import hashes
-from cryptography.hazmat.primitives.asymmetric import padding
-from cryptography.hazmat.primitives.serialization import load_pem_private_key
-from cryptography.hazmat.backends import default_backend
-from base64 import b64encode
-import hashlib
-
-
-class Zip:
-    RSAFileName = "META-INF/Nik.RSA"
-    SFFileName = "META-INF/Nik.SF"
-    ManifestFileName = "META-INF/MANIFEST.MF"
-    DigitalMessage = "Author:- Nikhil Menghani (Nikhil @ Xda-developers.com)"
-    SignatureVersion = "1.0"
-    ManifestVersion = "1.0"
-    CreatedBy = "Nikhil @ XDA"
-
-    def __init__(self, name, sign=False, private_key_path=None, comment=DigitalMessage):
-        directory = os.path.dirname(name)
-        if not os.path.exists(directory):
-            os.makedirs(directory, exist_ok=True)
-
-        self.zipObj = zipfile.ZipFile(name, 'w', compression=zipfile.ZIP_DEFLATED)
-        self.comment = comment.encode()
-        self.sign = sign
-        if self.sign:
-            if private_key_path is None:
-                raise ValueError("Private key path must be provided for signing.")
-            self.private_key = self.load_private_key(private_key_path)
-            self.signatures = {}
-            self.manifest_digests = {}
-
-    def load_private_key(self, file_path):
-        with open(file_path, 'rb') as key_file:
-            return load_pem_private_key(
-                key_file.read(),
-                password=None,
-                backend=default_backend()
-            )
-
-    def add_file(self, filename, zippath=None):
-        if zippath is None:
-            zippath = filename
-        self.zipObj.write(filename, zippath)
-        if self.sign:
-            self.sign_content(filename, zippath)
-
-    def add_string(self, text, zippath):
-        text = text.replace('\r\n', '\n')
-        self.zipObj.writestr(zippath, text)
-        if self.sign:
-            self.sign_content_string(text, zippath)
-
-    def sign_content(self, filename, zippath):
-        with open(filename, 'rb') as f:
-            content = f.read()
-        self.process_signature(content, zippath)
-
-    def sign_content_string(self, text, zippath):
-        content = text.encode()
-        self.process_signature(content, zippath)
-
-    def process_signature(self, content, zippath):
-        digest = hashlib.sha256(content).digest()
-        self.manifest_digests[zippath] = b64encode(digest).decode('utf-8')
-        signature = self.private_key.sign(
-            digest,
-            padding.PSS(
-                mgf=padding.MGF1(hashes.SHA256()),
-                salt_length=padding.PSS.MAX_LENGTH
-            ),
-            hashes.SHA256()
-        )
-        self.signatures[zippath] = b64encode(signature).decode('utf-8')
-        # self.zipObj.writestr(zippath + '.sig', signature)
-
-    def generate_manifest_and_signature_files(self):
-        manifest_content = f"Manifest-Version: {self.ManifestVersion}\nCreated-By: {self.CreatedBy}\n"
-        for filename, digest in self.manifest_digests.items():
-            manifest_content += f"Name: {filename}\nSHA-256-Digest: {digest}\n"
-        self.zipObj.writestr(self.ManifestFileName, manifest_content)
-
-        sf_content = f"Signature-Version: {self.SignatureVersion}\nCreated-By: {self.CreatedBy}\n"
-        self.zipObj.writestr(self.SFFileName, sf_content)
-
-        rsa_content = f"Digital-Message: {self.DigitalMessage}\nSignatures:\n"
-        for filename, signature in self.signatures.items():
-            rsa_content += f"{filename}: {signature}\n"
-        self.zipObj.writestr(self.RSAFileName, rsa_content)
-
-    def close(self):
-        if self.sign:
-            self.generate_manifest_and_signature_files()
-            self.zipObj.comment = self.comment
-        self.zipObj.close()

NikGapps/helper/compression/Zsh.py

@@ -1,17 +0,0 @@
-from pathlib import Path
-from subprocess import call
-
-from ..T import T
-
-
-class Zsh:
-
-    def __init__(self, folder_to_compress, file_name):
-        self.folder = folder_to_compress
-        self.tarfile = str(file_name) + ".tar.xz"
-
-    def compress(self):
-        time_obj = T()
-        call(["tar", "cJfP", self.tarfile, self.folder])
-        print(f"zsh tar filesize: {round(Path(self.tarfile).stat().st_size / (1024 * 1024), 2)} MB")
-        time_obj.taken("zsh tar filesize")