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

NikGapps/helper/git/GitlabManager.py

@@ -1,265 +0,0 @@
-import math
-import shutil
-import time
-from pathlib import Path
-
-import gitlab
-
-from NikGapps.helper.FileOp import FileOp
-from NikGapps.helper.P import P
-from NikGapps.helper.Statics import Statics
-from NikGapps.helper.git.GitOperations import GitOperations
-
-
-class GitLabManager:
-    def __init__(self, gitlab_url='https://gitlab.com', private_token=None):
-        self.token = private_token
-        self.gl = gitlab.Gitlab(gitlab_url, private_token=private_token)
-        self.gl.auth()
-
-    def fetch_user_details(self, user_id):
-        """Fetches user details for a specified user ID."""
-        user = self.gl.users.get(user_id)
-        return user
-
-    def create_repository(self, project_name, provide_owner_access=False, user_id=8064473, visibility='public'):
-        """Creates a new repository with the given project name."""
-        project = self.gl.projects.create({'name': project_name, 'visibility': visibility})
-        if provide_owner_access:
-            self.provide_owner_access(project_id=project.id, user_id=user_id)
-            self.create_and_commit_readme(project_id=project.id)
-        return project
-
-    def create_lfs_repository(self, project_name, provide_owner_access=False, user_id=8064473, visibility='public',
-                              extn_list=None):
-        """Creates a new repository with the given project name and attributes."""
-        if extn_list is None:
-            extn_list = []
-        project = self.gl.projects.create({'name': project_name, 'visibility': visibility})
-        if provide_owner_access:
-            self.provide_owner_access(project_id=project.id, user_id=user_id)
-            self.create_and_commit_readme(project_id=project.id)
-            gitattributes = ""
-            for extn in extn_list:
-                gitattributes += f"*.{extn} filter=lfs diff=lfs merge=lfs -text\n"
-            self.create_and_commit_file(project_id=project.id, file_path=".gitattributes", content=gitattributes)
-        return project
-
-    def provide_owner_access(self, project_id, user_id):
-        """Provides owner access to a repository for a particular user."""
-        project = self.gl.projects.get(project_id)
-        member = project.members.create({
-            'user_id': user_id,
-            'access_level': 50
-        })
-        P.green(f"Owner access provided to user with ID {user_id}.")
-        return member
-
-    def get_project(self, project_name):
-        # Fetch all projects for the current user
-        projects = self.gl.projects.list(owned=True, all=True)
-
-        # Print details of each project
-        for project in projects:
-            if project.path == project_name:
-                return project
-        return None
-
-    def create_and_commit_readme(self, project_id, branch_name="main", content="# Welcome to your new project"):
-        """Creates a README.md file and commits it to the specified repository."""
-        project = self.gl.projects.get(project_id)
-        commit_data = {
-            'branch': branch_name,
-            'commit_message': 'Add README.md',
-            'actions': [
-                {
-                    'action': 'create',
-                    'file_path': 'README.md',
-                    'content': content
-                }
-            ]
-        }
-        commit = project.commits.create(commit_data)
-        P.green(f"README.md created and committed to the repository {project.name}.")
-        # print(commit)
-        return commit
-
-    def create_and_commit_file(self, project_id, branch_name="main", file_path="file.txt", content=""):
-        """Creates a file and commits it to the specified repository."""
-        project = self.gl.projects.get(project_id)
-        commit_data = {
-            'branch': branch_name,
-            'commit_message': f'Add {file_path}',
-            'actions': [
-                {
-                    'action': 'create',
-                    'file_path': file_path,
-                    'content': content
-                }
-            ]
-        }
-        commit = project.commits.create(commit_data)
-        P.green(f"{file_path} created and committed to the repository {project.name}.")
-        # print(commit)
-        return commit
-
-    def create_gitlab_repository(self, project_name, visibility='public'):
-        try:
-            project = self.gl.projects.create({'name': project_name, 'visibility': visibility})
-            return project.web_url
-        except Exception as e:
-            raise Exception(f"Failed to create GitLab repository: {e}")
-
-    def get_repository_users_with_access_levels(self, project_id):
-        access_levels = {
-            10: 'Guest',
-            20: 'Reporter',
-            30: 'Developer',
-            40: 'Maintainer',
-            50: 'Owner'
-        }
-
-        project = self.gl.projects.get(project_id)
-        members = project.members.list(all=True)
-        user_access_levels = [(member.username, member.access_level, access_levels.get(member.access_level, 'Unknown'))
-                              for member in
-                              members]
-
-        return user_access_levels
-
-    def list_projects_with_ids(self, print_details=False):
-        namespace_name = "nikgapps"
-        # Fetch all projects for the current user
-        projects = self.gl.projects.list(owned=True, all=True)
-
-        # Print details of each project
-        for project in projects:
-            if not print_details:
-                return projects
-            project_details = self.gl.projects.get(project.id, statistics=True)
-            storage_size = math.ceil(project_details.statistics["storage_size"] / (1024 ** 2) * 100) / 100
-            print(f'Project Name: {project.name}, Project ID: {project.id}, Namespace: {project.namespace["path"]}, '
-                  f'Storage Size: {storage_size} MB')
-        return projects
-
-    def find_project_allocated_size(self, repo_name):
-        project = self.get_project(repo_name)
-        project_details = self.gl.projects.get(project.id, statistics=True)
-        return math.ceil(project_details.statistics["storage_size"] / (1024 ** 2) * 100) / 100
-
-    def delete_project(self, project_id):
-        try:
-            project = self.gl.projects.get(project_id)
-            project_name = project.name
-            project_path = project.path
-            project.delete()
-            print(f"Project with id {project_id}, name {project_name} and path {project_path} deleted successfully.")
-        except Exception as e:
-            print(f"Failed to delete project {project_id}: {e}")
-
-    def rename_repository(self, repo_name, new_repo_name=None):
-        project = self.get_project(repo_name)
-        if new_repo_name is None:
-            new_repo_name = f"{repo_name}_{time.strftime('%Y%m%d')}"
-        new_project = self.get_project(new_repo_name)
-        if new_project is not None:
-            P.red(f"Project {new_repo_name} already exists. Deleting...")
-            self.delete_project(new_project.id)
-        project.name = new_repo_name
-        project.path = new_repo_name
-        P.yellow(f"Repository {repo_name} renaming to {new_repo_name}.")
-        project.save()
-        P.green(f"Repository {repo_name} renamed to {new_repo_name}.")
-        return project
-
-    def reset_repository(self, repo_name, gitattributes=None, user_id=8064473, sleep_for=10, delete_only=False):
-        try:
-            print(f"Resetting repository {repo_name}...")
-            project = self.get_project(repo_name)
-            self.delete_project(project.id)
-            if not delete_only:
-                P.red(f"Waiting for {sleep_for} seconds for the project to be completely deleted...")
-                time.sleep(sleep_for)
-                project = self.create_repository(repo_name, provide_owner_access=True, user_id=user_id)
-                if gitattributes is not None:
-                    commit = self.create_and_commit_file(project_id=project.id, file_path=".gitattributes",
-                                                         content=gitattributes)
-                    # print(commit)
-            return project
-        except Exception as e:
-            print(f"Failed to reset repository: {e}")
-            return None
-
-    def reset_repository_storage(self, repo_name, user_id=8064473, sleep_for=10, storage_cap=7500, gitattributes=None,
-                                 method="rename"):
-        old_project = self.get_project(repo_name)
-        project_details = self.gl.projects.get(old_project.id, statistics=True)
-        storage_size = math.ceil(project_details.statistics["storage_size"] / (1024 ** 2) * 100) / 100
-        if storage_size > storage_cap:
-            print(f"Storage size of {storage_size} MB exceeds the limit of {storage_cap} MB "
-                  f"for project id {old_project.id}. Resetting...")
-            old_repo_dir = Statics.pwd + Statics.dir_sep + f"{repo_name}_old"
-            old_repo = GitOperations.setup_repo(repo_dir=f"{old_repo_dir}", repo_url=project_details.ssh_url_to_repo)
-            match method.lower():
-                case "rename":
-                    old_project = self.rename_repository(repo_name)
-                    new_project = self.create_repository(repo_name, provide_owner_access=True, user_id=user_id)
-                case _:
-                    new_project = self.reset_repository(repo_name, user_id=user_id, sleep_for=sleep_for,
-                                                        gitattributes=gitattributes)
-            new_repo_dir = Statics.pwd + Statics.dir_sep + f"{repo_name}_new"
-            new_repo = GitOperations.setup_repo(repo_dir=f"{new_repo_dir}", repo_url=project_details.ssh_url_to_repo)
-            for item in Path(old_repo.working_tree_dir).rglob('*'):
-                if '.git' in item.parts:
-                    continue
-                destination = Path(new_repo.working_tree_dir) / item.relative_to(Path(old_repo.working_tree_dir))
-                if item.is_dir():
-                    destination.mkdir(parents=True, exist_ok=True)
-                else:
-                    destination.parent.mkdir(parents=True, exist_ok=True)
-                    print(f"Copying {item} to {destination}")
-                    shutil.copy2(item, destination)
-            new_repo.git_push("Initial Commit", push_untracked_files=True)
-            project_details = self.gl.projects.get(new_project.id, statistics=True)
-            storage_size = math.ceil(project_details.statistics["storage_size"] / (1024 ** 2) * 100) / 100
-            print(f"Repository storage for project id {new_project.id} reset successfully. "
-                  f"New storage size: {storage_size} MB")
-            FileOp.remove_dir(old_repo.working_tree_dir)
-            FileOp.remove_dir(new_repo.working_tree_dir)
-            match method.lower():
-                case "rename":
-                    self.delete_project(old_project.id)
-        else:
-            print(f"Storage size of {storage_size} MB is within the limit of {storage_cap} MB. No action required.")
-
-    def copy_repository(self, source_repo_name, target_repo_name, user_id=8064473, override_target=False):
-        project = self.get_project(source_repo_name)
-        if project is None:
-            print(f"Project {source_repo_name} does not exist. Exiting...")
-            return
-        old_repo_dir = Statics.pwd + Statics.dir_sep + f"{source_repo_name}_old"
-        old_repo = GitOperations.setup_repo(repo_dir=f"{old_repo_dir}", repo_url=project.ssh_url_to_repo)
-        if override_target:
-            target_project = self.get_project(target_repo_name)
-            if target_project is not None:
-                P.red(f"Project {target_repo_name} already exists. Deleting...")
-                self.delete_project(target_project.id)
-        if self.get_project(target_repo_name) is not None:
-            print(f"Project {target_repo_name} already exists. Exiting...")
-            return
-        project = self.create_repository(target_repo_name, provide_owner_access=True, user_id=user_id)
-        new_repo_dir = Statics.pwd + Statics.dir_sep + f"{target_repo_name}_new"
-        new_repo = GitOperations.setup_repo(repo_dir=f"{new_repo_dir}", repo_url=project.ssh_url_to_repo)
-        for item in Path(old_repo.working_tree_dir).rglob('*'):
-            if '.git' in item.parts:
-                continue
-            destination = Path(new_repo.working_tree_dir) / item.relative_to(Path(old_repo.working_tree_dir))
-            if item.is_dir():
-                destination.mkdir(parents=True, exist_ok=True)
-            else:
-                destination.parent.mkdir(parents=True, exist_ok=True)
-                print(f"Copying {item} to {destination}")
-                shutil.copy2(item, destination)
-        new_repo.git_push("Initial Commit", push_untracked_files=True)
-        FileOp.remove_dir(old_repo.working_tree_dir)
-        FileOp.remove_dir(new_repo.working_tree_dir)

