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

qubership_pipelines_common_library/v2/artifacts_finder/auth/aws_credentials.py

@@ -0,0 +1,106 @@
+import boto3
+
+from enum import StrEnum
+from botocore.config import Config
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials_provider import CloudCredentialsProvider
+
+
+class AwsCredentialsProvider(CloudCredentialsProvider):
+
+    DEFAULT_ROLE_SESSION_NAME = "codeartifact-session"
+
+    access_key: str
+    secret_key: str
+    session_token: str
+    region_name: str
+    role_arn: str
+    role_session_name: str
+    _auth_type = None
+
+    class AuthType(StrEnum):
+        DIRECT = 'DIRECT'
+        ASSUME_ROLE = 'ASSUME_ROLE'
+
+    def with_direct_credentials(self,
+                                access_key: str,
+                                secret_key: str,
+                                region_name: str,
+                                session_token: str | None = None,
+                                ):
+        self.access_key = access_key
+        self.secret_key = secret_key
+        self.session_token = session_token
+        self.region_name = region_name
+        self.validate_mandatory_attrs(["access_key", "secret_key", "region_name"])
+        self._auth_type = self.AuthType.DIRECT
+        return self
+
+    def with_assume_role(self,
+                         access_key: str,
+                         secret_key: str,
+                         region_name: str,
+                         role_arn: str,
+                         role_session_name: str | None = DEFAULT_ROLE_SESSION_NAME,
+                         ):
+        self.access_key = access_key
+        self.secret_key = secret_key
+        self.region_name = region_name
+        self.role_arn = role_arn
+        self.role_session_name = role_session_name
+        self.validate_mandatory_attrs(["access_key", "secret_key", "region_name", "role_arn", "role_session_name"])
+        self._auth_type = self.AuthType.ASSUME_ROLE
+        return self
+
+    def get_credentials(self) -> Credentials:
+        if self._auth_type is self.AuthType.DIRECT:
+            return self._get_direct_credentials()
+        elif self._auth_type is self.AuthType.ASSUME_ROLE:
+            return self._get_assume_role_credentials()
+        else:
+            raise ValueError("Need to initialize this provider with AuthType via .with_*auth_type* method first!")
+
+    def get_ecr_authorization_token(self) -> str:
+        creds = self.get_credentials()
+        ecr_client = boto3.client(
+            service_name="ecr",
+            config=Config(region_name=self.region_name),
+            aws_access_key_id=creds["access_key"],
+            aws_secret_access_key=creds["secret_key"],
+            aws_session_token=creds["session_token"],
+        )
+        ecr_authorization_token = ecr_client.get_authorization_token()
+        ecr_authorization_data = ecr_authorization_token["authorizationData"][0]
+        return ecr_authorization_data["authorizationToken"]
+
+    def _get_direct_credentials(self) -> Credentials:
+        return Credentials(
+            access_key=self.access_key,
+            secret_key=self.secret_key,
+            session_token=self.session_token,
+            region_name=self.region_name,
+        )
+
+    def _get_assume_role_credentials(self) -> Credentials:
+        creds = self._assume_role()
+        return Credentials(
+            access_key=creds["AccessKeyId"],
+            secret_key=creds["SecretAccessKey"],
+            session_token=creds["SessionToken"],
+            role_arn=self.role_arn,
+            role_session_name=self.role_session_name,
+            region_name=self.region_name,
+        )
+
+    def _assume_role(self) -> dict:
+        sts_client = boto3.client(
+            service_name="sts",
+            config=Config(region_name=self.region_name),
+            aws_access_key_id=self.access_key,
+            aws_secret_access_key=self.secret_key,
+        )
+        assumed = sts_client.assume_role(
+            RoleArn=self.role_arn,
+            RoleSessionName=self.role_session_name,
+        )
+        return assumed["Credentials"]

qubership_pipelines_common_library/v2/artifacts_finder/auth/azure_credentials.py

