qubership-pipelines-common-library 2.0.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

qubership_pipelines_common_library/v2/artifacts_finder/providers/nexus.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact import Artifact
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact_provider import ArtifactProvider
+
+
+class NexusProvider(ArtifactProvider):
+
+    def __init__(self, registry_url: str, username: str = None, password: str = None, **kwargs):
+        """
+        Initializes this client to work with **Sonatype Nexus Repository** for maven artifacts.
+        Requires `username` and its `password` or `token`.
+        """
+        super().__init__(**kwargs)
+        self.registry_url = registry_url
+        if password:
+            from requests.auth import HTTPBasicAuth
+            self._session.auth = HTTPBasicAuth(username, password)
+
+    def download_artifact(self, resource_url: str, local_path: str | Path, **kwargs) -> None:
+        return self.generic_download(resource_url=resource_url, local_path=local_path)
+
+    def search_artifacts(self, artifact: Artifact, **kwargs) -> list[str]:
+        search_params = {
+            "maven.extension": artifact.extension,
+            "maven.artifactId": artifact.artifact_id,
+            **({"maven.groupId": artifact.group_id} if artifact.group_id else {}),
+        }
+        if artifact.is_snapshot():
+            search_params["maven.baseVersion"] = artifact.version
+        else:
+            search_params["version"] = artifact.version
+
+        response = self._session.get(url=f"{self.registry_url}/service/rest/v1/search/assets",
+                                     params=search_params,
+                                     timeout=self.timeout)
+        if response.status_code != 200:
+            raise Exception(f"Could not find '{artifact.artifact_id}' - search request returned {response.status_code}!")
+        return [result["downloadUrl"] for result in response.json()["items"]]
+
+    def get_provider_name(self) -> str:
+        return "nexus"

qubership_pipelines_common_library/v2/github/github_run_pipeline_command.py

@@ -102,9 +102,9 @@ class GithubRunPipeline(ExecutionCommand):
         self.pipeline_branch = self.context.input_param_get("params.pipeline_branch")
         self.pipeline_params = self.context.input_param_get("params.pipeline_params", {})
         if not self.pipeline_params:
-            self.context.logger.info(f"Pipeline parameters were not specified. This means that pipeline will be started with its default values")
+            self.context.logger.info("Pipeline parameters were not specified. This means that pipeline will be started with its default values")
         if not isinstance(self.pipeline_params, dict):
-            self.context.logger.error(f"Pipeline parameters were not loaded correctly. Probably mistake in the params definition")
+            self.context.logger.error("Pipeline parameters were not loaded correctly. Probably mistake in the params definition")
             return False
         self.import_artifacts = UtilsString.convert_to_bool(self.context.input_param_get("params.import_artifacts", False))
         self.success_statuses = [x.strip() for x in self.context.input_param_get("params.success_statuses", ExecutionInfo.STATUS_SUCCESS).split(",")]
@@ -165,7 +165,7 @@ class GithubRunPipeline(ExecutionCommand):
             self._exit(False, f"Status: {execution.get_status()}")
 
     def _save_execution_info(self, execution: ExecutionInfo):
-        self.context.logger.info(f"Writing GitHub workflow execution status")
+        self.context.logger.info("Writing GitHub workflow execution status")
         self.context.output_param_set("params.build.url", execution.get_url())
         self.context.output_param_set("params.build.id", execution.get_id())
         self.context.output_param_set("params.build.status", execution.get_status())

qubership_pipelines_common_library/v2/gitlab/custom_extensions.py

@@ -54,7 +54,7 @@ class GitlabModulesOpsPipelineDataImporter(PipelineDataImporter):
             self.context.logger.debug(f"Contents of folder {local_dirpath} (after zip.extractall): {os.listdir(local_dirpath)}")
             self._import_downloaded_data(local_dirpath / self.IMPORTED_CONTEXT_FILE)
         else:
-            self.context.logger.warning(f"No jobs found")
+            self.context.logger.warning("No jobs found")
 
         self.context.output_params.load(self.context.context.get("paths.output.params"))
         self.context.output_params_secure.load(self.context.context.get("paths.output.params_secure"))

