NikGapps 3.29__py3-none-any.whl → 3.30__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/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/git/Git.py

@@ -1,228 +0,0 @@
-import re
-
-import git.exc
-from git import Repo, Commit
-from shutil import copyfile
-from .. import Config
-from ..FileOp import FileOp
-from ..Assets import Assets
-import os
-import time
-import datetime
-from datetime import datetime
-import pytz
-from .GitStatics import GitStatics
-from ..P import P
-from ..T import T
-
-
-class Git:
-
-    def __init__(self, working_tree_dir):
-        os.environ["GIT_CLONE_PROTECTION_ACTIVE"] = 'false'
-        self.enable_push = Config.GIT_PUSH
-        self.working_tree_dir = working_tree_dir
-        self.repo_name = None
-        if FileOp.dir_exists(self.working_tree_dir):
-            self.repo = Repo(working_tree_dir)
-
-    def clone_repo(self, repo_url, branch="main", fresh_clone=True, commit_depth=1):
-        try:
-            t = T()
-            if fresh_clone:
-                # for fresh clone, we must clean the directory and clone again
-                if FileOp.dir_exists(self.working_tree_dir):
-                    print(f"{self.working_tree_dir} already exists, deleting for a fresh clone!")
-                    FileOp.remove_dir(self.working_tree_dir)
-                if commit_depth == 0:
-                    P.green(f"git clone -b {branch} {repo_url}")
-                    self.repo = git.Repo.clone_from(repo_url, self.working_tree_dir, branch=branch)
-                else:
-                    P.green(f"git clone -b {branch} --depth={commit_depth} {repo_url}")
-                    self.repo = git.Repo.clone_from(repo_url, self.working_tree_dir, branch=branch, depth=commit_depth)
-
-            else:
-                # if it is not a fresh clone, we only clone when directory doesn't exist
-                if not FileOp.dir_exists(self.working_tree_dir):
-                    print(f"{self.working_tree_dir} doesn't exists, fresh clone is enforced!")
-                    P.yellow(f"git clone -b {branch} --depth={commit_depth} {repo_url}")
-                    self.repo = git.Repo.clone_from(repo_url, self.working_tree_dir, branch=branch, depth=commit_depth)
-            t.taken(f"Time taken to clone -b {branch} {repo_url}")
-            self.update_repo_name(repo_url)
-            assert self.repo.__class__ is Repo  # clone an existing repository
-            assert Repo.init(self.working_tree_dir).__class__ is Repo
-            return True
-        except Exception as e:
-            print("Exception caught while cloning the repo: " + str(e))
-        return False
-
-    # this will return commits 21-30 from the commit list as traversed backwards master
-    # ten_commits_past_twenty = list(repo.iter_commits('master', max_count=10, skip=20))
-    # assert len(ten_commits_past_twenty) == 10
-    # assert fifty_first_commits[20:30] == ten_commits_past_twenty
-    # repo = git.Repo.clone_from(repo_url, working_tree_dir, branch='master')
-    def get_latest_commit_date(self, branch=None, filter_key=None):
-        tz_london = pytz.timezone('Europe/London')
-        try:
-            if branch is not None:
-                commits = list(self.repo.iter_commits(branch, max_count=50))
-            else:
-                commits = list(self.repo.iter_commits('master', max_count=50))
-        except git.exc.GitCommandError:
-            if branch == "master":
-                branch = "main"
-            commits = list(self.repo.iter_commits(branch, max_count=50))
-
-        for commit in commits:
-            commit: Commit
-            # if filter_key = 10, it will look for commits that starts with 10
-            # failing will continue looking for latest available commit that starts with 10
-            if filter_key is not None and not str(commit.message).startswith(filter_key + ":"):
-                continue
-            time_in_string = str(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(commit.committed_date)))
-            time_in_object = datetime.strptime(time_in_string, '%Y-%m-%d %H:%M:%S')
-            london_time_in_object = time_in_object.astimezone(tz_london)
-            london_time_in_string = london_time_in_object.strftime('%Y-%m-%d %H:%M:%S')
-            commit_datetime = datetime.strptime(london_time_in_string, '%Y-%m-%d %H:%M:%S')
-            return commit_datetime
-        return None
-
-    def update_repo_name(self, git_url):
-        git_pattern = re.compile(r'git@[^:]+:[^/]+/(.+)\.git')
-        https_pattern = re.compile(r'https?://[^/]+/[^/]+/(.+)\.git')
-        match = git_pattern.match(git_url) or https_pattern.match(git_url)
-        if match:
-            self.repo_name = match.group(1)
-        else:
-            raise ValueError("Invalid Git URL")
-
-    def get_file_commit_date(self, file_path, str_format="%y%m%d%H%M", skip_containing=None):
-        commits_touching_path = list(self.repo.iter_commits(paths=file_path))
-        if commits_touching_path:
-            for commit in commits_touching_path:
-                if skip_containing is not None and str(skip_containing).lower() in commit.message.lower():
-                    P.blue(f"Skipping commit ({commit.hexsha[:7]}): "
-                           f"{commit.message} as it contains '{skip_containing}'")
-                    continue
-                P.green(f"Commit ({commit.hexsha[:7]}): {commit.message} found for {file_path}")
-                return commit.committed_datetime.strftime(str_format)
-        else:
-            return None
-
-    def get_changed_files(self):
-        files_list = []
-        files = self.repo.git.diff(None, name_only=True)
-        if files != "":
-            for f in files.split('\n'):
-                files_list.append(f)
-        if self.repo.untracked_files.__len__() > 0:
-            for f in self.repo.untracked_files:
-                files_list.append(f)
-        return files_list
-
-    def due_changes(self):
-        files = self.repo.git.diff(None, name_only=True)
-        if files != "":
-            if files.split('\n').__len__() > 0:
-                return True
-        if self.repo.untracked_files.__len__() > 0:
-            return True
-        return False
-
-    def git_push(self, commit_message, push_untracked_files=False, debug=False, rebase=False, pull_first=False,
-                 post_buffer=None):
-        if not self.enable_push:
-            print("Git push is disabled, skipping push!")
-            return False
-        try:
-            origin = self.repo.remote(name='origin')
-            if post_buffer is not None:
-                self.repo.git.config('http.postBuffer', post_buffer)
-            if self.repo.is_dirty(untracked_files=True):
-                self.repo.git.add(u=True)
-                if push_untracked_files:
-                    self.repo.git.add(A=True)
-                if commit_message is None:
-                    commit_message = "Auto Commit"
-                self.repo.index.commit(commit_message)
-            if pull_first:
-                origin.fetch(self.repo.active_branch.name)
-                origin.pull(self.repo.active_branch.name)
-            if rebase:
-                origin.fetch(self.repo.active_branch.name)
-                try:
-                    self.repo.git.pull('--rebase')
-                except git.GitCommandError as e:
-                    print(f"Error during rebase: {e}")
-                    return False
-            if debug:
-                remotes = self.repo.remotes
-                for remote in remotes:
-                    print(f"Remote name: {remote.name}")
-                    for url in remote.urls:
-                        print(f"URL: {url}")
-                P.blue(self.repo.git.status())
-            push_info = origin.push(self.repo.active_branch.name)
-            for info in push_info:
-                if info.flags & (git.PushInfo.REMOTE_REJECTED | git.PushInfo.ERROR):
-                    print(f"Push failed for ref {info.local_ref}: {info.summary}")
-                    if info.summary.__contains__("remote rejected") and info.summary.__contains__(
-                            "is at") and info.summary.__contains__("but expected"):
-                        print("Remote rejected, trying to pull!")
-                        origin.fetch(self.repo.active_branch.name)
-                        origin.pull(self.repo.active_branch.name)
-                        # rebase if this fails.
-                        push_info = origin.push(self.repo.active_branch.name)
-                        for nested_info in push_info:
-                            if nested_info.flags & (git.PushInfo.REMOTE_REJECTED | git.PushInfo.ERROR):
-                                print(f"Push failed for ref {nested_info.local_ref}: {nested_info.summary}")
-                                return False
-                    return False
-
-            print("Pushed to origin:", commit_message)
-            return True
-
-        except git.exc.GitCommandError as e:
-            if "failed to push some refs" in e.stderr:  # Check for the specific error
-                self.repo.git.pull("origin", "main")  # Pull changes from remote
-                self.repo.git.push()  # Retry the push
-            else:
-                print(f"Git error: {e}")
-                raise e
-
-        except Exception as e:
-            print(f"Unexpected error: {e}")
-        return False
-
-    def update_changelog(self):
-        source_file = Assets.changelog
-        dest_file = GitStatics.website_repo_dir + os.path.sep + "_data" + os.path.sep + "changelogs.yaml"
-        copyfile(source_file, dest_file)
-        if self.due_changes():
-            print("Updating the changelog to the website")
-            self.git_push("Update Changelog")
-        else:
-            print("There is no changelog to update!")
-
-    def update_config_changes(self, message):
-        if self.due_changes():
-            print(message)
-            self.git_push(message, push_untracked_files=True)
-        else:
-            print("There is nothing to update!")
-
-    def update_repo_changes(self, message):
-        if self.due_changes():
-            P.green(message)
-            self.git_push(message, push_untracked_files=True)
-        else:
-            P.red("There is nothing to update!")
-
-    def get_status(self, path):
-        changed = [item.a_path for item in self.repo.index.diff(None)]
-        if path in self.repo.untracked_files:
-            return 'untracked'
-        elif path in changed:
-            return 'modified'
-        else:
-            return 'don''t care'

