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

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)

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)