suite-py 1.48.0__tar.gz → 1.49.0__tar.gz

{suite_py-1.48.0 → suite_py-1.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: suite-py
-Version: 1.48.0
+Version: 1.49.0
 Summary: 
 Author: larrywax, EugenioLaghi, michelangelomo
 Author-email: devops@prima.it
@@ -28,7 +28,7 @@ Requires-Dist: pytest (>=7.0.0)
 Requires-Dist: python-dateutil (>=2.8.2)
 Requires-Dist: requests (>=2.26.0)
 Requires-Dist: requests-toolbelt (>=0.9.1)
-Requires-Dist: rich (==14.1.0)
+Requires-Dist: rich (==14.2.0)
 Requires-Dist: semver (>=3.0.4,<4.0.0)
 Requires-Dist: termcolor (>=1.1.0)
 Requires-Dist: truststore (>=0.7,<0.11) ; python_version >= "3.10"

{suite_py-1.48.0 → suite_py-1.49.0}/pyproject.toml

@@ -2,7 +2,7 @@
 authors = ["larrywax, EugenioLaghi, michelangelomo <devops@prima.it>"]
 description = ""
 name = "suite-py"
-version = "1.48.0"
+version = "1.49.0"
 
 [tool.poetry.dependencies]
 Click = ">=7.0"
@@ -23,7 +23,7 @@ python = ">=3.8,<4.0"
 python-dateutil = ">=2.8.2"
 requests = ">=2.26.0"
 requests-toolbelt = ">=0.9.1"
-rich = "==14.1.0"
+rich = "==14.2.0"
 semver = "^3.0.4"
 termcolor = ">=1.1.0"
 truststore = {version = ">=0.7,<0.11", python = ">=3.10"}

{suite_py-1.48.0 → suite_py-1.49.0}/suite_py/__version__.py

@@ -1,2 +1,2 @@
 # -*- encoding: utf-8 -*-
-__version__ = "1.48.0"
+__version__ = "1.49.0"

{suite_py-1.48.0 → suite_py-1.49.0}/suite_py/cli.py

@@ -47,8 +47,10 @@ from suite_py.lib.config import Config
 from suite_py.lib.handler import git_handler as git
 from suite_py.lib.handler import prompt_utils
 from suite_py.lib.handler.captainhook_handler import CaptainHook
+from suite_py.lib.handler.git_handler import GitHandler
 from suite_py.lib.handler.okta_handler import Okta
 from suite_py.lib.handler.pre_commit_handler import PreCommit
+from suite_py.lib.handler.youtrack_handler import YoutrackHandler
 from suite_py.lib.tokens import Tokens
 
 # pylint: enable=wrong-import-position
@@ -176,17 +178,21 @@ def main(ctx, project, timeout, verbose):
     if timeout:
         config.user["captainhook_timeout"] = timeout
 
-    project = os.path.basename(project)
     tokens = Tokens()
     okta = Okta(config, tokens)
     captainhook = CaptainHook(config, okta, tokens)
+    project = os.path.basename(project)
+    git_handler = GitHandler(project, config)
+    youtrack_handler = YoutrackHandler(config, tokens)
 
     ctx.obj = Context(
+        captainhook=captainhook,
+        config=config,
+        git_handler=git_handler,
+        okta=okta,
         project=project,
         tokens=tokens,
-        okta=okta,
-        config=config,
-        captainhook=captainhook,
+        youtrack_handler=youtrack_handler,
     )
 
     ctx.obj.call(metrics.setup)
@@ -233,12 +239,27 @@ def bump(obj: Context, project: Optional[str] = None, version: Optional[str] = N
     is_flag=True,
     help="Stash uncommitted changes before creating the branch and reapply them afterward",
 )
+@click.option(
+    "--parent-branch",
+    type=click.STRING,
+    help="Parent branch to create the new branch from",
+)
+@click.option(
+    "--branch-name",
+    type=click.STRING,
+    help="Branch name template. Supports {card_id}, {type}, {summary} placeholders (ex. '{card_id}/{type}/{summary}')",
+)
 @click.pass_obj
 @catch_exceptions
-def cli_create_branch(obj, card, autostash):
+def cli_create_branch(obj, card, autostash, parent_branch, branch_name):
     from suite_py.commands.create_branch import CreateBranch
 
-    obj.call(CreateBranch, card=card, autostash=autostash).run()
+    obj.call(CreateBranch).run(
+        card_id=card,
+        autostash=autostash,
+        parent_branch=parent_branch,
+        branch_name=branch_name,
+    )
 
 
 @main.command("lock", help="Lock project on staging or prod")

{suite_py-1.48.0 → suite_py-1.49.0}/suite_py/commands/context.py

@@ -3,17 +3,21 @@ from inspect import signature
 
 from suite_py.lib.config import Config
 from suite_py.lib.handler.captainhook_handler import CaptainHook
+from suite_py.lib.handler.git_handler import GitHandler
 from suite_py.lib.handler.okta_handler import Okta
+from suite_py.lib.handler.youtrack_handler import YoutrackHandler
 from suite_py.lib.tokens import Tokens
 
 
 @dataclasses.dataclass
 class Context:
-    project: str
-    config: Config
     captainhook: CaptainHook
-    tokens: Tokens
+    config: Config
+    git_handler: GitHandler
     okta: Okta
+    project: str
+    tokens: Tokens
+    youtrack_handler: YoutrackHandler
 
     # Call the function to_call with kwargs, injecting fields from self as default arguments
     def call(self, to_call, **kwargs):

{suite_py-1.48.0 → suite_py-1.49.0}/suite_py/commands/create_branch.py

@@ -11,25 +11,37 @@ from suite_py.lib.handler.youtrack_handler import YoutrackHandler
 
 
 class CreateBranch:
-    def __init__(self, project, card, config, tokens, autostash=False):
-        self._project = project
-        self._card = card
+    def __init__(
+        self,
+        config,
+        git_handler: GitHandler,
+        youtrack_handler: YoutrackHandler,
+    ):
         self._config = config
-        self._youtrack = YoutrackHandler(config, tokens)
-        self._git = GitHandler(project, config)
-        self._autostash = autostash
+        self._git_handler = git_handler
+        self._youtrack = youtrack_handler
 
     @metrics.command("create-branch")
-    def run(self):
-        if not self._git.is_detached() and self._git.is_dirty() and not self._autostash:
+    def run(
+        self,
+        autostash=False,
+        branch_name=None,
+        card_id=None,
+        parent_branch=None,
+    ):
+        if (
+            not self._git_handler.is_detached()
+            and self._git_handler.is_dirty()
+            and not autostash
+        ):
             # Default behaviour is to pull when not detached.
             # Can't do that with uncommitted changes.
             logger.error("You have some uncommitted changes, I can't continue")
             sys.exit(-1)
 
         try:
-            if self._card:
-                issue = self._youtrack.get_issue(self._card)
+            if card_id:
+                issue = self._youtrack.get_issue(card_id)
             else:
                 issue = self._youtrack.get_issue(self._ask_card())
         except Exception:
@@ -38,7 +50,7 @@ class CreateBranch:
             )
             sys.exit(-1)
 