NikGapps/helper/git/GitOperations.py

@@ -1,118 +0,0 @@
-import json
-from ..FileOp import FileOp
-from .Git import Git
-from .GitStatics import GitStatics
-from ..Statics import Statics
-
-
-class GitOperations:
-
-    @staticmethod
-    def setup_tracker_repo(fresh_clone=True):
-        return GitOperations.setup_repo(GitStatics.tracker_repo_dir, GitStatics.tracker_repo_url, "main", fresh_clone)
-
-    @staticmethod
-    def setup_repo(repo_dir, repo_url, branch="main", fresh_clone=True, commit_depth=50):
-        print()
-        print("Repo Dir: " + repo_dir)
-        repo = Git(repo_dir)
-        result = repo.clone_repo(repo_url, branch=branch, fresh_clone=fresh_clone, commit_depth=commit_depth)
-        return repo if result else None
-
-    @staticmethod
-    def clone_overlay_repo(android_version, fresh_clone=False, branch="main", source=False, enable_push=False):
-        if float(android_version) > 12:
-            overlay_source_dir = (Statics.pwd + Statics.dir_sep + f"overlays_{android_version}"
-                                  + ("_source" if source else ""))
-            overlay_source_repo = (("git@gitlab.com:nikgapps/" if enable_push else "https://gitlab.com/nikgapps/")
-                                   + f"overlays_{android_version}"
-                                   + ("_source" if source else "") + ".git")
-            return GitOperations.setup_repo(overlay_source_dir, overlay_source_repo, branch, fresh_clone)
-        else:
-            print(f"Cloning Overlay repo not needed for android {android_version}")
-            return None
-
-    @staticmethod
-    def clone_apk_repo(android_version, arch="arm64", fresh_clone=False, branch="main",
-                       cached=False, use_ssh_clone=False):
-        arch = "" if arch == "arm64" else "_" + arch
-        cache = "_cached" if cached else ""
-        apk_source_directory = Statics.pwd + Statics.dir_sep + str(android_version) + arch + cache
-        apk_source_repo = (GitStatics.apk_source_repo_ssh if use_ssh_clone else GitStatics.apk_source_repo) + str(
-            android_version) + arch + cache + ".git"
-        return GitOperations.setup_repo(apk_source_directory, apk_source_repo, branch, fresh_clone, commit_depth=1)
-
-    # Following method is new method of cloning the apk source from Gitlab - based on release type
-    @staticmethod
-    def clone_apk_source(android_version, arch="arm64", release_type="stable", fresh_clone=False, cached=False,
-                         use_ssh_clone=False):
-        url = f"{android_version}{('_' + arch if arch != 'arm64' else '')}_{release_type}"
-        url = url + ("_cached" if cached else "")
-        return GitOperations.clone_apk_url(url, fresh_clone, use_ssh_clone)
-
-    @staticmethod
-    def clone_apk_url(url, fresh_clone=False, use_ssh_clone=False):
-        apk_source_directory = Statics.pwd + Statics.dir_sep + url
-        apk_source_repo = ((GitStatics.apk_source_repo_ssh if use_ssh_clone else GitStatics.apk_source_repo) + url
-                           + ".git")
-        return GitOperations.setup_repo(apk_source_directory, apk_source_repo, branch="main", fresh_clone=fresh_clone,
-                                        commit_depth=1)
-
-    @staticmethod
-    def get_last_commit_date(branch, repo_dir=Statics.cwd, repo_url=None, android_version=None, use_ssh_clone=False):
-        last_commit_datetime = None
-        if android_version is not None:
-            repository = GitOperations.clone_apk_repo(android_version, branch=branch, use_ssh_clone=use_ssh_clone)
-        else:
-            repository = Git(repo_dir)
-            if repo_url is not None:
-                repository.clone_repo(repo_url=repo_url, fresh_clone=False, branch=branch)
-        if repository is not None:
-            last_commit_datetime = repository.get_latest_commit_date(branch=branch)
-        return last_commit_datetime
-
-    @staticmethod
-    def get_release_repo(release_type):
-        release_repo = Git(GitStatics.release_history_dir)
-        if not FileOp.dir_exists(GitStatics.release_history_dir):
-            if release_type == "canary":
-                GitStatics.release_repo_url = "git@github.com:nikgapps/canary-release.git"
-            release_repo.clone_repo(GitStatics.release_repo_url, branch="master", commit_depth=50)
-            if not FileOp.dir_exists(GitStatics.release_history_dir):
-                print(GitStatics.release_history_dir + " doesn't exist!")
-        return release_repo
-
-    @staticmethod
-    def get_website_repo_for_changelog(repo_dir=GitStatics.website_repo_dir, repo_url=GitStatics.website_repo_url,
-                                       branch="main"):
-        repo = Git(repo_dir)
-        if repo_url is not None:
-            repo.clone_repo(repo_url=repo_url, fresh_clone=False, branch=branch)
-        if not FileOp.dir_exists(GitStatics.website_repo_dir):
-            print(f"Repo {repo_dir} doesn't exist!")
-        return repo
-
-    @staticmethod
-    def mark_a_release(android_version, release_type):
-        tracker_repo = GitOperations.setup_tracker_repo(False)
-        if tracker_repo is not None:
-            release_tracker = tracker_repo.working_tree_dir + Statics.dir_sep + "release_tracker.json"
-            decoded_hand = {}
-            if FileOp.file_exists(release_tracker):
-                with open(release_tracker, "r") as file:
-                    decoded_hand = json.load(file)
-                if release_type not in decoded_hand:
-                    decoded_hand[release_type] = {}
-                decoded_hand[release_type][android_version] = Statics.time
-            else:
-                decoded_hand[release_type] = {}
-                decoded_hand[release_type][android_version] = Statics.time
-            print(f"Marking a release with {decoded_hand}")
-            with open(release_tracker, "w") as file:
-                json.dump(decoded_hand, file, indent=2, sort_keys=True)
-            if tracker_repo.due_changes():
-                tracker_repo.git_push(
-                    f"Updated release_tracker.json with latest {release_type} release date: " + Statics.time,
-                    pull_first=True)
-            else:
-                print("No changes to commit!")