NikGapps/helper/upload/Upload.py

@@ -1,125 +0,0 @@
-import os
-import platform
-from pathlib import Path
-import pysftp
-from NikGapps.helper.FileOp import FileOp
-from NikGapps.helper.P import P
-from NikGapps.helper.Statics import Statics
-from NikGapps.helper.T import T
-from NikGapps.helper.web.TelegramApi import TelegramApi
-
-
-class Upload:
-    def __init__(self, android_version, release_type, upload_files, password=None):
-        self.android_version = android_version
-        self.android_version_code = Statics.get_android_code(android_version)
-        self.upload_files = upload_files
-        self.host = "frs.sourceforge.net"
-        self.username = "nikhilmenghani"
-        self.password = os.environ.get('SF_PWD') if password is None else password
-        self.release_dir = Statics.get_sourceforge_release_directory(release_type)
-        self.release_date = T.get_london_date_time("%d-%b-%Y")
-        self.cmd_method = False  # can be removed later
-        self.upload_obj = None  # can be removed later
-        if self.password is None or self.password.__eq__(""):
-            self.password = ""
-            self.sftp = None
-            return
-        try:
-            self.sftp = pysftp.Connection(host=self.host, username=self.username, password=self.password)
-        except Exception as e:
-            P.red("Exception while connecting to SFTP: " + str(e))
-            self.sftp = None
-
-    def set_release_dir(self, release_dir):
-        self.release_dir = release_dir
-
-    def get_cd(self, file_type):
-        folder_name = f"{self.release_dir}/Test/{self.release_date}"
-        match file_type:
-            case "gapps" | "config":
-                folder_name = f"{self.release_dir}/Android-{self.android_version}/{self.release_date}"
-            case "addons":
-                folder_name = f"{self.release_dir}/Android-{self.android_version}/{self.release_date}/Addons"
-            case "debloater":
-                tools_dir = Statics.get_sourceforge_release_directory("NikGappsTools/Debloater")
-                folder_name = f"{tools_dir}/{self.release_date}"
-            case "removeotascripts":
-                tools_dir = Statics.get_sourceforge_release_directory("NikGappsTools/RemoveOtaScripts")
-                folder_name = f"{tools_dir}/{self.release_date}"
-            case "nikgappsconfig":
-                folder_name = f"{self.release_dir}/Android-{self.android_version}"
-            case _:
-                print(file_type)
-        print("Upload Dir: " + folder_name)
-        return folder_name
-
-    def upload(self, file_name, telegram: TelegramApi = None, remote_directory=None):
-        if self.sftp is not None:
-            system_name = platform.system()
-            execution_status = False
-            download_link = None
-            file_size_kb = round(FileOp.get_file_size(file_name, "KB"), 2)
-            file_size_mb = round(FileOp.get_file_size(file_name), 2)
-            if telegram is not None:
-                telegram.message(f"- The zip {file_size_mb} MB is uploading...")
-            if self.sftp is not None and system_name != "Windows" and self.upload_files:
-                t = T()
-                file_type = "gapps"
-                if os.path.basename(file_name).__contains__("-Addon-"):
-                    file_type = "addons"
-                elif os.path.basename(file_name).__contains__("Debloater"):
-                    file_type = "debloater"
-                elif os.path.basename(file_name).lower().__contains__("removeotascripts"):
-                    file_type = "removeotascripts"
-
-                if remote_directory is None:
-                    remote_directory = self.get_cd(file_type)
-
-                remote_filename = Path(file_name).name
-                try:
-                    self.sftp.chdir(remote_directory)
-                except IOError:
-                    P.magenta(f"The remote directory: {remote_directory} doesn't exist, creating..")
-                    try:
-                        self.sftp.makedirs(remote_directory)
-                        self.sftp.chdir(remote_directory)
-                    except Exception as e:
-                        P.red("Exception while creating directory: " + str(e))
-                        self.close_connection()
-                        self.sftp = pysftp.Connection(host=self.host, username=self.username, password=self.password)
-                        return execution_status
-                putinfo = self.sftp.put(file_name, remote_filename)
-                print(putinfo)
-                P.green(f'File uploaded successfully to {remote_directory}/{remote_filename}')
-                download_link = Statics.get_download_link(file_name, remote_directory)
-                P.magenta("Download Link: " + download_link)
-                print("uploading file finished...")
-                execution_status = True
-                time_taken = t.taken(f"Total time taken to upload file with size {file_size_mb} MB ("
-                                     f"{file_size_kb} Kb)")
-                if execution_status:
-                    if telegram is not None:
-                        telegram.message(
-                            f"- The zip {file_size_mb} MB uploaded in {T.format_time(round(time_taken))}\n",
-                            replace_last_message=True)
-                        if download_link is not None:
-                            telegram.message(f"*Note:* Download link should start working in 10 minutes",
-                                             escape_text=False,
-                                             ur_link={f"Download": f"{download_link}"})
-            else:
-                P.red("System incompatible or upload disabled or connection failed!")
-                P.red("system_name: " + system_name)
-                P.red("self.sftp: " + str(self.sftp))
-                P.red("self.upload_files: " + str(self.upload_files))
-            return execution_status, download_link, file_size_mb
-        else:
-            P.red("Connection failed!")
-            return False, None, None
-
-    def close_connection(self):
-        if self.cmd_method:
-            self.upload_obj.close_connection()
-        elif self.sftp is not None:
-            self.sftp.close()
-            print("Connection closed")