qubership_pipelines_common_library/v2/gitlab/gitlab_run_pipeline_command.py

@@ -110,9 +110,9 @@ class GitlabRunPipeline(ExecutionCommand):
 
         self.pipeline_params = self.context.input_param_get("params.pipeline_params", {})
         if not self.pipeline_params:
-            self.context.logger.info(f"Pipeline parameters were not specified. This means that pipeline will be started with its default values")
+            self.context.logger.info("Pipeline parameters were not specified. This means that pipeline will be started with its default values")
         if not isinstance(self.pipeline_params, dict):
-            self.context.logger.error(f"Pipeline parameters were not loaded correctly. Probably mistake in the params definition")
+            self.context.logger.error("Pipeline parameters were not loaded correctly. Probably mistake in the params definition")
             return False
         self.import_artifacts = UtilsString.convert_to_bool(self.context.input_param_get("params.import_artifacts", False))
         self.success_statuses = [x.strip() for x in self.context.input_param_get("params.success_statuses", ExecutionInfo.STATUS_SUCCESS).split(",")]
@@ -129,7 +129,7 @@ class GitlabRunPipeline(ExecutionCommand):
             retry_timeout_seconds=self.retry_timeout_seconds,
             retry_wait_seconds=self.retry_wait_seconds
         )
-        self.context.logger.info(f"Successfully initialized GitLab client")
+        self.context.logger.info("Successfully initialized GitLab client")
 
         if not self.pipeline_branch:
             self.pipeline_branch = self.gl_client.get_default_branch(project_id=self.pipeline_path)
@@ -185,7 +185,7 @@ class GitlabRunPipeline(ExecutionCommand):
             self._exit(False, f"Status: {execution.get_status()}")
 
     def _save_execution_info(self, execution: ExecutionInfo):
-        self.context.logger.info(f"Writing GitLab pipeline execution status")
+        self.context.logger.info("Writing GitLab pipeline execution status")
         self.context.output_param_set("params.build.url", execution.get_url())
         self.context.output_param_set("params.build.id", execution.get_id())
         self.context.output_param_set("params.build.status", execution.get_status())

qubership_pipelines_common_library/v2/jenkins/custom_extensions.py

@@ -0,0 +1,63 @@
+from pathlib import Path
+
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommandExtension
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v2.extensions.pipeline_data_importer import PipelineDataImporter
+
+
+class JenkinsOutputParamsPipelineDataImporter(PipelineDataImporter):
+    """
+    Jenkins Output Params Importer:
+        imports data from contracted Declarative Pipelines
+        extracts output files and params of targeted pipeline into 'output' folder of this command
+    """
+    def import_pipeline_data(self, execution: ExecutionInfo) -> None:
+        self.context.logger.info("Processing jenkins job artifacts")
+        artifact_paths = self.command.jenkins_client.get_pipeline_execution_artifacts(execution)
+        if artifact_paths and len(artifact_paths):
+            for artifact_path in artifact_paths:
+                if artifact_path == "output/params.yaml":
+                    self.context.logger.info(f"Artifact with name '{artifact_path}' will be processed as output params")
+                    file_path = self.context.input_param_get("paths.output.params")
+                    self.command.jenkins_client.save_pipeline_execution_artifact_to_file(execution, artifact_path, file_path)
+                    self.context.output_params.load(file_path)
+                elif artifact_path == "output/params_secure.yaml":
+                    self.context.logger.info(f"Artifact with name '{artifact_path}' will be processed as output secure params")
+                    file_path = self.context.input_param_get("paths.output.params_secure")
+                    self.command.jenkins_client.save_pipeline_execution_artifact_to_file(execution, artifact_path, file_path)
+                    self.context.output_params_secure.load(file_path)
+                else:
+                    self.context.logger.info(f"Artifact with name '{artifact_path}' will be saved as output file")
+                    file_path = Path(self.context.input_param_get("paths.output.files")).joinpath(artifact_path)
+                    self.command.jenkins_client.save_pipeline_execution_artifact_to_file(execution, artifact_path, file_path)
+        else:
+            self.context.logger.info("No artifacts found in the job")
+
+
+class JenkinsSaveInjectedEnvVars(ExecutionCommandExtension):
+    """
+    Post-execution extension, saving injected environment variables from the build
+    """
+
+    INJECTED_ENV_VARS_URL = "injectedEnvVars/api/json"
+
+    def execute(self):
+        import os, requests
+        from requests.auth import HTTPBasicAuth
+
+        self.context.logger.info("Trying to get and save injected vars from build")
+        build_url = self.command.execution_info.get_url()
+        if build_url:
+            injected_api_url = build_url + self.INJECTED_ENV_VARS_URL
+            response = requests.get(injected_api_url,
+                                    auth=HTTPBasicAuth(self.context.input_param_get("systems.jenkins.username"),
+                                                       self.context.input_param_get("systems.jenkins.password")),
+                                    verify=True if os.getenv('PYTHONHTTPSVERIFY', '1') == '0' else False)
+
+            if response.status_code == 200:
+                self.context.output_param_set("params.build.injected_vars", response.json().get("envMap", {}))
+                self.context.output_params_save()
+            else:
+                self.context.logger.warning(f"Can't get injected variables for url {injected_api_url} with response code {response.status_code}")
+        else:
+            self.context.logger.warning("Can't get build url for injectedEnvVars")