-        self._checkout_branch(issue, self._autostash)
+        self._checkout_branch(issue, autostash, parent_branch, branch_name)
 
         user = self._youtrack.get_current_user()
         self._youtrack.assign_to(issue["id"], user["login"])
@@ -95,33 +107,45 @@ class CreateBranch:
             )
             return []
 
-    def _checkout_branch(self, issue, autostash=False):
+    def _checkout_branch(
+        self, issue, autostash=False, parent_branch=None, branch_name_template=None
+    ):
         default_parent_branch_name = self._config.user.get(
-            "default_parent_branch", self._git.current_branch_name()
+            "default_parent_branch", self._git_handler.current_branch_name()
         )
 
-        parent_branch_name = prompt_utils.ask_questions_input(
-            "Insert initial branch: ", default_parent_branch_name
+        parent_branch_name = parent_branch or prompt_utils.ask_questions_input(
+            "Enter parent branch: ", default_parent_branch_name
         )
 
         full_branch_name = ""
         branch_name = _normalize_git_ref_segment(issue["summary"])
         branch_type = _normalize_git_ref_segment(issue["Type"])
 
-        while True:
-            branch_name = str(
-                prompt_utils.ask_questions_input("Enter branch name: ", branch_name)
+        if branch_name_template:
+            # Use the template and replace placeholders
+            full_branch_name = branch_name_template.format(
+                card_id=issue["idReadable"], type=branch_type, summary=branch_name
             )
 
-            full_branch_name = f"{issue['idReadable']}/{branch_type}/{branch_name}"
-            if is_branch_name_valid(full_branch_name):
-                break
+            if not is_branch_name_valid(full_branch_name):
+                logger.error(f"Invalid branch name from template: {full_branch_name}")
+                sys.exit(-1)
+        else:
+            while True:
+                branch_name = str(
+                    prompt_utils.ask_questions_input("Enter branch name: ", branch_name)
+                )
 
-            logger.error(f"Invalid branch name: {full_branch_name}. Try again?")
+                full_branch_name = f"{issue['idReadable']}/{branch_type}/{branch_name}"
+                if is_branch_name_valid(full_branch_name):
+                    break
 
-        self._git.checkout(parent_branch_name, autostash=autostash)
+                logger.error(f"Invalid branch name: {full_branch_name}. Try again?")
 
-        self._git.checkout(full_branch_name, new=True, autostash=autostash)
+        self._git_handler.checkout(parent_branch_name, autostash=autostash)
+
+        self._git_handler.checkout(full_branch_name, new=True, autostash=autostash)
 
 
 # Normalize a string into a valid segment(ie. the part of the branch name between the /)

{suite_py-1.48.0 → suite_py-1.49.0}/suite_py/commands/release.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 import re
 import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from suite_py.commands import common
 from suite_py.lib import logger, metrics
@@ -71,7 +72,6 @@ class Release:
         sha = self._resolve_target_sha(commits)
         self._create_release(new_version, message, sha)
 
-    # ---- helpers (extracted to reduce complexity of _create) ----
     def _gather_commits_and_version(self, latest):
         """Return (commits, new_version, base_message)."""
         if latest == "":
@@ -79,6 +79,11 @@ class Release:
 
         logger.info(f"The current release is {latest}")
         commits = self._github.get_commits_since_release(self._repo, latest)
+        if not commits:
+            logger.warning(
+                "No commits found after the latest release tag; nothing to release."
+            )
+            sys.exit(0)
         # If user did not pass a target commit, ask interactively which commit to release.
         # Only perform interactive selection if user explicitly requested it
         if self._interactive:
@@ -88,7 +93,7 @@ class Release:
         message = self._build_commits_message(commits)
         logger.info(f"\nCommits list:\n{message}\n")
         if not prompt_utils.ask_confirm("Do you want to continue?"):
-            sys.exit()  # Preserve previous early return semantics
+            sys.exit()
         new_version = self._version.select_new_version(latest, allow_prerelease=True)
         return commits, new_version, message
 
@@ -106,7 +111,7 @@ class Release:
         try:
             resolved_commit = self._repo.get_commit(self._commit)
             target_sha = resolved_commit.sha
-        except Exception:  # pragma: no cover
+        except Exception:
             logger.error(
                 f"The provided commit '{self._commit}' was not found in the repository."
             )
@@ -125,6 +130,8 @@ class Release:
                 "The specified commit is not part of the unreleased commits (i.e., not after the latest release)."
             )
             sys.exit(-1)
+        # We want ONLY the selected commit and the older commits (towards the previous release),
+        # excluding any *newer* commits that appear before it in the list.
         return commits[target_index:]
 
     def _select_commit_if_needed(self, commits):
@@ -137,22 +144,127 @@ class Release:
         """
         if self._commit or not commits:
             return
-        if len(commits) == 1:
-            # Only one unreleased commit; implicitly choose it.
-            self._commit = commits[0].sha
-            return
-        choices = [
-            {
-                "name": f"{c.sha[:8]} | {c.commit.message.splitlines()[0]}",
+
+        choices = []
+
+        def build_choice(c, icon):
+            summary = c.commit.message.splitlines()[0]
+            return {
+                "name": f"{icon} {c.sha[:8]} | {summary}",
                 "value": c.sha,
             }
-            for c in commits
-        ]
+
+        with ThreadPoolExecutor(max_workers=min(8, len(commits))) as executor:
+            future_map = {
+                executor.submit(self._get_commit_status_icon, c.sha): c for c in commits
+            }
+
+            icon_results = {}
+            for future in as_completed(future_map):
+                c = future_map[future]
+                try:
+                    icon_results[c.sha] = future.result()
+                except Exception:
+                    icon_results[c.sha] = "?"
+            for c in commits:
+                choices.append(build_choice(c, icon_results.get(c.sha, "?")))
+
+        subtitle = "(only one available)" if len(choices) == 1 else "(newest first):"
         selected = prompt_utils.ask_choices(
-            "Select commit to release (newest first):", choices
+            f"Select commit to release {subtitle}", choices
         )
         self._commit = selected
 
+    def _get_commit_status_icon(self, sha):
+        """Return an icon representing the simplified CI status for a commit.
+
+        Final exposed statuses (icons):
+          success (✅), failure (❌), in_progress (🏗️), cancelled (🚫), unknown (❓)
+
+        Everything else is folded into one of those buckets:
+          pending / queued / waiting -> in_progress
+          skipped / neutral -> unknown (unless at least one success present)
+        Preference order for determining state:
+          1. Check runs API
+          2. Combined status API
+          3. Fallback unknown
+        """
+        check_runs = self._safe_get_check_runs(sha)
+        state = self._classify_from_check_runs(check_runs) if check_runs else None
+        if state is None:
+            state = self._classify_from_combined_status(sha)
+        return self._icon_for_state(state)
+
+    def _safe_get_check_runs(self, sha):
+        try:
+            commit = self._repo.get_commit(sha)
+            return list(commit.get_check_runs())
+        except Exception:
+            return []
+
+    def _classify_from_check_runs(self, check_runs):
+        statuses = {r.status for r in check_runs if getattr(r, "status", None)}
+        conclusions = {
+            r.conclusion for r in check_runs if getattr(r, "conclusion", None)
+        }
+
+        if self._any_in_progress(statuses):
+            return "in_progress"
+        if self._any_failure(conclusions):
+            return "failure"
+        if "cancelled" in conclusions:
+            return "cancelled"
+        if self._is_success(conclusions):
+            return "success"
+        return "unknown"
+
+    @staticmethod
+    def _any_in_progress(statuses):
+        return any(
+            s in {"in_progress", "queued", "waiting", "pending"} for s in statuses
+        )
+
+    @staticmethod
+    def _any_failure(conclusions):
+        return any(
+            c in {"failure", "timed_out", "action_required", "stale"}
+            for c in conclusions
+        )
+
+    @staticmethod
+    def _is_success(conclusions):
+        return bool(conclusions) and (
+            all(c == "success" for c in conclusions)
+            or ("success" in conclusions and not Release._any_failure(conclusions))
+        )
+
+    def _classify_from_combined_status(self, sha):
+        try:
+            status = self._github.get_build_status(self._project, sha)
+            combined = (status.state or "unknown").lower()
+        except Exception:
+            combined = "unknown"
+        if combined in {"pending", "queued", "waiting", "in_progress"}:
+            return "in_progress"
+        if combined == "success":
+            return "success"
+        if combined == "failure":
+            return "failure"
+        if combined == "cancelled":
+            return "cancelled"
+        return "unknown"
+
+    @staticmethod
+    def _icon_for_state(state):
+        icon_mapping = {
+            "success": "✅",
+            "failure": "❌",
+            "in_progress": "🏗️",
+            "cancelled": "🚫",
+            "unknown": "❓",
+        }
+        return icon_mapping.get(state, "❓")
+
     @staticmethod
     def _build_commits_message(commits):
         return "\n".join(
@@ -179,7 +291,7 @@ class Release:
             return commits[0].commit.sha if commits else ""
         try:
             sha = self._repo.get_commit(self._commit).sha
-        except Exception:  # pragma: no cover
+        except Exception:
             logger.error(
                 f"Unable to resolve commit '{self._commit}' during release creation."
             )
@@ -189,13 +301,13 @@ class Release:
 
     def _validate_target_commit_not_tagged(self, sha):
         try:
-            for t in self._repo.get_tags():  # network call
+            for t in self._repo.get_tags():
                 if t.commit.sha == sha:
                     logger.error(
                         f"The commit {sha[:7]} is already tagged with {t.name}. Aborting."
                     )
                     sys.exit(-1)
-        except Exception:  # pragma: no cover
+        except Exception:
             logger.warning("Could not verify if commit already tagged; continuing.")
 
     def _create_release(self, new_version, message, commit):