@@ -0,0 +1,72 @@
+import requests
+
+from enum import StrEnum
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials_provider import CloudCredentialsProvider
+
+
+class AzureCredentialsProvider(CloudCredentialsProvider):
+
+    tenant_id: str
+    client_id: str
+    client_secret: str
+    target_resource: str
+    _auth_data: dict
+    _auth_type = None
+
+    class AuthType(StrEnum):
+        OAUTH2 = 'OAUTH2'
+
+    def with_oauth2(self,
+                    tenant_id: str,
+                    client_id: str,
+                    client_secret: str,
+                    target_resource: str,
+                    ):
+        self.tenant_id = tenant_id
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.target_resource = target_resource
+        self.validate_mandatory_attrs(["tenant_id", "client_id", "client_secret", "target_resource"])
+        self._auth_data = {
+            "grant_type": "client_credentials",
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "scope": f"{target_resource}/.default"
+        }
+        self._auth_type = self.AuthType.OAUTH2
+        return self
+
+    def with_oauth2_custom_data(self,
+                                tenant_id: str,
+                                custom_auth_data: dict,
+                                ):
+        self.tenant_id = tenant_id
+        self._auth_data = custom_auth_data
+        self.validate_mandatory_attrs(["tenant_id", "_auth_data"])
+        self._auth_type = self.AuthType.OAUTH2
+        return self
+
+    def get_credentials(self) -> Credentials:
+        if self._auth_type is self.AuthType.OAUTH2:
+            return self._get_oauth2_credentials()
+        else:
+            raise ValueError("Need to initialize this provider with AuthType via .with_*auth_type* method first!")
+
+    def _get_oauth2_credentials(self) -> Credentials:
+        token_url = f"https://login.microsoftonline.com/{self.tenant_id}/oauth2/v2.0/token"
+        response = requests.post(
+            token_url,
+            data=self._auth_data,
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+        )
+        response.raise_for_status()
+        response_json = response.json()
+        access_token = response_json.get("access_token")
+        if not access_token:
+            raise Exception(f"Failed to get access token from {token_url}: {response_json}")
+
+        return Credentials(
+            access_token=access_token,
+            tenant_id=self.tenant_id,
+        )

qubership_pipelines_common_library/v2/artifacts_finder/auth/gcp_credentials.py

@@ -0,0 +1,88 @@
+import json
+from enum import StrEnum
+from pathlib import Path
+
+from google.auth.transport.requests import AuthorizedSession, Request
+
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials_provider import CloudCredentialsProvider
+
+
+class GcpCredentialsProvider(CloudCredentialsProvider):
+
+    DEFAULT_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"]
+    DEFAULT_SUBJECT_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:jwt"
+
+    service_account_key_content: str
+    oidc_credential_source: dict
+    audience: str
+    scopes: list[str]
+    subject_token_type: str
+    _auth_type = None
+
+    class AuthType(StrEnum):
+        SA_KEY = 'SA_KEY'
+        OIDC_CREDS = 'OIDC_CREDS'
+
+    def with_service_account_key(self,
+                                 service_account_key_content: str | None = None,
+                                 service_account_key_path: str | Path | None = None,
+                                 scopes: list[str] = None,
+                                 ):
+        if scopes is None:
+            scopes = self.DEFAULT_SCOPES
+        self.scopes = scopes
+        self.service_account_key_content = service_account_key_content
+        if service_account_key_path:
+            with open(service_account_key_path, 'r') as key_file:
+                self.service_account_key_content = key_file.read()
+        self.validate_mandatory_attrs(["service_account_key_content"])
+        self._auth_type = self.AuthType.SA_KEY
+        return self
+
+    def with_oidc_creds(self,
+                        oidc_credential_source: dict,
+                        audience: str,
+                        oidc_token_file_path: str = None,
+                        subject_token_type: str = DEFAULT_SUBJECT_TOKEN_TYPE,
+                        scopes: list[str] = None,
+                        ):
+        if scopes is None:
+            scopes = self.DEFAULT_SCOPES
+        self.scopes = scopes
+        self.oidc_credential_source = oidc_credential_source
+        if oidc_token_file_path:
+            self.oidc_credential_source = {"file": oidc_token_file_path}
+        self.audience = audience
+        self.subject_token_type = subject_token_type
+        self.validate_mandatory_attrs(["oidc_credential_source", "audience"])
+        self._auth_type = self.AuthType.OIDC_CREDS
+        return self
+
+    def get_credentials(self) -> Credentials:
+        if self._auth_type == self.AuthType.SA_KEY:
+            from google.oauth2 import service_account
+            google_creds = service_account.Credentials.from_service_account_info(
+                info=json.loads(self.service_account_key_content),
+                scopes=self.scopes,
+            )
+        elif self._auth_type == self.AuthType.OIDC_CREDS:
+            from google.auth import identity_pool
+            google_creds = identity_pool.Credentials(
+                audience=self.audience,
+                subject_token_type=self.subject_token_type,
+                credential_source=self.oidc_credential_source,
+                scopes=self.scopes,
+            )
+        else:
+            raise ValueError("Need to initialize this provider with AuthType via .with_*auth_type* method first!")
+
+        google_creds.refresh(Request())
+        creds = Credentials(
+            google_credentials_object=google_creds,
+            gcp_authorization_token=google_creds.token, # It can be used in Basic Authorization (in some Execution Commands)
+            authorized_session=AuthorizedSession(credentials=google_creds),
+        )
+        if self._auth_type == self.AuthType.SA_KEY:
+            creds.service_account_key_content = self.service_account_key_content
+        return creds