NikGapps/helper/web/Requests.py

@@ -1,139 +0,0 @@
-import json
-import time
-
-import requests
-from NikGapps.helper.Statics import Statics
-
-
-class Requests:
-
-    @staticmethod
-    def get(url, headers=None, params=None):
-        if params is None:
-            params = {"": ""}
-        if headers is None:
-            headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:105.0) Gecko/20100101 Firefox/105.0'}
-        result = requests.get(url, data=json.dumps(params), headers=headers)
-        if result.status_code == 429:
-            return Requests.handle_429_response(url, params, headers, result)
-        return result
-
-    @staticmethod
-    def put(url, headers=None, params=None):
-        if params is None:
-            params = {"": ""}
-        if headers is None:
-            headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:105.0) Gecko/20100101 Firefox/105.0'}
-        result = requests.put(url, data=json.dumps(params), headers=headers)
-        if result.status_code == 429:
-            return Requests.handle_429_response(url, params, headers, result)
-        return result
-
-    @staticmethod
-    def patch(url, headers=None, params=None):
-        if params is None:
-            params = {"": ""}
-        if headers is None:
-            headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:105.0) Gecko/20100101 Firefox/105.0'}
-        result = requests.patch(url, data=json.dumps(params), headers=headers)
-        if result.status_code == 429:
-            return Requests.handle_429_response(url, params, headers, result)
-        return result
-
-    @staticmethod
-    def post(url, headers=None, params=None):
-        if params is None:
-            params = {"": ""}
-        if headers is None:
-            headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:105.0) Gecko/20100101 Firefox/105.0'}
-        result = requests.post(url, data=json.dumps(params), headers=headers)
-        if result.status_code == 429:
-            return Requests.handle_429_response(url, params, headers, result)
-        return result
-
-    @staticmethod
-    def get_text(url):
-        return requests.get(url).text
-
-    @staticmethod
-    def get_release_date(android_version, release_type):
-        decoded_hand = Requests.get(Statics.release_tracker_url)
-        if decoded_hand.status_code == 200:
-            data = decoded_hand.json()
-            if android_version in data[release_type]:
-                return data[release_type][android_version]
-        else:
-            print(f"{decoded_hand.status_code} while getting release date")
-            return Statics.time
-
-    @staticmethod
-    def get_folder_access(folder_name=None):
-        decoded_hand = Requests.get(Statics.folder_access_url)
-        if decoded_hand.status_code == 200:
-            data = decoded_hand.json()
-            return data if folder_name is None else (data[folder_name] if folder_name in data else None)
-        else:
-            print(f"{decoded_hand.status_code} while getting folder access")
-            return None
-
-    @staticmethod
-    def get_admin_access():
-        decoded_hand = Requests.get(Statics.admin_access_url)
-        admin_list = []
-        if decoded_hand.status_code == 200:
-            for admin in decoded_hand.text.split("\n"):
-                if admin != "":
-                    admin_list.append(admin)
-            return admin_list
-        else:
-            print(f"{decoded_hand.status_code} while getting admin access")
-            return ["nikhilmenghani", "nikgapps"]
-
-    @staticmethod
-    def get_package_details(android_version):
-        package_details_url = f"https://raw.githubusercontent.com/nikgapps/tracker/main/{android_version}/GooglePackages.json"
-        decoded_hand = Requests.get(package_details_url)
-        package_details = {}
-        if decoded_hand.status_code == 200:
-            return decoded_hand.json()
-        else:
-            print(f"{decoded_hand.status_code} while getting package details")
-            return package_details
-
-    @staticmethod
-    def get_appset_details(android_version):
-        appset_details_url = f"https://raw.githubusercontent.com/nikgapps/tracker/main/{android_version}/AppSets.json"
-        decoded_hand = Requests.get(appset_details_url)
-        appset_details = {}
-        if decoded_hand.status_code == 200:
-            return decoded_hand.json()
-        else:
-            print(f"{decoded_hand.status_code} while getting appset details")
-            return appset_details
-
-    @staticmethod
-    def handle_429_response(url, params, headers, result):
-        if 'Retry-After' in result.headers:
-            wait_time = float(result.headers['Retry-After'])
-            print(f"Sleeping for {wait_time} seconds...")
-            time.sleep(wait_time)
-            return requests.get(url, data=json.dumps(params), headers=headers)
-        else:
-            for delay in [0, 1, 2, 4, 8, 16, 32, 64]:
-                print(f"Rate limit exceeded. Waiting for {delay} seconds before retrying...")
-                time.sleep(delay)
-                result = requests.get(url, data=json.dumps(params), headers=headers)
-                if result.status_code != 429:
-                    return result
-            return result
-
-    @staticmethod
-    def get_data_in_json(url):
-        url = f"{url}"
-        decoded_hand = Requests.get(url)
-        details = {}
-        if decoded_hand.status_code == 200:
-            return decoded_hand.json()
-        else:
-            print(f"{decoded_hand.status_code} while getting package details")
-            return details