qubership_pipelines_common_library/v2/jenkins/jenkins_client.py

@@ -0,0 +1,5 @@
+from qubership_pipelines_common_library.v1.jenkins_client import JenkinsClient as JenkinsClientV1
+
+
+class JenkinsClient(JenkinsClientV1):
+    pass

qubership_pipelines_common_library/v2/jenkins/jenkins_pipeline_data_importer.py

@@ -0,0 +1,31 @@
+import zipfile
+from pathlib import Path
+
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v2.extensions.pipeline_data_importer import PipelineDataImporter
+from qubership_pipelines_common_library.v2.jenkins.jenkins_client import JenkinsClient
+
+
+class DefaultJenkinsPipelineDataImporter(PipelineDataImporter):
+    """
+    Default Jenkins implementation:
+        downloads all available workflow run artifacts as one archive,
+        extracts them into context-defined 'paths.output.files' path
+    """
+    def import_pipeline_data(self, execution: ExecutionInfo) -> None:
+        self.context.logger.info("DefaultJenkinsPipelineDataImporter - importing pipeline data...")
+        artifact_paths = self.command.jenkins_client.get_pipeline_execution_artifacts(execution)
+        if artifact_paths:
+            self.context.logger.info(f"Job produced {len(artifact_paths)} artifact(s)")
+            self.command.jenkins_client.save_pipeline_execution_artifact_to_file(
+                execution,
+                JenkinsClient.BUILD_ARTIFACTS_ZIP_PATH,
+                self.context.path_temp / "archive.zip")
+        else:
+            self.context.logger.info("No artifacts found, skipping pipeline import.")
+
+        output_path = Path(self.context.input_param_get("paths.output.files"))
+        output_path.mkdir(parents=True, exist_ok=True)
+        for file_path in Path(self.context.path_temp).iterdir():
+            with zipfile.ZipFile(file_path) as zf:
+                zf.extractall(output_path)

qubership_pipelines_common_library/v2/jenkins/jenkins_run_pipeline_command.py

