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

qubership_pipelines_common_library/__init__.py

@@ -14,4 +14,4 @@
 
 import sys, os
 current_path = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, current_path)
+sys.path.insert(0, current_path)

qubership_pipelines_common_library/v1/artifactory_client.py

@@ -84,7 +84,7 @@ class ArtifactoryAPI:
     def get_files_list(self, artifact_path: str):
         try:
             response = self._get(f"{self.api_url}/api/storage/{artifact_path}?list&deep=1&listFolders=1").json()
-            return [ArtifactListEntry(uri=f['uri'], size=int(f['size']), folder=f['folder'] == True) for f in
+            return [ArtifactListEntry(uri=f['uri'], size=int(f['size']), folder=(f['folder'] is True)) for f in
                     response['files']]
         except requests.exceptions.HTTPError as error:
             raise ArtifactoryError from error

qubership_pipelines_common_library/v1/execution/exec_command.py

@@ -61,6 +61,8 @@ class ExecutionCommand:
     def run(self):
         """Runs command following its lifecycle"""
         try:
+            self._log_command_class_name()
+            self._log_border_line()
             self._log_input_params()
             if not self._validate():
                 logging.error(ExecutionCommand.FAILURE_MSG)
@@ -69,9 +71,17 @@ class ExecutionCommand:
             self._execute()
             self._post_execute()
             self._exit(True, ExecutionCommand.SUCCESS_MSG)
-        except Exception as e:
+        except Exception:
             logging.error(traceback.format_exc())
             self._exit(False, ExecutionCommand.FAILURE_MSG)
+        finally:
+            self._log_border_line()
+
+    def _log_command_class_name(self):
+        self.context.logger.info("command_class_name = %s", type(self).__name__)
+
+    def _log_border_line(self):
+        self.context.logger.info("=" * 60)
 
     def _log_input_params(self):
         self.context.logger.info(

qubership_pipelines_common_library/v1/execution/exec_context.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os, logging
+import os
 
 from pathlib import Path
 from qubership_pipelines_common_library.v1.utils.utils_file import UtilsFile
@@ -40,7 +40,7 @@ class ExecutionContext:
         self.__init_temp_folder()
         self.__init_logger()
         # load context from files
-        logging.info(f"""Execution context params:
+        self.logger.debug(f"""Execution context params:
             paths.logs: {self.context.get("paths.logs")}
             paths.temp: {self.context.get("paths.temp")}
             paths.input.params: {self.context.get("paths.input.params")}
@@ -55,10 +55,10 @@ class ExecutionContext:
     def output_params_save(self):
         """Stores output_param files to disk"""
         if self.context.get("paths.output.params"):
-            logging.info(f"Writing insecure param file '{self.context.get('paths.output.params')}'")
+            self.logger.info(f"Writing insecure param file '{self.context.get('paths.output.params')}'")
             self.output_params.save(self.context.get("paths.output.params"))
         if self.context.get("paths.output.params_secure"):
-            logging.info(f"Writing secure param file '{self.context.get('paths.output.params_secure')}'")
+            self.logger.info(f"Writing secure param file '{self.context.get('paths.output.params_secure')}'")
             self.output_params_secure.save(self.context.get("paths.output.params_secure"))
 
     def input_param_get(self, path, def_value=None):
@@ -85,13 +85,13 @@ class ExecutionContext:
             if not self.__validate_param(key):
                 valid = False
                 if not silent:
-                    logging.error(f"Parameter '{key}' is mandatory but not defined")
+                    self.logger.error(f"Parameter '{key}' is mandatory but not defined")
         return valid
 
     def __validate_param(self, name):
         try:
             return self.context.get(name) or self.input_param_get(name)  # or self.__dict__.get(name)
-        except:
+        except Exception:
             return False
 
     def __input_params_load(self):

qubership_pipelines_common_library/v1/execution/exec_context_file.py

@@ -141,7 +141,7 @@ class ExecutionContextFile:
                 logging.error(f"Incorrect apiVersion value: {self.content['apiVersion']} in file '{full_path}'. "
                               f"Only '{ExecutionContextFile.SUPPORTED_API_VERSIONS}' are supported")
                 self.init_empty()
-        except FileNotFoundError as e:
+        except FileNotFoundError:
             self.init_empty()
 
     def save(self, path):

qubership_pipelines_common_library/v1/execution/exec_logger.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import logging, os
+import logging
+import os
 
 
 class ExecutionLogger:
@@ -20,7 +21,8 @@ class ExecutionLogger:
     FILE_NAME_FULL = "full.log"
     EXECUTION_LOG_LEVEL = logging.INFO
     FULL_LOG_LEVEL = logging.DEBUG
-    DEFAULT_FORMAT = u'[%(asctime)s] [%(levelname)-5s] [class=%(filename)s:%(lineno)-3s] %(message)s'
+    DEFAULT_FORMAT = u'[%(asctime)s] [%(levelname)-7s] [class=%(filename)s:%(lineno)-3s] %(message)s'
+    LEVELNAME_COLORED_FORMAT = u'[%(asctime)s] [%(levelname_color_open_tag)s%(levelname)-7s%(levelname_color_close_tag)s] \\[class=%(filename)s:%(lineno)-3s] %(message)s'
 
     def __init__(self, path_logs):
         """
@@ -34,7 +36,9 @@ class ExecutionLogger:
         #  Also, file handlers are never removed
         self.path_logs = path_logs
         self.logger = logging.getLogger("execution_logger")
-        self.logger.setLevel(logging.DEBUG) # set to the lowest level to allow handlers to capture anything
+        self.logger.setLevel(logging.DEBUG)  # set to the lowest level to allow handlers to capture anything
+        self.logger.propagate = True
+
         if path_logs:
             # execution logs - only in local logger
             handler_exec = logging.FileHandler(os.path.join(path_logs, ExecutionLogger.FILE_NAME_EXECUTION))
@@ -46,9 +50,7 @@ class ExecutionLogger:
             handler_full = logging.FileHandler(os.path.join(path_logs, ExecutionLogger.FILE_NAME_FULL))
             handler_full.setLevel(ExecutionLogger.FULL_LOG_LEVEL)
             handler_full.setFormatter(logging.Formatter(ExecutionLogger.DEFAULT_FORMAT))
-            logging.getLogger().propagate = False
             logging.getLogger().addHandler(handler_full)
-        self.logger.propagate = True
 
     def info(self, msg, *args, **kwargs):
         self.logger.info(msg, *args, **kwargs)

qubership_pipelines_common_library/v1/github_client.py

@@ -152,7 +152,7 @@ class GithubClient:
                     logging.info(f"Workflow Run status: '{run.status}' is present in input break statuses list. Stop waiting.")
                     execution.stop()
                     break
-            except:
+            except Exception:
                 pass
             timeout += wait_seconds
             logging.info(f"Waiting workflow run execution timeout {wait_seconds} seconds")

qubership_pipelines_common_library/v1/gitlab_client.py

@@ -165,7 +165,7 @@ class GitlabClient:
                     logging.info(f"Pipeline status: '{pipeline.status}' contains in input break status list. Stop waiting.")
                     execution.stop()
                     break
-            except:
+            except Exception:
                 pass
             now = time.perf_counter()
             retries += 1
@@ -234,15 +234,19 @@ class GitlabClient:
                 if e.response_code == 404:
                     logging.warning(f"No artifacts for job {job_id}")
                     return None
-                else: raise
+                else:
+                    raise
         logging.info(f"Artifacts downloaded to {local_file}")
         return local_file
 
     @staticmethod
     def _cast_to_string(value) -> str:
-        if isinstance(value, str): return value
-        if value is None: return ''
-        if isinstance(value, bool): return 'true' if value else 'false'
+        if isinstance(value, str):
+            return value
+        if value is None:
+            return ''
+        if isinstance(value, bool):
+            return 'true' if value else 'false'
         return str(value)
 
     def _map_status(self, git_status: str, default_status: str):
@@ -323,7 +327,7 @@ class GitlabClient:
     def make_first_commit_to_gitlab_project(gitlab_url, gitlab_token, project_id, repo_branch):
         """"""
         import requests
-        logging.debug(f"Making first commit...")
+        logging.debug("Making first commit...")
         headers = {"PRIVATE-TOKEN": gitlab_token, "Content-Type": "application/json"}
         commit_payload = {
             "branch": repo_branch,
@@ -343,6 +347,6 @@ class GitlabClient:
             json=commit_payload
         )
         if response.status_code == 201:
-            logging.info(f"Commit successfull")
+            logging.info("Commit successfull")
         else:
             logging.error(f"Error {response.status_code}: {response.text}")

qubership_pipelines_common_library/v1/jenkins_client.py

@@ -12,14 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import logging, jenkins
+import logging, jenkins, time
 
-from time import sleep
 from pathlib import Path
 from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
+from qubership_pipelines_common_library.v1.utils.utils_file import UtilsFile
 
 
 class JenkinsClient:
+
     # statuses taken from https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/Result.java
     STATUS_SUCCESS = "SUCCESS"
     STATUS_UNSTABLE = "UNSTABLE"
@@ -27,15 +28,24 @@ class JenkinsClient:
     STATUS_ABORTED = "ABORTED"
     STATUS_NOT_BUILT = "NOT_BUILT"
 
-    STATUSES_COMPLETE = [STATUS_SUCCESS, STATUS_UNSTABLE, STATUS_FAILURE, STATUS_ABORTED, STATUS_NOT_BUILT]
+    BUILD_ARTIFACTS_ZIP_PATH = "*zip*/archive.zip"
 
     def __init__(self, host: str, user: str, password: str):
         """
+        This class is deprecated and will be removed in v3.0.0. Use class from v2 module instead.
         Arguments:
             host (str): Jenkins host URL
             user (str): User used in auth request
             password (str): Token used in auth request
         """
+        if self.__class__ == JenkinsClient:
+            import warnings
+            warnings.warn(
+                "v1.jenkins_client.JenkinsClient is deprecated since v2.0.0 and will be removed in v3.0.0. "
+                "Use v2.jenkins.jenkins_client.JenkinsClient instead.",
+                DeprecationWarning,
+                stacklevel=2
+            )
         self.url = host
         self.user = user
         self.token = password
@@ -63,13 +73,16 @@ class JenkinsClient:
                 if count < timeout_seconds:
                     logging.info("Job is not queued yet, waiting %s of %s", count, timeout_seconds)
                     count += wait_seconds
-                    sleep(wait_seconds)
+                    time.sleep(wait_seconds)
                     continue
                 else:
                     logging.error("Wasn't able to queue the job within %s seconds", timeout_seconds)
                     return execution
         count = 0
         build_id = 0
+        if timeout_seconds < 1:
+            logging.debug("Job put to queue, not fetching job id in async mode...")
+            return execution.start()
         while build_id == 0:
             try:
                 queue_info = self.server.get_queue_item(queue_id)
@@ -79,7 +92,7 @@ class JenkinsClient:
                 if count < timeout_seconds:
                     logging.info("Job is not started yet, waiting %s of %s", count, timeout_seconds)
                     count += 5
-                    sleep(5)
+                    time.sleep(5)
                     continue
                 else:
                     logging.error("Wasn't able to start job within %s seconds", timeout_seconds)
@@ -100,15 +113,24 @@ class JenkinsClient:
             logging.error("Can't get job result within %s seconds", timeout_seconds)
         return execution
 
-    def wait_pipeline_execution(self, execution: ExecutionInfo, timeout_seconds: float, wait_seconds: float = 1.0):
+    def wait_pipeline_execution(self, execution: ExecutionInfo, timeout_seconds: float = 180.0, wait_seconds: float = 1.0):
         """"""
-        count = 0
-        while count < timeout_seconds:
+        count_seconds = 0
+        last_log_time = time.perf_counter()
+        estimated_max_attempts = timeout_seconds // wait_seconds
+        retries = 0
+        while count_seconds < timeout_seconds:
             try:
                 build_info = self.server.get_build_info(execution.get_name(), execution.get_id(), depth=0)
                 logging.debug("Job info: %s", build_info)
                 build_result = build_info["result"]
-                if build_info["inProgress"] == False and build_result:
+
+                if "inProgress" in build_info: # Jenkins version >= 2.375. Use 'inProgress' property
+                    is_job_stopped = build_info["inProgress"] is False and build_result
+                else:                          # Jenkins version <= 2.369. Use 'building' property
+                    is_job_stopped = build_info["building"] is False and build_result
+
+                if is_job_stopped:
                     logging.info("Job is stopped with result '%s'", build_result)
                     build_url = build_info["url"]
                     build_status = self._map_status(build_result, ExecutionInfo.STATUS_UNKNOWN)
@@ -116,12 +138,15 @@ class JenkinsClient:
                     break
             except Exception:
                 execution.with_status(ExecutionInfo.STATUS_UNKNOWN)
-                logging.error("Failed to get information about jon with name '%s' and id '%s'",
-                              execution.get_name(), execution.get_id())
-            logging.info("Waiting job execution %s of %s", count, timeout_seconds)
-            count += wait_seconds
-            sleep(wait_seconds)
-        if count >= timeout_seconds:
+                logging.error("Failed to get information about job with name '%s' and id '%s'", execution.get_name(), execution.get_id())
+            now = time.perf_counter()
+            retries += 1
+            if now - last_log_time >= 10.0:
+                logging.info(f"Made [{retries} of {estimated_max_attempts}] retries. Waiting pipeline execution {count_seconds} of {timeout_seconds}")
+                last_log_time = now
+            count_seconds += wait_seconds
+            time.sleep(wait_seconds)
+        if count_seconds >= timeout_seconds:
             execution.with_status(ExecutionInfo.STATUS_TIMEOUT)
         return execution
 
@@ -132,7 +157,7 @@ class JenkinsClient:
         while count < timeout_seconds:
             logging.info("Waiting while job stop %s of %s", count, timeout_seconds)
             count += wait_seconds
-            sleep(wait_seconds)
+            time.sleep(wait_seconds)
         return execution.stop(ExecutionInfo.STATUS_ABORTED)
 
     def get_pipeline_execution_artifacts(self, execution: ExecutionInfo, timeout_seconds: float = 30.0, wait_seconds: float = 1.0):
@@ -149,7 +174,19 @@ class JenkinsClient:
     def save_pipeline_execution_artifact_to_file(self, execution: ExecutionInfo, artifact_path: str, file_path: str):
         """"""
         artifact_bytes = self.server.get_build_artifact_as_bytes(execution.get_name(), execution.get_id(), artifact_path)
-        Path(file_path).write_bytes(artifact_bytes)
+        UtilsFile.create_parent_dirs(file_path)
+        # Jenkins might return gzipped artifacts:
+        if len(artifact_bytes) >= 2 and artifact_bytes[0] == 0x1f and artifact_bytes[1] == 0x8b:
+            try:
+                import io, gzip
+                with gzip.GzipFile(fileobj=io.BytesIO(artifact_bytes)) as f:
+                    decompressed_bytes = f.read()
+                Path(file_path).write_bytes(decompressed_bytes)
+            except Exception as e:
+                logging.warning(f"Failed to decompress gzip, writing raw: {e}")
+                Path(file_path).write_bytes(artifact_bytes)
+        else:
+            Path(file_path).write_bytes(artifact_bytes)
 
     def _get_build_info(self, execution: ExecutionInfo, timeout_seconds: float = 30.0, wait_seconds: float = 1.0):
         count = 0
@@ -160,7 +197,7 @@ class JenkinsClient:
             except Exception:
                 logging.info("Can't get job result, waiting %s of %s", count, timeout_seconds)
                 count = count + wait_seconds
-                sleep(wait_seconds)
+                time.sleep(wait_seconds)
                 continue
         return None
 

qubership_pipelines_common_library/v1/maven_client.py

@@ -22,7 +22,7 @@ class Artifact:
     def from_string(artifact_str: str):
         parts = artifact_str.split(":")
         if len(parts) == 3:
-            group, artifact, version = parts[0], parts[1], parts[-1]
+            artifact, version = parts[1], parts[-1]
             return Artifact(artifact, version)
 
 
@@ -67,7 +67,7 @@ class MavenArtifactSearcher:
         if not artifact:
             artifact = Artifact(artifact_id=artifact_id, version=version, extension=extension)
         if not artifact.artifact_id or not artifact.version:
-            raise Exception(f"Artifact 'artifact_id' and 'version' must be specified!")
+            raise Exception("Artifact 'artifact_id' and 'version' must be specified!")
         logging.debug(f"Searching for '{artifact.artifact_id}' in {self.registry_url}...")
         return self._search_func(artifact=artifact)
 

qubership_pipelines_common_library/v1/minio_client.py

@@ -68,7 +68,7 @@ class MinioClient:
 
     def put_file(self, bucket_name: str, path: str, local_path: str):
         """"""
-        result = self.minio.fput_object(bucket_name, path, local_path)
+        self.minio.fput_object(bucket_name, path, local_path)
 
     def get_text_file_content(self, bucket_name: str, file_path: str):
         """"""

qubership_pipelines_common_library/v1/utils/rest.py

@@ -77,4 +77,4 @@ class RestClient:
                 return False
         except requests.RequestException as e:
             logging.error(f"Error: {e}")
-            return False
+            return False

qubership_pipelines_common_library/v1/utils/utils.py

@@ -47,4 +47,4 @@ def recursive_merge(source: dict, target: dict):
          source[key] = recursive_merge(source[key], value)
       else:
          source[key] = value
-   return source
+   return source

qubership_pipelines_common_library/v1/utils/utils_cli.py

@@ -1,14 +1,21 @@
+import logging
 import re
+
 import click
-import logging
-import sys, os
+from rich import box
+from rich.logging import RichHandler
+from rich.panel import Panel
+
 from qubership_pipelines_common_library.v1.execution.exec_logger import ExecutionLogger
+from qubership_pipelines_common_library.v1.utils.utils_logging import rich_console, ExtendedReprHighlighter, \
+    LevelColorFilter
 
 DEFAULT_CONTEXT_FILE_PATH = 'context.yaml'
 
 
 def utils_cli(func):
     """Decorator to add CLI options for logging level, context path and custom input params."""
+
     @click.option('--log-level', default='INFO', show_default=True,
                   type=click.Choice(['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], case_sensitive=False),
                   help="Set the logging level")
@@ -20,23 +27,50 @@ def utils_cli(func):
     @click.pass_context
     def wrapper(ctx, *args, log_level, **kwargs):
         ExecutionLogger.EXECUTION_LOG_LEVEL = getattr(logging, log_level.upper(), logging.INFO)
-        _configure_global_logger(logging.getLogger(), log_level, ExecutionLogger.DEFAULT_FORMAT)
+        _configure_global_logger(logging.getLogger(), log_level)
+        _print_command_name()
         _transform_kwargs(kwargs)
         return ctx.invoke(func, *args, **kwargs)
+
     return wrapper
 
 
-def _configure_global_logger(global_logger: logging.Logger, log_level: str, formatter_str: str):
+def _configure_global_logger(global_logger: logging.Logger, log_level: str):
     """Configure the global logger with a specific log level and formatter."""
-    log_level_value = getattr(logging, log_level.upper(), logging.INFO)
     global_logger.setLevel(logging.DEBUG)
     if global_logger.hasHandlers():
         global_logger.handlers.clear()
     global_logger.propagate = True
-    stdout_handler = logging.StreamHandler(sys.stdout)
-    stdout_handler.setLevel(log_level_value)
-    stdout_handler.setFormatter(logging.Formatter(formatter_str))
-    global_logger.addHandler(stdout_handler)
+    rich_handler = RichHandler(
+        console=rich_console,
+        show_time=False,
+        show_level=False,
+        show_path=False,
+        enable_link_path=False,
+        rich_tracebacks=True,
+        tracebacks_show_locals=False,
+        markup=True,
+        highlighter=ExtendedReprHighlighter(),
+    )
+    rich_handler.addFilter(LevelColorFilter())
+    rich_handler.setFormatter(logging.Formatter(ExecutionLogger.LEVELNAME_COLORED_FORMAT))
+    log_level_value = getattr(logging, log_level.upper(), logging.INFO)
+    rich_handler.setLevel(log_level_value)
+    global_logger.addHandler(rich_handler)
+
+
+def _print_command_name():
+    try:
+        click_context = click.get_current_context()
+        command_name = click_context.command.name or click_context.info_name
+    except RuntimeError:
+        logging.getLogger().warning("Can't find command name.")
+        command_name = ""
+
+    command_panel = Panel(f"command_name = {command_name}", expand=False, padding=(0, 1), box=box.ROUNDED)
+    rich_console.print()
+    rich_console.print(command_panel)
+    rich_console.print()
 
 
 def _transform_kwargs(kwargs):

qubership_pipelines_common_library/v1/utils/utils_dictionary.py

@@ -39,4 +39,4 @@ class UtilsDictionary:
             elif key not in curr:
                 curr[key] = {}
             curr = curr[key]
-        return input_dict
+        return input_dict

qubership_pipelines_common_library/v1/utils/utils_logging.py

@@ -0,0 +1,53 @@
+import logging
+
+from rich.console import Console
+from rich.highlighter import ReprHighlighter
+from rich.theme import Theme
+
+soft_theme = Theme({
+    "repr.number": "rgb(180,200,255)",
+    "repr.bool_true": "rgb(140,230,140)",
+    "repr.bool_false": "rgb(230,140,140)",
+    "repr.none": "rgb(200,200,200) italic",
+    "repr.path": "rgb(190,220,160)",
+    "repr.filename": "rgb(160,210,190)",
+    "repr.url": "rgb(130,180,255) underline",
+    "repr.uuid": "rgb(200,180,220)",
+    "repr.attrib_name": "rgb(220,200,130)",
+    "repr.attrib_value": "rgb(170,190,220)",
+    "repr.str": "rgb(140,180,140)",
+    "repr.tag_name": "rgb(200,170,220)",
+    "repr.tag_value": "rgb(170,200,220)",
+
+    "repr.time": "rgb(160,190,220) italic",
+})
+
+rich_console = Console(
+    theme=soft_theme,
+    force_terminal=True,
+    no_color=False,
+    highlight=True,
+    width=150,
+)
+
+level_colors = {
+    logging.DEBUG: "steel_blue",
+    logging.INFO: "light_sea_green",
+    logging.WARNING: "orange3",
+    logging.ERROR: "indian_red",
+    logging.CRITICAL: "bold medium_violet_red",
+}
+
+
+class LevelColorFilter(logging.Filter):
+    def filter(self, record):
+        color = level_colors.get(record.levelno, "default")
+        record.levelname_color_open_tag = f"[{color}]"
+        record.levelname_color_close_tag = "[/]"
+        return True
+
+
+class ExtendedReprHighlighter(ReprHighlighter):
+    highlights = ReprHighlighter.highlights + [
+        r"(?P<time>\b([01]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:[.,]\d{1,9})?\b)",
+    ]

qubership_pipelines_common_library/v2/artifacts_finder/artifact_finder.py

@@ -0,0 +1,56 @@
+import logging
+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 ArtifactFinder:
+    """
+    Allows searching for specific descriptor artifacts in different repositories without knowing full coordinates
+    (e.g. knowing only `artifact_id` and `version`, but not its `group_id`)
+
+    Supports different repository providers: Artifactory, Nexus, AWS, GCP, Azure
+
+    Provides different auth methods for Cloud Providers, implementing `CloudCredentialsProvider` interface
+
+    Start by initializing this client with one of implementations:
+    ``finder = ArtifactFinder(artifact_provider=ArtifactoryProvider(registry_url="https://our_url", username="user", password="password"))``
+
+    Then find your artifacts using
+    ``resource_urls = finder.find_artifact_urls(artifact_id='art_id', version='1.0.0', extension='json')``
+
+    Additionally, perform filtering of returned results (if you expect to find more than one artifact), and then download necessary artifacts with
+    ``finder.download_artifact(one_of_the_returned_resource_urls, './my_artifact.json')``
+
+    For more complex providers (e.g. AWS Code Artifact), you need to use specific Credential Providers
+    As an example:
+    ```
+    aws_creds = AwsCredentialsProvider().with_assume_role(...all the required params...).get_credentials()
+    aws_code_artifact_provider = AwsCodeArtifactProvider(creds=creds, domain='our_domain', project='our_project')
+    finder = ArtifactFinder(artifact_provider=aws_code_artifact_provider)
+    ```
+    """
+
+    def __init__(self, artifact_provider: ArtifactProvider, **kwargs):
+        if not artifact_provider:
+            raise Exception("Initialize ArtifactFinder with one of registry artifact providers first!")
+        self.provider = artifact_provider
+
+    def find_artifact_urls(self, artifact_id: str = None, version: str = None, group_id: str = None,
+                           extension: str = "jar", artifact: Artifact = None) -> list[str]:
+        if not artifact:
+            artifact = Artifact(group_id=group_id, artifact_id=artifact_id, version=version, extension=extension)
+        if not artifact.artifact_id or not artifact.version:
+            raise Exception("Artifact 'artifact_id' and 'version' must be specified!")
+        logging.debug(f"Searching for '{artifact.artifact_id}:{artifact.version}' in {self.provider.get_provider_name()}...")
+        return self.provider.search_artifacts(artifact=artifact)
+
+    def download_artifact(self, resource_url: str, local_path: str | Path, artifact: Artifact = None):
+        from qubership_pipelines_common_library.v1.utils.utils_file import UtilsFile
+        download_path = Path(local_path)
+        if artifact:
+            download_path = download_path.joinpath(artifact.get_filename())
+        UtilsFile.create_parent_dirs(download_path)
+        logging.debug(f"Downloading artifact from '{resource_url}' to '{download_path}'...")
+        return self.provider.download_artifact(resource_url=resource_url, local_path=download_path)