NikGapps/helper/web/TelegramApi.py

@@ -1,126 +0,0 @@
-import time
-
-import requests
-import yaml
-
-from .Requests import Requests
-
-
-class TelegramApi:
-
-    def __init__(self, token, chat_id, message_thread_id=None):
-        self.token = token
-        self.base = "https://api.telegram.org"
-        self.chat_id = chat_id
-        self.message_thread_id = message_thread_id
-        self.message_id = None
-        self.msg = None
-        self.last_msg = None
-        self.urls = {}
-        self.changelog = None
-
-    def message(self, text, chat_id=None, replace_last_message=False, escape_text=True, parse_mode="markdown",
-                ur_link=None, send_as_new_message=False):
-        if self.token is None:
-            return None
-        if chat_id is None:
-            chat_id = self.chat_id
-        if text is None or str(text).__eq__(""):
-            print("No text to send")
-            return None
-        if send_as_new_message:
-            self.reset_message()
-        if escape_text:
-            for i in '_*[]~`>+=|{}':
-                text = text.replace(i, "\\" + i)
-        sending_text = text
-        if self.message_id is not None:
-            sending_text = self.msg.replace(self.last_msg, text) if replace_last_message else (self.msg + "\n" + text)
-        data = {
-            "chat_id": chat_id,
-            "text": f"{sending_text}",
-            "parse_mode": f"{parse_mode}",
-            "disable_web_page_preview": True
-        }
-        if self.message_thread_id is not None:
-            data["message_thread_id"] = self.message_thread_id
-        url = f"{self.base}/bot{self.token}/sendMessage"
-        if self.message_id is not None:
-            data["message_id"] = self.message_id
-            url = f"{self.base}/bot{self.token}/editMessageText"
-        if ur_link is not None:
-            ur_link: dict
-            for key in ur_link:
-                self.urls[key] = ur_link[key]
-        if len(self.urls) > 0:
-            row_list = []
-            inline_list = []
-            max_col = 1 if len(self.urls) > 1 else len(self.urls)
-            for count, key in enumerate(self.urls):
-                inline_list.append({"text": key, "url": self.urls[key]})
-                if count == max_col:
-                    row_list.append(inline_list)
-                    inline_list = []
-            if len(inline_list) > 0:
-                row_list.append(inline_list)
-            data["reply_markup"] = {
-                "inline_keyboard": [
-                    row for row in row_list
-                ]
-            }
-        r = requests.post(url, json=data)
-        response = r.json()
-        if r.status_code != 200:
-            print(f"Error sending message: {response}")
-            if r.status_code == 429:
-                print(f"Sleeping for {response['parameters']['retry_after']} seconds")
-                time.sleep(response['parameters']['retry_after'])
-            else:
-                return None
-        if response["ok"]:
-            self.last_msg = text
-            self.msg = sending_text
-            self.message_id = response["result"]["message_id"]
-        return response
-
-    def delete_message(self, message_id=None, chat_id=None):
-        if self.token is None:
-            return None
-        if chat_id is None:
-            chat_id = self.chat_id
-        if message_id is None:
-            message_id = self.message_id
-        if message_id is None:
-            return None
-        url = f"{self.base}/bot{self.token}/deleteMessage" \
-              f"?chat_id={chat_id}" \
-              f"&message_id={str(message_id)}"
-        r = Requests.get(url)
-        response = r.json()
-        return response
-
-    def get_latest_changelog_message(self, changelog=None):
-        if changelog is not None:
-            self.changelog = changelog
-            with open(self.changelog, 'r') as stream:
-                try:
-                    msg = ""
-                    for date in yaml.safe_load(stream):
-                        msg += f"*New Release is up - {date['date']}*\n\n"
-                        msg += f"Changelog:\n"
-                        for item in date['changes']:
-                            msg += f"- {item['item']}\n"
-                        msg += f"\n"
-                        msg += f"*Note: *\n"
-                        msg += "- You can always take a backup and dirty flash the gapps, if you run into issues, you should try clean flashing the gapps.\n"
-                        msg += "if you have any problem feel free to reach us @NikGappsGroup\nHappy Flashing!"
-                        break
-                    return msg
-                except yaml.YAMLError as exc:
-                    print(exc)
-        return None
-
-    def reset_message(self):
-        self.message_id = None
-        self.msg = None
-        self.urls = {}