qubership_pipelines_common_library/v2/artifacts_finder/model/artifact.py

@@ -0,0 +1,20 @@
+class Artifact:
+    def __init__(self, group_id = None, artifact_id = None, version = None, extension='jar'):
+        self.group_id = group_id
+        self.artifact_id = artifact_id
+        self.version = version
+        self.extension = "jar" if not extension else extension
+
+    def is_snapshot(self):
+        return self.version and self.version.endswith("SNAPSHOT")
+
+    def get_filename(self) -> str:
+        return f"{self.artifact_id}-{self.version}.{self.extension}"
+
+    @staticmethod
+    def from_string(artifact_str: str):
+        parts = artifact_str.split(":")
+        if len(parts) == 3:
+            group, artifact, version = parts[0], parts[1], parts[-1]
+            return Artifact(group, artifact, version)
+        raise Exception("Invalid artifact string")

qubership_pipelines_common_library/v2/artifacts_finder/model/artifact_provider.py

@@ -0,0 +1,35 @@
+import requests
+
+from pathlib import Path
+from abc import ABC, abstractmethod
+from qubership_pipelines_common_library.v2.artifacts_finder.model.artifact import Artifact
+
+
+class ArtifactProvider(ABC):
+    """Base class for all artifact providers"""
+
+    TIMESTAMP_VERSION_PATTERN = "^(.*-)?([0-9]{8}\\.[0-9]{6}-[0-9]+)$"
+
+    def __init__(self, params: dict = None, **kwargs):
+        self.params = params if params else {}
+        self._session = requests.Session()
+        self._session.verify = self.params.get('verify', True)
+        self.timeout = self.params.get('timeout', None)
+
+    def generic_download(self, resource_url: str, local_path: str | Path):
+        response = self._session.get(url=resource_url, timeout=self.timeout)
+        response.raise_for_status()
+        with open(local_path, 'wb') as file:
+            file.write(response.content)
+
+    @abstractmethod
+    def download_artifact(self, resource_url: str, local_path: str | Path, **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    def search_artifacts(self, artifact: Artifact, **kwargs) -> list[str]:
+        pass
+
+    @abstractmethod
+    def get_provider_name(self) -> str:
+        pass

qubership_pipelines_common_library/v2/artifacts_finder/model/credentials.py

@@ -0,0 +1,16 @@
+class Credentials(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.__dict__ = self  # allow attribute access
+
+    def __getitem__(self, key):
+        return self.get(key)
+
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            return None
+
+    def __setattr__(self, key, value):
+        self[key] = value

qubership_pipelines_common_library/v2/artifacts_finder/model/credentials_provider.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+
+
+class CloudCredentialsProvider(ABC):
+    """Base class for all cloud credentials"""
+
+    @abstractmethod
+    def get_credentials(self) -> Credentials:
+        pass
+
+    def validate_mandatory_attrs(self, attrs_names) -> None:
+        missing_attrs = [attr for attr in attrs_names if getattr(self, attr, None) is None]
+        if missing_attrs:
+            raise ValueError(f"The following mandatory attributes are not set: {', '.join(missing_attrs)}")

qubership_pipelines_common_library/v2/artifacts_finder/providers/artifactory.py

@@ -0,0 +1,52 @@
+import logging
+import re
+
+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 ArtifactoryProvider(ArtifactProvider):
+
+    def __init__(self, registry_url: str, username: str = None, password: str = None, **kwargs):
+        """
+        Initializes this client to work with **JFrog Artifactory** maven repositories.
+        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]:
+        timestamp_version_match = re.match(self.TIMESTAMP_VERSION_PATTERN, artifact.version)
+        if timestamp_version_match:
+            base_version = timestamp_version_match.group(1) + "SNAPSHOT"
+        else:
+            base_version = artifact.version
+
+        search_params = {
+            **({"g": artifact.group_id} if artifact.group_id else {}),
+            "a": artifact.artifact_id,
+            "v": base_version,
+            "specific": "true"
+        }
+        search_api_url = f"{self.registry_url}/api/search/gavc"
+        logging.debug(f"Search URL: {search_api_url}"f"\nSearch Parameters: {search_params}")
+
+        response = self._session.get(url=search_api_url,
+                                     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["downloadUri"] for result in response.json()["results"]
+                if result["ext"] == artifact.extension
+                and (not timestamp_version_match or result["downloadUri"].endswith(f"{artifact.version}.{artifact.extension}"))]
+
+    def get_provider_name(self) -> str:
+        return "artifactory"

qubership_pipelines_common_library/v2/artifacts_finder/providers/aws_code_artifact.py

@@ -0,0 +1,79 @@
+import logging
+import boto3
+
+from pathlib import Path
+from botocore.config import Config
+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
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+
+
+class AwsCodeArtifactProvider(ArtifactProvider):
+
+    def __init__(self, credentials: Credentials, domain: str, repository: str, package_format: str = "generic", **kwargs):
+        """
+        Initializes this client to work with **AWS Code Artifact** for generic or maven artifacts.
+        Requires `Credentials` provided by `AwsCredentialsProvider`.
+        """
+        super().__init__(**kwargs)
+        self._credentials = credentials
+        self._domain = domain
+        self._repository = repository
+        self._format = package_format
+        self._aws_client = boto3.client(
+            service_name='codeartifact',
+            config=Config(region_name=credentials.region_name),
+            aws_access_key_id=credentials.access_key,
+            aws_secret_access_key=credentials.secret_key,
+            aws_session_token=credentials.session_token,
+        )
+
+    def download_artifact(self, resource_url: str, local_path: str | Path, **kwargs) -> None:
+        """ 'resource_url' is actually AWS-specific resource_id, expected to be "namespace/package/version/asset_name" """
+        asset_parts = resource_url.split("/")
+        response = self._aws_client.get_package_version_asset(
+            domain=self._domain, repository=self._repository,
+            format=self._format, namespace=asset_parts[0],
+            package=asset_parts[1], packageVersion=asset_parts[2],
+            asset=asset_parts[3]
+        )
+        with open(local_path, 'wb') as file:
+            file.write(response.get('asset').read())
+
+    def search_artifacts(self, artifact: Artifact, **kwargs) -> list[str]:
+        list_packages_response = self._aws_client.list_packages(
+            domain=self._domain, repository=self._repository,
+            format=self._format, packagePrefix=artifact.artifact_id
+        )
+        logging.debug(f"list_packages_response: {list_packages_response}")
+
+        namespaces = [package.get('namespace') for package in list_packages_response.get('packages')
+                      if package.get('package') == artifact.artifact_id]
+        logging.debug(f"namespaces: {namespaces}")
+
+        if not namespaces:
+            logging.warning(f"Found no packages with artifactId = {artifact.artifact_id}!")
+            return []
+        if len(namespaces) > 1:
+            logging.warning(f"Found multiple namespaces with same artifactId = {artifact.artifact_id}:\n{namespaces}")
+
+        results = []
+        for namespace in namespaces:
+            try:
+                assets_response = self._aws_client.list_package_version_assets(
+                    domain=self._domain, repository=self._repository,
+                    format=self._format, package=artifact.artifact_id,
+                    packageVersion=artifact.version, namespace=namespace
+                )
+                logging.debug(f"assets: {assets_response}")
+                for asset in assets_response.get('assets'):
+                    if asset.get('name').lower().endswith(artifact.extension.lower()):
+                        results.append(f"{assets_response.get('namespace')}/{assets_response.get('package')}/"
+                                       f"{assets_response.get('version')}/{asset.get('name')}")
+            except Exception:
+                logging.warning(f"Specific version ({artifact.version}) of package ({namespace}.{artifact.artifact_id}) not found!")
+        logging.info(f"AWS search results: {results}")
+        return results
+
+    def get_provider_name(self) -> str:
+        return "aws_code_artifact"

qubership_pipelines_common_library/v2/artifacts_finder/providers/azure_artifacts.py

@@ -0,0 +1,98 @@
+import logging
+import re
+
+from pathlib import Path
+from requests.auth import HTTPBasicAuth
+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
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+
+
+class AzureArtifactsProvider(ArtifactProvider):
+
+    def __init__(self, credentials: Credentials, organization: str, project: str, feed: str, **kwargs):
+        """
+        Initializes this client to work with **Azure Artifacts** for generic artifacts.
+        Requires `Credentials` provided by `AzureCredentialsProvider`.
+        """
+        super().__init__(**kwargs)
+        self._credentials = credentials
+        self._session.auth = HTTPBasicAuth("", self._credentials.access_token)
+        self.organization = organization
+        self.project = project
+        self.feed = feed
+
+    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]:
+        acceptable_versions = [artifact.version]
+        if timestamp_version_match := re.match(self.TIMESTAMP_VERSION_PATTERN, artifact.version):
+            acceptable_versions.append(timestamp_version_match.group(1) + "SNAPSHOT")
+
+        # Try to find package with name ~ "artifact_id"
+        feeds_search_url = f"https://feeds.dev.azure.com/{self.organization}/{self.project}/_apis/packaging/feeds/{self.feed}/packages"
+        feed_search_params = {
+            "includeAllVersions": "true",
+            "packageNameQuery": artifact.artifact_id,
+            "protocolType": "maven",
+            "api-version": "7.1",
+        }
+        feeds_response = self._session.get(url=feeds_search_url, params=feed_search_params, timeout=self.timeout)
+        feeds_response_json = feeds_response.json()
+        if feeds_response.status_code != 200:
+            logging.error(f"Feeds search error ({feeds_response.status_code}) response: {feeds_response_json}")
+            raise Exception(f"Could not find '{artifact.artifact_id}' - search request returned {feeds_response.status_code}!")
+
+        logging.debug(f"Feeds search response: {feeds_response_json}")
+        if feeds_response_json.get("count") > 1:
+            logging.warning("Found more than 1 feeds. Use the first one.")
+        elif feeds_response_json.get("count") == 0:
+            logging.warning("No feeds were found.")
+            return []
+        feed = feeds_response_json.get("value")[0]
+        feed_links = feed.get("_links", {})
+
+        # Get feed versions
+        feed_versions_url = feed_links.get("versions", {}).get("href", "")
+        feed_versions_response = self._session.get(url=feed_versions_url, timeout=self.timeout)
+        feed_versions_response_json = feed_versions_response.json()
+        if feed_versions_response.status_code != 200:
+            logging.error(f"Feed versions error ({feed_versions_response.status_code}) response: {feed_versions_response_json}")
+            raise Exception(f"Could not find feed versions, search request returned {feed_versions_response.status_code}!")
+        logging.debug(f"Feed versions response: {feed_versions_response_json}")
+        feed_versions = feed_versions_response_json.get("value")
+
+        # Filter by acceptable versions
+        logging.debug(f"Filtering by acceptable versions: '{acceptable_versions}'")
+        feed_version = [f for f in feed_versions if (f.get('protocolMetadata').get('data').get('version') in acceptable_versions)]
+        if len(feed_version) == 0:
+            logging.warning("All feed versions filtered.")
+            return []
+        filtered_feed_version = feed_version[0]
+
+        # Search for target file
+        files = [f for f in filtered_feed_version.get("files") if f.get('name').startswith(f"{artifact.artifact_id}-{artifact.version}") and f.get('name').endswith(artifact.extension)]
+        logging.debug(f"Files found: {files}")
+        if len(files) == 0:
+            logging.warning("All files filtered.")
+            return []
+        target_file = files[0]
+
+        # Build download url
+        feed_id = feed_links.get("feed").get("href").split("/")[-1] # take id from link to feed
+        feed_version = filtered_feed_version.get("version")
+        group_id = filtered_feed_version.get('protocolMetadata').get('data').get("groupId")
+        artifact_id = filtered_feed_version.get('protocolMetadata').get('data').get("artifactId")
+        target_file_name = target_file.get("name")
+
+        download_url = (
+            f"https://pkgs.dev.azure.com/{self.organization}/{self.project}/_apis/packaging/feeds/{feed_id}/maven/"
+            f"{group_id}/{artifact_id}/{feed_version}/{target_file_name}/content"
+            f"?api-version=7.1-preview.1"
+        )
+        logging.info(f"Azure search resulting url: {download_url}")
+        return [download_url]
+
+    def get_provider_name(self) -> str:
+        return "azure_artifacts"

qubership_pipelines_common_library/v2/artifacts_finder/providers/gcp_artifact_registry.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+from google.cloud import artifactregistry_v1
+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
+from qubership_pipelines_common_library.v2.artifacts_finder.model.credentials import Credentials
+
+
+class GcpArtifactRegistryProvider(ArtifactProvider):
+
+    def __init__(self, credentials: Credentials, project: str, region_name: str, repository: str, **kwargs):
+        """
+        Initializes this client to work with **GCP Artifact Registry** for generic artifacts.
+        Requires `Credentials` provided by `GcpCredentialsProvider`.
+        """
+        super().__init__(**kwargs)
+        self._credentials = credentials
+        self._project = project
+        self._region_name = region_name
+        self._repository = repository
+        self._repo_resource_id = f"projects/{project}/locations/{region_name}/repositories/{repository}"
+
+        self._gcp_client = artifactregistry_v1.ArtifactRegistryClient(
+            credentials=self._credentials.google_credentials_object
+        )
+        self._authorized_session = self._credentials.authorized_session
+
+    def download_artifact(self, resource_url: str, local_path: str | Path, **kwargs) -> None:
+        response = self._authorized_session.get(url=resource_url, timeout=self.timeout)
+        response.raise_for_status()
+        with open(local_path, 'wb') as file:
+            file.write(response.content)
+
+    def search_artifacts(self, artifact: Artifact, **kwargs) -> list[str]:
+        # works with both "Maven" and "Generic" type repositories
+        name_filter = f"{self._repo_resource_id}/files/*{artifact.artifact_id}-{artifact.version}.{artifact.extension}"
+        list_files_request = artifactregistry_v1.ListFilesRequest(
+            parent=f"{self._repo_resource_id}",
+            filter=f'name="{name_filter}"',
+        )
+        files = self._gcp_client.list_files(request=list_files_request)
+        # logging.debug(f"[GCP search_artifacts] files: {files}")
+
+        urls = []
+        for file in files:
+            download_url = f"https://artifactregistry.googleapis.com/download/v1/{file.name}:download?alt=media"
+            urls.append(download_url)
+        return urls
+
+    def get_provider_name(self) -> str:
+        return "gcp_artifact_registry"