gitflow-manager 1.1.4__tar.gz → 2.0.0__tar.gz

{gitflow_manager-1.1.4 → gitflow_manager-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitflow_manager
-Version: 1.1.4
+Version: 2.0.0
 Summary: This package contains the Anacision Git Manager.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -9,6 +9,11 @@ Requires-Dist: pystache>=0.6.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: requests>=2.27.1
 Requires-Dist: tomlkit>=0.13.3
+Provides-Extra: dev
+Requires-Dist: pre-commit>=4.0.1; extra == "dev"
+Requires-Dist: ruff==0.6.9; extra == "dev"
+Requires-Dist: setuptools>=75.3.0; extra == "dev"
+Requires-Dist: twine>=6.0.1; extra == "dev"
 
 # Anacision Gitflow Manager
 

gitflow_manager-2.0.0/gitflow_manager/__init__.py

@@ -0,0 +1 @@
+__version__="2.0.0"

{gitflow_manager-1.1.4 → gitflow_manager-2.0.0}/gitflow_manager/git_hosts.py

@@ -1,3 +1,4 @@
+import base64
 import json
 import warnings
 from abc import ABC, abstractmethod
@@ -52,7 +53,13 @@ class GitHost(ABC):
         pass
 
     @abstractmethod
-    def create_merge_request(self, source_branch: str, target_branch: str, description: str) -> None:
+    def create_merge_request(
+        self,
+        source_branch: str,
+        target_branch: str,
+        description: str,
+        reviewer_ids: list[int] | None = None,
+    ) -> None:
         """Create a merge request between branches."""
         pass
 
@@ -115,6 +122,39 @@ class GitHost(ABC):
         """
         return self.git_obj.execute(["git", "rev-parse", "--abbrev-ref", "HEAD"])
 
+    def _build_basic_auth_header(self, username: str) -> str:
+        """
+        Build an HTTP Basic auth header for Git-over-HTTPS operations.
+
+        :param username: Username part for HTTP Basic authentication
+        :return: Authorization header value
+        """
+        raw_auth = f"{username}:{self.token}".encode("utf-8")
+        encoded_auth = base64.b64encode(raw_auth).decode("ascii")
+        return f"Authorization: Basic {encoded_auth}"
+
+    def _execute_git_with_https_auth(self, git_args: list[str], https_url: str, username: str) -> str:
+        """
+        Execute a git command against origin using an in-memory HTTPS URL and auth header.
+
+        :param git_args: Arguments after the git executable
+        :param https_url: HTTPS repository URL for origin
+        :param username: Username part for HTTP Basic authentication
+        :return: Command output
+        """
+        auth_header = self._build_basic_auth_header(username=username)
+        command = [
+            "git",
+            "-c",
+            f"remote.origin.url={https_url}",
+            "-c",
+            f"remote.origin.pushurl={https_url}",
+            "-c",
+            f"http.extraHeader={auth_header}",
+            *git_args,
+        ]
+        return self.git_obj.execute(command)
+
 
 class BitBucket(GitHost):
     """
@@ -145,52 +185,40 @@ class BitBucket(GitHost):
         info = self._create_request(
             f"{self.git_host_rest_url}/api/1.0/projects/{self.project_id}/repos/{self.repo_id}"
         ).json()
-        url = info["links"]["clone"][1]["href"]
-        if url != self.git_obj.execute(["git", "remote", "get-url", "origin"]):
-            ssh_url = True
-            # set origin temporarily to https url
-            url = url.replace("https://", f"https://oauth2:{self.token}@")
-            self.git_obj.execute(["git", "remote", "set-url", "origin", url])
-            # necessary as some configs have an extra push url (and we cannot check if it exists...)
-            self.git_obj.execute(["git", "remote", "set-url", "--push", "origin", url])
-        else:
-            ssh_url = False
+        clone_links = info["links"]["clone"]
+        https_link = next((l for l in clone_links if l["name"] in {"http","https"}), clone_links[0])
+        url = https_link["href"]
         try:
             if method == "push":
-                self.git_obj.execute(["git", "push", "--set-upstream", "origin", branch])
+                self._execute_git_with_https_auth(
+                    git_args=["push", "--set-upstream", "origin", branch],
+                    https_url=url,
+                    username="oauth2",
+                )
                 if tag is not None:
-                    self.git_obj.execute(["git", "push", "origin", f"refs/tags/{tag}"])
+                    self._execute_git_with_https_auth(
+                        git_args=["push", "origin", f"refs/tags/{tag}"],
+                        https_url=url,
+                        username="oauth2",
+                    )
 
             else:
-                self.git_obj.execute(["git", "pull", "origin", branch])
+                self._execute_git_with_https_auth(
+                    git_args=["pull", "origin", branch],
+                    https_url=url,
+                    username="oauth2",
+                )
         except GitCommandError as e:
             raise Exception(
                 f"Trying to communicate via https failed due to:\n{str(e)}\n\n" f"Please pull/push manually!!!"
             )
-        finally:
-            self.git_obj.fetch("origin")
-            self.git_obj.execute(["git", "branch", "--set-upstream-to", f"origin/{branch}"])
-            if ssh_url:
-                # make sure remote tracking is set back to the default
-                self.git_obj.execute(
-                    [
-                        "git",
-                        "remote",
-                        "set-url",
-                        "origin",
-                        [link["href"] for link in info["links"]["clone"] if link["name"] == "ssh"][0],
-                    ]
-                )
-                self.git_obj.execute(
-                    [
-                        "git",
-                        "remote",
-                        "set-url",
-                        "--push",
-                        "origin",
-                        [link["href"] for link in info["links"]["clone"] if link["name"] == "ssh"][0],
-                    ]
-                )
+
+        self._execute_git_with_https_auth(
+            git_args=["fetch", "origin"],
+            https_url=url,
+            username="oauth2",
+        )
+        self.git_obj.execute(["git", "branch", "--set-upstream-to", f"origin/{branch}"])
 
     def git_remote(self, method, branch="HEAD", tag=None):
         """
@@ -261,7 +289,7 @@ class BitBucket(GitHost):
         except Exception as e:
             return f"Could not identify protected branches: {e}"
 
-    def create_merge_request(self, source_branch, target_branch, description):
+    def create_merge_request(self, source_branch, target_branch, description, reviewer_ids=None):
         """
         Create a merge request in a Bitbucket repository.
 
@@ -350,43 +378,39 @@ class GitLab(GitHost):
         if "error" in info:
             raise AssertionError(f"Error when accessing Gitlab API: {info['error_description']}")
         url = info["http_url_to_repo"]
-        origin_url = self.git_obj.execute(["git", "remote", "get-url", "origin"])
-        url_replaced = False
-        if "https://" not in origin_url:
-            url_replaced = True
-            # set origin temporarily to https url
-            url = url.replace("https://", f"https://oauth2:{self.token}@")
-            self.git_obj.execute(["git", "remote", "set-url", "origin", url])
-            # necessary as some configs have an extra push url (and we cannot check if it exists...)
-            self.git_obj.execute(["git", "remote", "set-url", "--push", "origin", url])
-        else:
-            user_name = self._create_request(f"{self.git_host_rest_url}/user").json()["username"]
-            url = url.replace("https://", f"https://{user_name}:{self.token}@")
-            if url != origin_url:
-                url_replaced = True
-                self.git_obj.execute(["git", "remote", "set-url", "origin", url])
-                # necessary as some configs have an extra push url (and we cannot check if it exists...)
-                self.git_obj.execute(["git", "remote", "set-url", "--push", "origin", url])
+        user_name = self._create_request(f"{self.git_host_rest_url}/user").json().get("username", "oauth2")
 
         try:
             if method == "push":
-                self.git_obj.execute(["git", "push", "--set-upstream", "origin", branch])
+                self._execute_git_with_https_auth(
+                    git_args=["push", "--set-upstream", "origin", branch],
+                    https_url=url,
+                    username=user_name,
+                )
                 if tag is not None:
-                    self.git_obj.execute(["git", "push", "origin", f"refs/tags/{tag}"])
+                    self._execute_git_with_https_auth(
+                        git_args=["push", "origin", f"refs/tags/{tag}"],
+                        https_url=url,
+                        username=user_name,
+                    )
 
             else:
-                self.git_obj.execute(["git", "pull", "origin", branch])
+                self._execute_git_with_https_auth(
+                    git_args=["pull", "origin", branch],
+                    https_url=url,
+                    username=user_name,
+                )
         except GitCommandError as e:
             raise Exception(
                 f"Trying to communicate via https failed due to:\n{str(e)}\n\n" f"Please pull/push manually!!!"
             )
-        finally:
-            self.git_obj.fetch("origin")
-            self.git_obj.execute(["git", "branch", "--set-upstream-to", f"origin/{branch}"])
-            if url_replaced:
-                # make sure remote tracking is set back to the default
-                self.git_obj.execute(["git", "remote", "set-url", "origin", origin_url])
-                self.git_obj.execute(["git", "remote", "set-url", "--push", "origin", origin_url])
+
+        self._execute_git_with_https_auth(
+            git_args=["fetch", "origin"],
+            https_url=url,
+            username=user_name,
+        )
+        self.git_obj.execute(["git", "branch", "--set-upstream-to", f"origin/{branch}"])
 
     def git_remote(self, method, branch="HEAD", tag=None):
         """
@@ -424,23 +448,94 @@ class GitLab(GitHost):
 
         :return: A list of names for the protected branches in the repository.
         """
-        response = self._create_request(f"{self.git_host_rest_url}/projects/{self.project_id}/protected_branches").json()
+        response = self._create_request(
+            f"{self.git_host_rest_url}/projects/{self.project_id}/protected_branches"
+        ).json()
         protected = []
         for br in response:
             if br["push_access_levels"][0]["access_level"] == 0:
                 protected.append(br["name"])
         return protected
 
-    def create_merge_request(self, source_branch, target_branch, description):
+    def _current_user_id(self) -> int | None:
+        """
+        Return GitLab user ID of the authenticated user.
+        Returns None if a project access token is used.
+        """
+        user_data = self._create_request(f"{self.git_host_rest_url}/user").json()
+        username = user_data.get("username", "")
+
+        # detect project bot users by naming pattern
+        if username.startswith("project_") or "_bot" in username:
+            return None
+
+        return user_data["id"]
+
+    def _user_id_by_username(self, username: str) -> int | None:
+        """
+        Return the GitLab user ID for a given username.
+        Returns None if the user does not exist.
+        """
+        res = self._create_request(f"{self.git_host_rest_url}/users", params={"username": username}).json()
+        return res[0]["id"] if res else None
+
+    def _reviewer_ids(self, reviewers: list[str]) -> tuple[list[int], list[str]]:
+        """
+        Convert GitLab usernames to user IDs.
+        Returns (valid ids, invalid usernames).
+        """
+        ids: list[int] = []
+        invalid: list[str] = []
+        for username in reviewers:
+            uid = self._user_id_by_username(username)
+            if uid is None:
+                invalid.append(username)
+            else:
+                ids.append(uid)
+        return ids, invalid
+
+    def _prompt_reviewer_ids(self) -> list[int]:
+        """
+        Prompt for reviewer usernames and resolve them to GitLab user IDs.
+        Returns a list of user IDs, or [] if user skips (presses Enter).
+        """
+        reviewer_id_set: set[int] = set()
+        invalid: list[str] = []
+
+        rev = input("Enter reviewer usernames (without @, comma-separated), or leave empty to skip:\n").strip()
+        if rev:
+            reviewers = [r.strip() for r in rev.split(",") if r.strip()]
+            ids, invalid = self._reviewer_ids(reviewers)
+            reviewer_id_set.update(ids)
+
+        while invalid:
+            print(f'Invalid usernames: {", ".join(invalid)}')
+            rev = input("Re-enter the invalid usernames, or press Enter to continue with valid reviewers:\n").strip()
+            if not rev:
+                break
+
+            retry = [r.strip() for r in rev.split(",") if r.strip()]
+            ids, invalid = self._reviewer_ids(retry)
+            reviewer_id_set.update(ids)
+
+        return list(reviewer_id_set)
+
+    def create_merge_request(self, source_branch, target_branch, description, reviewer_ids=None):
         """
         Create a merge request in a GitLab repository.
 
         :param source_branch: The branch to be merged into the target branch.
         :param target_branch: The branch into which the source branch will be merged.
         :param description: A description for the merge request.
+        :param reviewer_ids: Optional list of reviewer ids.
         """
         # make sure source branch is up to date on origin
         self.git_push(source_branch)
+
+        # normalize empty list → None for GitLab API
+        if reviewer_ids == []:
+            reviewer_ids = None
+
         # create merge information
         merge_data = {
             "id": self.project_id,
@@ -449,6 +544,8 @@ class GitLab(GitHost):
             "title": f"Merge {source_branch} into {target_branch}",
             "description": description,
             "remove_source_branch": False,
+            "assignee_id": self._current_user_id(),
+            "reviewer_ids": reviewer_ids,
         }
 
         response = self._create_request(

{gitflow_manager-1.1.4 → gitflow_manager-2.0.0}/gitflow_manager/gitflow_manager.py

@@ -46,8 +46,9 @@ class GitFlowManager:
         self.check_docs = check_docs
         self.dynamic_version = dynamic_version
         self.layout = project_layout
-        self.package_name, self.package_version = self.get_package_info(layout=project_layout,
-                                                                        dynamic_version=dynamic_version)
+        self.package_name, self.package_version = self.get_package_info(
+            layout=project_layout, dynamic_version=dynamic_version
+        )
         self.steps_to_do = []
         self.steps_done = []
         self.files_to_commit = []
@@ -75,12 +76,26 @@ class GitFlowManager:
             if match:
                 package_version = match.group(1)
             else:
-                raise FileNotFoundError(f"Found no version in init file {path_to_init}. If your project has no dynamic"
-                                        f"version, please set 'dynamic_version' to false in '.gitflow_manager.yml'.")
+                raise FileNotFoundError(
+                    f"Found no version in init file {path_to_init}. If your project has no dynamic"
+                    f"version, please set 'dynamic_version' to false in '.gitflow_manager.yml'."
+                )
         else:
             package_version = pyproject_data["project"]["version"]
         return package_name, package_version
 
+    def assert_branch_available(self, branch_name: str):
+        """
+        Raise if branch_name already exists locally or on origin.
+
+        :param branch_name: Name of the branch to check
+        """
+        if self.git.execute(["git", "branch", "--list", branch_name]).strip():
+            raise GitFlowManagerError(f'Branch "{branch_name}" already exists locally.')
+
+        if self.git.execute(["git", "ls-remote", "--heads", "origin", branch_name]).strip():
+            raise GitFlowManagerError(f'Branch "{branch_name}" already exists on origin.')
+
     def branch_from_main(self, chglog, user_name, app_specific_changes, app_specific_text):
         """
         Create a new branch from the main branch, update version and changelog, and push new branch to origin
@@ -106,6 +121,7 @@ class GitFlowManager:
         package_version_parsed = [int(x) for x in self.package_version.split(".")]
         new_package_version = self.increase_version(package_version_parsed, "hotfix")
         branch_name = f"hotfix/v{new_package_version}"
+        self.assert_branch_available(branch_name)
         self.steps_to_do.extend([f'Checkout to "{branch_name}"'])
         # create the new hotfix branch and checkout
         self.git.checkout("HEAD", b=branch_name)  # create a new branch
@@ -179,6 +195,7 @@ class GitFlowManager:
                     print("Only letters and underscore is allowed!")
 
         branch_name = f"{branch_type}/{new_branch}"
+        self.assert_branch_available(branch_name)
         self.steps_to_do.extend([f'Checkout to "{branch_name}"'])
         # create the new release branch and checkout
         self.git.checkout("HEAD", b=branch_name)  # create a new branch
@@ -234,9 +251,7 @@ class GitFlowManager:
             sys.exit()
 
         if answer == "0":
-            self.edit_change_log_info(
-                chglog, user_name, app_specific_changes, app_specific_text
-            )
+            self.edit_change_log_info(chglog, user_name, app_specific_changes, app_specific_text)
         else:
             # fill steps to do list
             self.steps_to_do.append("Do a sanity push of your branch to origin beforehand")
@@ -244,9 +259,16 @@ class GitFlowManager:
                 f"Merge branch into dev & {self.main_branch_name} (directly+pushing or via merge request)"
             )
             branches_to_merge = ["dev"]
+            descr = None
+            reviewer_ids = None
 
             if answer == "2":
                 branches_to_merge.append(self.main_branch_name)
+                descr = input(
+                    f"Enter description for merge into dev and {self.main_branch_name} "
+                    f"(adding all git commit messages if nothing entered)\n"
+                ).strip()
+                reviewer_ids = self.git_host._prompt_reviewer_ids()
                 # only do the commit check if there will be merge into the main branch
                 self.commit_check(branches_to_merge[-1])
                 last_main_commit = self.git.execute(["git", "rev-parse", f"origin/{branches_to_merge[-1]}"])
@@ -261,10 +283,10 @@ class GitFlowManager:
             self.steps_to_do.pop(0)
 
             protected_branches = self.git_host.get_protected_branches()
-            descr = None
+
             for main_branch in branches_to_merge:
                 if main_branch in protected_branches:
-                    self.request_merge(main_branch, last_main_commit, descr)
+                    self.request_merge(main_branch, last_main_commit, descr, reviewer_ids)
 
                 else:
                     self.merge_branch(main_branch)
@@ -293,9 +315,7 @@ class GitFlowManager:
             sys.exit()
 
         if answer == "0":
-            self.edit_change_log_info(
-                chglog, user_name, app_specific_changes, app_specific_text
-            )
+            self.edit_change_log_info(chglog, user_name, app_specific_changes, app_specific_text)
         else:
             print("******Checking latest commit of dev...******")
             main_branch = "dev"
@@ -378,8 +398,10 @@ class GitFlowManager:
         init_text = read_file(path_to_init)
         init_text_new = init_text.replace(old_version, new_version)
         if init_text == init_text_new:
-            warnings.warn(f"Failed to replace old version string with new one in {path_to_init}. Probably it does not"
-                          f"contain a version string.")
+            warnings.warn(
+                f"Failed to replace old version string with new one in {path_to_init}. Probably it does not"
+                f"contain a version string."
+            )
         else:
             write_to_file(path_to_init, init_text_new)
 
@@ -521,21 +543,19 @@ class GitFlowManager:
         print(self.git.status())
 
         try:
-            self.git.commit(f'-m {message}')
+            self.git.commit(f"-m {message}")
         except GitCommandError:
             print("******Try committing changes again after pre-commit.******")
             self.git.add(self.files_to_commit)
-            self.git.commit(f'-m {message}')
+            self.git.commit(f"-m {message}")
 
         self.steps_done.append(self.steps_to_do.pop(0))
-        print(f"******Pushing now...******")
+        print("******Pushing now...******")
         self.git_host.git_push(branch_name)
         self.files_to_commit = []
         self.steps_done.append(self.steps_to_do.pop(0))
 
-    def edit_change_log_info(
-        self, chglog, user_name, app_specific_changes, app_specific_text
-    ):
+    def edit_change_log_info(self, chglog, user_name, app_specific_changes, app_specific_text):
         """
         Edit change log information or regenerate change log.
         :param chglog:
@@ -555,9 +575,7 @@ class GitFlowManager:
             sys.exit()
 
         if answer == "0":
-            self.add_change_log_info(
-                chglog, user_name, app_specific_changes, app_specific_text
-            )
+            self.add_change_log_info(chglog, user_name, app_specific_changes, app_specific_text)
         else:
             self.steps_to_do.append("Create new change_log.rst")
             print("******Regenerating change log...******")
@@ -575,9 +593,7 @@ class GitFlowManager:
         :return:
         """
         # fill steps to do list
-        self.steps_to_do.append(
-            "Log changes to change_log.json and create new change_log.rst"
-        )
+        self.steps_to_do.append("Log changes to change_log.json and create new change_log.rst")
         if "bugfix/" in self.branch_of_interest or "hotfix/" in self.branch_of_interest:
             ask_sections = [Sections.fixed]
         else:
@@ -625,7 +641,9 @@ class GitFlowManager:
         # find most recent commit of main branch/dev
         last_main_commit = self.git.execute(["git", "rev-parse", f"origin/{branch_to_merge}"])
         if last_commit == last_main_commit:
-            raise GitFlowManagerError(f"{branch_to_merge} is already up to date with your branch {self.branch_of_interest}")
+            raise GitFlowManagerError(
+                f"{branch_to_merge} is already up to date with your branch {self.branch_of_interest}"
+            )
         self.steps_done.append(self.steps_to_do.pop(0))
         if (
             common_commit != last_main_commit
@@ -672,13 +690,18 @@ class GitFlowManager:
                     print(f"Answer was {answer}, aborting...")
                     sys.exit()
 
-    def request_merge(self, branch_to_merge, last_main_commit, descr):
+    def request_merge(self, branch_to_merge, last_main_commit, descr, reviewer_ids=None):
         """
         For protected branches, create a merge request
 
         :param branch_to_merge: Branch to merge into, main branch or dev
         :param last_main_commit: Last commit of the branch to merge into
-        :param descr: Description for the merge request
+        :param descr: Description for the merge request.
+                      None prompts the user for input.
+                      "" skips the prompt and auto-generates from commit history.
+        :param reviewer_ids: Optional list of GitLab reviewer user IDs.
+                             None prompts the user for reviewer usernames.
+                             [] skips the prompt and creates the merge request without reviewers.
         """
         # fill steps to do list
         self.steps_to_do.append(f"Create merge request for branch {self.branch_of_interest} into {branch_to_merge}")
@@ -688,25 +711,28 @@ class GitFlowManager:
                 f"Enter some description for the merge to {branch_to_merge} "
                 f"(adding all git commit messages if nothing entered)\n"
             )
-            if len(descr) <= 1:
-                commit_history = self.git.execute(
-                    [
-                        "git",
-                        "log",
-                        '--pretty=format:"%h%x09%an:%x09%s"',
-                        f"{last_main_commit}..HEAD",
-                    ]
-                )
-                commit_history = "* " + "* ".join(commit_history.splitlines(True))
-                descr = (
-                    f"Merge of {self.branch_of_interest} into {branch_to_merge}.\n\n"
-                    f"Git history:\n\n{commit_history}"
-                )
+        if not descr.strip():  # auto-generate if empty or whitespace-only
+            commit_history = self.git.execute(
+                [
+                    "git",
+                    "log",
+                    '--pretty=format:"%h%x09%an:%x09%s"',
+                    f"{last_main_commit}..HEAD",
+                ]
+            )
+            commit_history = "* " + "* ".join(commit_history.splitlines(True))
+            descr = (
+                f"Merge of {self.branch_of_interest} into {branch_to_merge}.\n\n" f"Git history:\n\n{commit_history}"
+            )
+
+        if reviewer_ids is None:
+            reviewer_ids = self.git_host._prompt_reviewer_ids()  # only implemented for GitLab
 
         self.git_host.create_merge_request(
             source_branch=self.branch_of_interest,
             target_branch=branch_to_merge,
             description=descr,
+            reviewer_ids=reviewer_ids,
         )
         self.steps_done.append(self.steps_to_do.pop(0))
 

{gitflow_manager-1.1.4 → gitflow_manager-2.0.0}/gitflow_manager/start.py

@@ -3,15 +3,22 @@ from pathlib import Path
 from urllib.parse import urlparse
 import requests
 import yaml
+from git import Repo
 
 from gitflow_manager.run import run
 
 
 def get_project_details(repo_url, git_host_token):
     """Get the details of the repository: url, project id, repository name"""
-    parsed_url = urlparse(repo_url)
-    host = parsed_url.netloc
-    path = parsed_url.path.strip("/").removesuffix(".git")
+
+    if repo_url.startswith("git@"):
+        host, path = repo_url.split(":", 1)
+        host = host.split("@", 1)[1]
+    else:
+        parsed = urlparse(repo_url)
+        host = parsed.netloc
+        path = parsed.path
+    path = path.strip("/").removesuffix(".git")
 
     namespace, repo_name = path.split("/", 1)
     gitlab_api_url = f"https://{host}/api/v4"
@@ -46,12 +53,20 @@ def init(config_file: Path):
     """Function to initialize GitFlowManager"""
 
     # Check if config exists
-    if not config_file.is_file() or input("Configuration already existing in .gitflow_manager.yml. "
-                        "Use existing configuration (y/n)?\n").lower() == "n":
+    if (
+        not config_file.is_file()
+        or input(
+            "Configuration already existing in .gitflow_manager.yml. " "Use existing configuration (y/n)?\n"
+        ).lower()
+        == "n"
+    ):
         # create new config file and use new information
-        repo_url = input("Please enter the URL of your repository:\n")
-        git_host_token = input("Please enter a project or personal token, with which you can access that repository "
-                         "(read/write):\n")
+        repo_url = Repo(".").remotes.origin.url
+        print(f"Using origin URL from current repository:\n{repo_url}")
+
+        git_host_token = input(
+            "Please enter a project or personal token, with which you can access that repository " "(read/write):\n"
+        )
         git_host_rest_url, project_id, repo_name = get_project_details(repo_url, git_host_token=git_host_token)
         project_layout = input("Please enter the layout of your project (e.g., 'flat' or 'src'):\n")
         dynamic_version = input("Is the versioning of your project dynamic (y/n)?\n")
@@ -62,16 +77,19 @@ def init(config_file: Path):
         use_ssh = use_ssh.lower() == "y"
 
         # Save config
-        save_config(config_file, {
-            "git_host_rest_url": git_host_rest_url,
-            "git_host_token": git_host_token,
-            "project_id": project_id,
-            "repo_name": repo_name,
-            "project_layout": project_layout,
-            "dynamic_version": dynamic_version,
-            "check_docs": check_docs,
-            "use_ssh": use_ssh
-        })
+        save_config(
+            config_file,
+            {
+                "git_host_rest_url": git_host_rest_url,
+                "git_host_token": git_host_token,
+                "project_id": project_id,
+                "repo_name": repo_name,
+                "project_layout": project_layout,
+                "dynamic_version": dynamic_version,
+                "check_docs": check_docs,
+                "use_ssh": use_ssh,
+            },
+        )
 
         ignore_file = Path(".gitignore")
 
@@ -103,7 +121,8 @@ def main():
     if config_file.is_file():
         config = load_config(config_file)
         # use config file based on user choice during init
-        run(config["project_id"],
+        run(
+            config["project_id"],
             config["repo_name"],
             folder=str(Path.cwd()),  # Get the current project directory,
             git_host_rest_url=config["git_host_rest_url"],
@@ -111,11 +130,13 @@ def main():
             layout=config["project_layout"],
             dynamic_version=config["dynamic_version"],
             check_docs=config["check_docs"],
-            use_ssh=config["use_ssh"]
-            )
+            use_ssh=config["use_ssh"],
+        )
     else:
-        raise FileNotFoundError("Git manager config file '.gitflow_manager.yml' not found in the current directory. "
-                                "Either you are in the wrong directory, or you have not run 'gfm --init', yet.")
+        raise FileNotFoundError(
+            "Git manager config file '.gitflow_manager.yml' not found in the current directory. "
+            "Either you are in the wrong directory, or you have not run 'gfm --init', yet."
+        )
 
 
 if __name__ == "__main__":

{gitflow_manager-1.1.4 → gitflow_manager-2.0.0}/gitflow_manager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitflow_manager
-Version: 1.1.4
+Version: 2.0.0
 Summary: This package contains the Anacision Git Manager.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -9,6 +9,11 @@ Requires-Dist: pystache>=0.6.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: requests>=2.27.1
 Requires-Dist: tomlkit>=0.13.3
+Provides-Extra: dev
+Requires-Dist: pre-commit>=4.0.1; extra == "dev"
+Requires-Dist: ruff==0.6.9; extra == "dev"
+Requires-Dist: setuptools>=75.3.0; extra == "dev"
+Requires-Dist: twine>=6.0.1; extra == "dev"
 
 # Anacision Gitflow Manager
 

{gitflow_manager-1.1.4 → gitflow_manager-2.0.0}/gitflow_manager.egg-info/requires.txt

@@ -3,3 +3,9 @@ pystache>=0.6.0
 pyyaml>=6.0.2
 requests>=2.27.1
 tomlkit>=0.13.3
+
+[dev]
+pre-commit>=4.0.1
+ruff==0.6.9
+setuptools>=75.3.0
+twine>=6.0.1

{gitflow_manager-1.1.4 → gitflow_manager-2.0.0}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
 [project.scripts]
 gfm = "gitflow_manager.start:main"
 
-[dependency-groups]
+[project.optional-dependencies]
 dev = [
     "pre-commit>=4.0.1",
     "ruff==0.6.9",
@@ -32,7 +32,7 @@ version = { attr = "gitflow_manager.__version__" }
 
 [tool.ruff]
 line-length = 120
-target-version="1.1.4"
+target-version="2.0.0"
 
 [tool.ruff.lint]
 select = [

gitflow_manager-1.1.4/gitflow_manager/__init__.py

@@ -1 +0,0 @@
-__version__="1.1.4"