NikGapps/helper/git/GitStatics.py

@@ -1,14 +0,0 @@
-from ..Statics import Statics
-
-
-class GitStatics:
-    tracker_repo_url = "git@github.com:nikgapps/tracker.git"
-    tracker_repo_dir = Statics.pwd + Statics.dir_sep + "tracker"
-    apk_source_repo_ssh = f"git@gitlab.com:nikgapps/"
-    apk_source_repo = f"https://gitlab.com/nikgapps/"
-    release_repo_url = "git@github.com:nikgapps/release.git"
-    release_history_dir = Statics.pwd + Statics.dir_sep + "release"
-    website_repo_url = "git@github.com:nikgapps/nikgapps.github.io.git"
-    website_repo_dir = Statics.pwd + Statics.dir_sep + "nikgapps.github.io"
-    config_repo_dir = Statics.pwd + Statics.dir_sep + "config"
-    config_repo_url = "git@github.com:nikgapps/config.git"

NikGapps/helper/git/GithubManager.py

@@ -1,21 +0,0 @@
-from github import Github
-
-
-class GithubManager:
-
-    def __init__(self, token):
-        self.g = Github(token)
-        self.user = self.g.get_user()
-
-    def get_user(self):
-        return self.g.get_user()
-
-    def get_repos(self):
-        return self.user.get_repos()
-
-    def create_repo(self, repo_name):
-        return self.user.create_repo(repo_name)
-
-    @staticmethod
-    def create_issue(repo, issue_title, issue_body):
-        return repo.create_issue(title=issue_title, body=issue_body)