@@ -0,0 +1,165 @@
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommand
+from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v1.utils.utils_string import UtilsString
+from qubership_pipelines_common_library.v2.extensions.pipeline_data_importer import PipelineDataImporter
+from qubership_pipelines_common_library.v2.jenkins.jenkins_pipeline_data_importer import DefaultJenkinsPipelineDataImporter
+from qubership_pipelines_common_library.v2.jenkins.safe_jenkins_client import SafeJenkinsClient
+
+
+class JenkinsRunPipeline(ExecutionCommand):
+    """
+    Runs Jenkins Pipeline and optionally imports artifacts.
+
+    This command runs Jenkins Pipeline, monitors its execution, and provides
+    options for importing resulting artifacts and custom data processing through extensible
+    importers.
+
+    Input Parameters Structure (this structure is expected inside "input_params.params" block):
+    ```
+    {
+        "pipeline_path": "TENANT-NAME/path/to/job",              # REQUIRED: Full pipeline path (e.g. "TENANT/folder/job")
+        "pipeline_params": {                                     # OPTIONAL: Input parameters to pass to the pipeline
+            "KEY1": "VALUE1",                                    #     Side-note: if you want to run your parametrized job with default parameters,
+            "KEY2": "VALUE2"                                     #     you still need to pass some fake params (they will be ignored by Jenkins), e.g. "__fake_key":"fake_value",
+        },                                                       #     Otherwise, if this dict is empty - endpoint for non-parametrized jobs will be triggered
+        "import_artifacts": true,                                # OPTIONAL: Whether to import pipeline artifacts (default: true)
+        "use_existing_pipeline": 123456789,                      # OPTIONAL: Use existing pipeline ID instead of starting new one (debug feature)
+        "timeout_seconds": 1800,                                 # OPTIONAL: Maximum wait time for pipeline completion in seconds (default: 1800, 0 for async execution)
+        "wait_seconds": 1,                                       # OPTIONAL: Wait interval between status checks in seconds (default: 1)
+        "retry_timeout_seconds": 180,                            # OPTIONAL: Timeout for GitLab client initialization and pipeline start retries in seconds (default: 180)
+        "retry_wait_seconds": 1,                                 # OPTIONAL: Wait interval between retries in seconds (default: 1)
+        "success_statuses": "SUCCESS,UNSTABLE"                   # OPTIONAL: Comma-separated list of acceptable completion statuses (default: SUCCESS)
+    }
+    ```
+
+    Systems Configuration (expected in "systems.jenkins" block):
+    ```
+    {
+        "url": "https://github.com",                             # REQUIRED: Jenkins instance URL
+        "username": "<jenkins_user>"                             # REQUIRED: Jenkins user
+        "password": "<jenkins_token>"                            # REQUIRED: Jenkins password or token with job-triggering permissions
+    }
+    ```
+
+    Output Parameters:
+        - params.build.url: URL to view the pipeline run in GitLab
+        - params.build.id: ID of the executed pipeline
+        - params.build.status: Final status of the pipeline execution
+        - params.build.date: Workflow start time in ISO format
+        - params.build.duration: Total execution duration in human-readable format
+        - params.build.name: Name of the pipeline execution
+
+    Extension Points:
+        - Custom pipeline data importers can be implemented by extending PipelineDataImporter interface
+        - PipelineDataImporter is passed into constructor of command via "pipeline_data_importer" arg
+
+    Notes:
+        - Setting timeout_seconds to 0 enables asynchronous execution (workflow starts but command doesn't wait for completion, and won't fetch build id)
+    """
+
+    # default timeout values
+    WAIT_TIMEOUT = 1800
+    WAIT_SECONDS = 1
+    RETRY_TIMEOUT_SECONDS = 180
+    RETRY_WAIT_SECONDS = 1
+
+    PARAM_NAME_IS_DRY_RUN = "IS_DRY_RUN"
+
+    def __init__(self, *args, pipeline_data_importer: PipelineDataImporter = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.pipeline_data_importer = pipeline_data_importer or DefaultJenkinsPipelineDataImporter()
+        if pipeline_data_importer and not isinstance(pipeline_data_importer, PipelineDataImporter):
+            raise TypeError(f"Class {type(pipeline_data_importer)} must inherit from PipelineDataImporter")
+
+    def _validate(self):
+        names = [
+            "paths.input.params",
+            "paths.output.params",
+            "paths.output.files",
+            "systems.jenkins.url",
+            "systems.jenkins.username",
+            "systems.jenkins.password",
+            "params.pipeline_path",
+        ]
+        if not self.context.validate(names):
+            return False
+
+        self.timeout_seconds = max(0, int(self.context.input_param_get("params.timeout_seconds", self.WAIT_TIMEOUT)))
+        self.wait_seconds = max(1, int(self.context.input_param_get("params.wait_seconds", self.WAIT_SECONDS)))
+
+        self.retry_timeout_seconds = int(self.context.input_param_get("params.retry_timeout_seconds", self.RETRY_TIMEOUT_SECONDS))
+        self.retry_wait_seconds = int(self.context.input_param_get("params.retry_wait_seconds", self.RETRY_WAIT_SECONDS))
+
+        if self.timeout_seconds == 0:
+            self.context.logger.info(f"Timeout is set to: {self.timeout_seconds}. This means that the pipeline will be started asynchronously")
+
+        self.pipeline_path = self.context.input_param_get("params.pipeline_path").strip("/")
+        self.pipeline_params = self.context.input_param_get("params.pipeline_params", {})
+        if not self.pipeline_params:
+            self.context.logger.info("Pipeline parameters were not specified. This means that pipeline will be started with its default values")
+        if not isinstance(self.pipeline_params, dict):
+            self.context.logger.error("Pipeline parameters were not loaded correctly. Probably mistake in the params definition")
+            return False
+
+        self.success_statuses = [x.strip() for x in self.context.input_param_get("params.success_statuses", ExecutionInfo.STATUS_SUCCESS).split(",")]
+        if UtilsString.convert_to_bool(self.context.input_param_get("params.is_dry_run", False)):
+            self.pipeline_params[self.PARAM_NAME_IS_DRY_RUN] = True
+        self.import_artifacts = UtilsString.convert_to_bool(self.context.input_param_get("params.import_artifacts", True))
+        self.use_existing_pipeline = self.context.input_param_get("params.use_existing_pipeline")
+        return True
+
+    def _execute(self):
+        self.context.logger.info("Running jenkins-run-pipeline...")
+        self.jenkins_client = SafeJenkinsClient.create_jenkins_client(
+            self.context.input_param_get("systems.jenkins.url"),
+            self.context.input_param_get("systems.jenkins.username"),
+            self.context.input_param_get("systems.jenkins.password"),
+            retry_timeout_seconds=self.retry_timeout_seconds,
+            retry_wait_seconds=self.retry_wait_seconds
+        )
+        self.context.logger.info("Successfully initialized Jenkins client")
+
+        if self.use_existing_pipeline:  # work with existing job
+            self.context.logger.info(f"Using existing job {self.pipeline_path} - {self.use_existing_pipeline}")
+            execution = (ExecutionInfo().with_params(self.pipeline_params)
+                         .with_name(self.pipeline_path).with_id(int(self.use_existing_pipeline))
+                         .with_status(ExecutionInfo.STATUS_UNKNOWN))
+            execution.start()
+        else:
+            execution = self.jenkins_client.run_pipeline(
+                self.pipeline_path, self.pipeline_params,
+                timeout_seconds=self.timeout_seconds,
+                wait_seconds=self.wait_seconds
+            )
+
+        self.execution_info = execution
+        if execution.get_status() != ExecutionInfo.STATUS_IN_PROGRESS:
+            self._exit(False, f"Pipeline was not started. Status {execution.get_status()}")
+        elif self.timeout_seconds < 1:
+            self.context.logger.info("Pipeline was started in asynchronous mode. Pipeline status and artifacts will not be processed")
+            return
+
+        self.context.logger.info(f"Pipeline successfully started. Waiting {self.timeout_seconds} seconds for execution to complete")
+        execution = self.jenkins_client.wait_pipeline_execution(execution, self.timeout_seconds, self.wait_seconds)
+        self.context.logger.info(f"Pipeline status: {execution.get_status()}\nPipeline available at {execution.get_url()}")
+
+        if self.import_artifacts and self.pipeline_data_importer and execution.get_status() in ExecutionInfo.STATUSES_COMPLETE:
+            try:
+                self.pipeline_data_importer.with_command(self)
+                self.pipeline_data_importer.import_pipeline_data(execution)
+            except Exception as e:
+                self.context.logger.error(f"Exception during pipeline_data_importer execution: {e}")
+
+        self._save_execution_info(execution)
+        if execution.get_status() not in self.success_statuses:
+            self._exit(False, f"Status: {execution.get_status()}")
+
+    def _save_execution_info(self, execution: ExecutionInfo):
+        self.context.logger.info("Writing jenkins job execution status")
+        self.context.output_param_set("params.build.url", execution.get_url())
+        self.context.output_param_set("params.build.id", execution.get_id())
+        self.context.output_param_set("params.build.status", execution.get_status())
+        self.context.output_param_set("params.build.date", execution.get_time_start().isoformat())
+        self.context.output_param_set("params.build.duration", execution.get_duration_str())
+        self.context.output_param_set("params.build.name", execution.get_name())
+        self.context.output_params_save()

qubership_pipelines_common_library/v2/jenkins/safe_jenkins_client.py

@@ -0,0 +1,14 @@
+from qubership_pipelines_common_library.v2.jenkins.jenkins_client import JenkinsClient
+from qubership_pipelines_common_library.v2.utils.retry_decorator import RetryDecorator
+
+
+class SafeJenkinsClient(JenkinsClient):
+
+    def __init__(self, host: str, user: str, password: str):
+        super().__init__(host, user, password)
+
+    @classmethod
+    @RetryDecorator(condition_func=lambda result: result is not None)
+    def create_jenkins_client(cls, host: str, user: str, password: str,
+                              retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1):
+        return cls(host, user, password)

qubership_pipelines_common_library/v2/podman/podman_command.md

@@ -135,6 +135,7 @@ To install and use `podman run` in your Dockerimage (`python:3.11-slim` was used
 ### GitHub
 
 1. `apt-get install podman nftables fuse-overlayfs`
+
 2. ```bash
     RUN cat <<EOF > /etc/containers/storage.conf
     [storage]
@@ -145,8 +146,10 @@ To install and use `podman run` in your Dockerimage (`python:3.11-slim` was used
     mount_program = "/usr/bin/fuse-overlayfs"
     EOF
     ```
+
 3. In your workflow file, need to pass `--privileged` option
-    ```
+
+    ```yaml
    jobs:
       execute-pipeline:
         runs-on: ubuntu-latest
@@ -154,11 +157,13 @@ To install and use `podman run` in your Dockerimage (`python:3.11-slim` was used
           image: ghcr.io/netcracker/qubership-pipelines-declarative-executor:dev_podman_engine
           options: --privileged
     ```
+
 4. Need to run `PodmanRunImage` command with additional flags: `"additional_run_flags": "--cgroups=disabled"`
 
 ### GitLab
 
 1. `apt-get install podman nftables slirp4netns fuse-overlayfs`
+
 2. ```bash
     RUN cat <<EOF > /etc/containers/storage.conf
     [storage]
@@ -169,4 +174,5 @@ To install and use `podman run` in your Dockerimage (`python:3.11-slim` was used
     mount_program = "/usr/bin/fuse-overlayfs"
     EOF
     ```
+
 3. Need to run `PodmanRunImage` command with additional flags: `"additional_run_flags": "--cgroups=disabled --network slirp4netns"`

qubership_pipelines_common_library/v2/podman/podman_command.py

@@ -211,14 +211,14 @@ class PodmanRunImage(ExecutionCommand):
                 import json
                 with open(file_path, 'r', encoding='utf-8') as f:
                     return json.load(f)
-            except:
+            except Exception:
                 pass
 
             try:
                 import yaml
                 with open(file_path, 'r', encoding='utf-8') as f:
                     return yaml.safe_load(f)
-            except:
+            except Exception:
                 pass
 
             try:
@@ -230,7 +230,7 @@ class PodmanRunImage(ExecutionCommand):
                             key, value = line.split('=', 1)
                             key_values[key.strip()] = value.strip()
                 return key_values if key_values else None
-            except:
+            except Exception:
                 pass
 
             with open(file_path, 'r', encoding='utf-8') as f:
@@ -292,7 +292,7 @@ class PodmanRunImage(ExecutionCommand):
             raise
 
         except PodmanException:
-            self.context.logger.error(f"Container exited with unexpected exitcode")
+            self.context.logger.error("Container exited with unexpected exitcode")
             raise
 
         except Exception as e:

qubership_pipelines_common_library/v2/sops/sops_client.py

@@ -88,7 +88,7 @@ class SopsClient:
         Returns:
             path to generated `.sops.yaml`
         """
-        self.logger.debug(f"Preparing sops config for encryption")
+        self.logger.debug("Preparing sops config for encryption")
         sops_config_content = {
             "creation_rules": [
                 {
@@ -111,6 +111,6 @@ class SopsClient:
         Returns:
 
         """
-        self.logger.debug(f"Removing sops config")
+        self.logger.debug("Removing sops config")
         if sops_config_folder.exists() and sops_config_folder.is_dir():
             shutil.rmtree(sops_config_folder)

qubership_pipelines_common_library/v2/utils/retry_decorator.py

@@ -25,7 +25,7 @@ class RetryDecorator:
             last_result = None
             estimated_max_attempts = self.retry_timeout_seconds // self.retry_wait_seconds
 
-            
+
             while count_seconds < self.retry_timeout_seconds and not self.condition_func(last_result):
                 try:
                     last_result = func(*args, **kwargs)
@@ -41,7 +41,7 @@ class RetryDecorator:
                         last_log_time = now
                     else:
                         time.sleep(self.retry_wait_seconds)
-                    
+
                 except Exception as e:
                     retries += 1
                     now = time.perf_counter()
@@ -50,14 +50,14 @@ class RetryDecorator:
                         last_log_time = now
                     else:
                         time.sleep(self.retry_wait_seconds)
-                
+
                 finally:
                     count_seconds += self.retry_wait_seconds
 
             if self.condition_func(last_result):
                 self.logger.debug(f"Function {func.__name__} successfully executed after {retries} attempts in {count_seconds}s")
                 return last_result
-            
+
             self._exit_with_error_message(func.__name__)
         return wrapper
 
@@ -80,7 +80,7 @@ class RetryDecorator:
         else:
             self.logger.debug(
                 f"`retry_wait_seconds` is not found in func {func.__name__} arguments. Using default value = {self.retry_wait_seconds}")
-    
+
     def _process_exception_during_func_execution(self, exception, count_seconds, func_name, retries, estimated_max_attempts):
         if count_seconds < self.retry_timeout_seconds:
             self._sleep_with_warning_log(

{qubership_pipelines_common_library-2.0.0.dist-info → qubership_pipelines_common_library-2.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubership-pipelines-common-library
-Version: 2.0.0
+Version: 2.0.2
 Summary: Qubership Pipelines common library
 License: Apache-2.0
 License-File: LICENSE
@@ -24,6 +24,7 @@ Requires-Dist: python-gitlab (>=4.13.0,<5.0.0)
 Requires-Dist: python-jenkins (>=1.8.2,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: rich (>=14.2.0,<15.0.0)
 Requires-Dist: urllib3 (>=2.2.3,<3.0.0)
 Requires-Dist: webexpythonsdk (==2.0.1)
 Description-Content-Type: text/markdown
@@ -37,7 +38,7 @@ Description-Content-Type: text/markdown
 
 Open-source python library of clients used by Qubership pipelines/modules.
 
-Library provides easy-to-use clients and wrappers for common devops services (e.g. Jenkins, MiniO, GitLab Pipelines)
+Library provides easy-to-use clients and wrappers for common DevOps services (e.g. Jenkins, MiniO, GitLab Pipelines)
 
 ## Sample implementation
 
@@ -49,7 +50,7 @@ It includes reference python implementation along with the [Development Guide](h
 
 Library is presented as a set of clients with predefined operations
 
-Auto-generated reference (via mkdocs) is available on [this repo's GitHub Pages](https://netcracker.github.io/qubership-pipelines-common-python-library) 
+Auto-generated reference (via mkdocs) is available on [this repo's GitHub Pages](https://netcracker.github.io/qubership-pipelines-common-python-library/mkdocs)
 
 ## Installation
 
@@ -61,6 +62,7 @@ Auto-generated reference (via mkdocs) is available on [this repo's GitHub Pages]
   ```
 
 - Or you can install it via `pip`:
+
   ```bash
   pip install qubership-pipelines-common-library
   ```