sap-ai-sdk-core 2.9.9__py3-none-any.whl → 3.0.3__py3-none-any.whl

ai_core_sdk/models/application.py

@@ -0,0 +1,37 @@
+from typing import Dict
+
+
+class Application:
+    """The Application object defines the application.
+
+    :param path: path within the repository
+    :type path: str
+    :param revision: revision
+    :type revision: str
+    :param repository_url: URL of the repository
+    :type repository_url: str
+    :param application_name: name of the application
+    :type application_name: str
+    """
+
+    # pylint:disable=W0613
+    def __init__(self, path: str, revision: str, repository_url: str, application_name: str, **kwargs):
+        self.path: str = path
+        self.revision: str = revision
+        self.repository_url: str = repository_url
+        self.application_name: str = application_name
+
+    def __str__(self):
+        return "Application name: " + str(self.application_name)
+
+    @staticmethod
+    def from_dict(application_dict: Dict[str, str]):
+        """Returns a :class:`ai_core_sdk.models.application.Application` object, created from the values in
+        the dict provided as parameter
+
+        :param application_dict: Dict which includes the necessary values to create the object
+        :type application_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.application.Application`
+        """
+        return Application(**application_dict)

ai_core_sdk/models/application_query_response.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List
+
+from ai_core_sdk.models import QueryResponse
+from ai_core_sdk.models.application import Application
+
+
+class ApplicationQueryResponse(QueryResponse):
+    """The ApplicationQueryResponse object defines the response of the applications query request
+    :param resources: List of the applications returned from the server
+    :type resources: List[class:`ai_core_sdk.models.application.Application`]
+    :param count: Total number of the queried applications
+    :type count: int
+    :param `**kwargs`: The keyword arguments are there in case there are additional attributes returned from server
+    """
+    def __init__(self, resources: List[Application], count: int, **kwargs):
+        super().__init__(resources=resources, count=count, **kwargs)
+
+    @staticmethod
+    def from_dict(response_dict: Dict[str, Any]):
+        """Returns a
+        :class:`ai_core_sdk.models.application_query_response.ApplicationQueryResponse`
+        object, created from the values in the dict provided as parameter
+
+        :param response_dict: Dict which includes the necessary values to create the object
+        :type response_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.application_query_response.ApplicationQueryResponse`
+        """
+        response_dict['resources'] = [Application.from_dict(r) for r in response_dict['resources']]
+        return ApplicationQueryResponse(**response_dict)

ai_core_sdk/models/application_resource_sync_status.py

@@ -0,0 +1,34 @@
+from typing import Dict
+
+
+class ApplicationResourceSyncStatus:
+    """The ApplicationSyncResourcesStatus object defines the status of sync of application resource.
+
+    :param name: Name of the application resource, defaults to None
+    :type name: str, optional
+    :param kind: kind of the application resource
+    :type kind: str, optional
+    :param status: status of the sync of the application resource
+    :type status: str, optional
+    :param message: application resource message
+    :type message: str, optional
+    """
+
+    def __init__(self, name: str = None, kind: str = None, status: str = None, message: str = None, **kwargs):
+        self.name: str = name
+        self.kind: str = kind
+        self.status: str = status
+        self.message: str = message
+
+    @staticmethod
+    def from_dict(app_res_sync_status_dict: Dict[str, str]):
+        """Returns a :class:`ai_core_sdk.models.application_resource_sync_status.ApplicationResourceSyncStatus`
+        object, created from the values in the dict provided as parameter
+
+        :param app_res_sync_status_dict: Dict which includes the necessary values to create the object
+        :type app_res_sync_status_dict: Dict[str, str]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.application_resource_sync_status.ApplicationResourceSyncStatus`
+        """
+        return ApplicationResourceSyncStatus(**app_res_sync_status_dict)
+

ai_core_sdk/models/application_source.py

@@ -0,0 +1,34 @@
+from typing import Dict
+
+
+class ApplicationSource:
+    """The ApplicationSource object defines the application source.
+
+        :param repo_url: URL of the repository, defaults to None
+        :type repo_url: str, optional
+        :param path: path within the repository, defaults to None
+        :type path: str, optional
+        :param revision: revision number of the application, defaults to None
+        :type revision: str, optional
+        """
+
+    # pylint:disable=W0613
+    def __init__(self, repo_url: str = None, path: str = None, revision: str = None, **kwargs):
+        self.repourl: str = repo_url
+        self.path: str = path
+        self.revision: str = revision
+
+    def __str__(self):
+        return "ApplicationSource repourl: " + str(self.repourl) + ", ApplicationSource revision: " + str(self.revision)
+
+    @staticmethod
+    def from_dict(application_source_dict: Dict[str, str]):
+        """Returns a :class:`ai_core_sdk.models.application_source.ApplicationSource` object, created from the values in
+        the dict provided as parameter
+
+        :param application_source_dict: Dict which includes the necessary values to create the object
+        :type application_source_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.application_source.ApplicationSource`
+        """
+        return ApplicationSource(**application_source_dict)

ai_core_sdk/models/application_status.py

@@ -0,0 +1,66 @@
+from typing import Any, Dict, List
+
+from ai_core_sdk.models.application_source import ApplicationSource
+from ai_core_sdk.models.application_resource_sync_status import ApplicationResourceSyncStatus
+
+
+class ApplicationStatus:
+    """The Application object defines the application.
+
+        :param health_status: Application health status, defaults to None
+        :type health_status: str, optional
+        :param sync_status: Application sync status, defaults to None
+        :type sync_status: str, optional
+        :param message: Application health status message, defaults to None
+        :type message: str, optional
+        :param source: Application source, defaults to None
+        :type source: class:`ai_core_sdk.models.application_status.ApplicationStatus`, optional
+        :param sync_finished_at: Application sync finish time, defaults to None
+        :type sync_finished_at: str, optional
+        :param sync_started_at: Application sync start time, defaults to None
+        :type sync_started_at: str, optional
+        :param reconciled_at: Application reconciliation time, defaults to None
+        :type reconciled_at: str, optional
+        :param sync_resources_status: Status of the synchronization of the application resources, defaults to None
+        :type sync_resources_status:
+            List[class:`ai_core_sdk.models.application_resource_sync_status.ApplicationResourceSyncStatus`], optional
+        """
+
+    def __init__(self, health_status: str = None, sync_status: str = None, message: str = None,
+                 source: ApplicationSource = None, sync_finished_at: str = None, sync_started_at: str = None,
+                 reconciled_at: str = None, sync_resources_status: List[ApplicationResourceSyncStatus] = None,
+                 **kwargs):
+        self.health_status: str = health_status
+        self.sync_status: str = sync_status
+        self.message: str = message
+        self.source: ApplicationSource = source
+        self.sync_finished_at: str = sync_finished_at
+        self.sync_started_at: str = sync_started_at
+        self.reconciled_at: str = reconciled_at
+        self.sync_resources_status: List[ApplicationResourceSyncStatus] = sync_resources_status
+        # sync_ressources_status property is deprecated, please use sync_resources_status instead
+        self.sync_ressources_status: List[ApplicationResourceSyncStatus] = self.sync_resources_status
+
+    def __str__(self):
+        return "ApplicationStatus health status: " + str(self.health_status) + \
+               ", ApplicationStatus sync status: " + str(self.sync_status) + \
+               ", ApplicationStatus message: " + str(self.message) + ", " + str(self.source)
+
+    @staticmethod
+    def from_dict(application_status_dict: Dict[str, Any]):
+        """Returns a :class:`ai_core_sdk.models.application_status.ApplicationStatus` object, created from the values in
+        the dict provided as parameter
+
+        :param application_status_dict: Dict which includes the necessary values to create the object
+        :type application_status_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.application_status.ApplicationStatus`
+        """
+        if 'source' in application_status_dict:
+            application_status_dict['source'] = ApplicationSource.from_dict(application_status_dict['source'])
+        if 'sync_resources_status' in application_status_dict:
+            application_status_dict['sync_resources_status'] = [
+                ApplicationResourceSyncStatus.from_dict(asd)
+                for asd in application_status_dict['sync_resources_status']
+            ]
+        return ApplicationStatus(**application_status_dict)

ai_core_sdk/models/base_models.py

@@ -0,0 +1,62 @@
+from typing import Dict
+
+
+class BasicNameResponse:
+    """The BasicNameResponse object defines the response with name from the server
+
+    :param name: Name of the relevant resource
+    :type id: str
+    :param message: Response message from the server
+    :type message: str
+    :param `**kwargs`: The keyword arguments are there in case there are additional attributes returned from server
+    """
+
+    def __init__(self, name: str, message: str, **kwargs):
+        self.name: str = name
+        self.message: str = message
+
+    def __str__(self):
+        return "Name: " + str(self.name) + ", Message: " + str(self.message)
+
+    @staticmethod
+    def from_dict(bnr_dict: Dict[str, str]):
+        """Returns a :class:`ai_core_sdk.models.base_models.BasicNameResponse` object, created from the values in the
+        dict provided as parameter
+
+        :param bnr_dict: Dict which includes the necessary values to create the object
+        :type bnr_dict: Dict[str, str]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.base_models.BasicNameResponse`
+        """
+        return BasicNameResponse(**bnr_dict)
+
+
+class Message:
+    """Message object defines a message
+
+    :param message: message
+    :type message: str
+    """
+
+    def __init__(self, message: str, **kwargs):
+        self.message: str = message
+
+    def __eq__(self, other):
+        if not isinstance(other, Message):
+            return False
+        return self.message == other.message
+
+    def __str__(self):
+        return "Message: " + str(self.message)
+
+    @staticmethod
+    def from_dict(message_dict: Dict[str, str]):
+        """Returns a :class:`ai_core_sdk.models.base_models.Message` object, created from the values in the
+        dict provided as parameter
+
+        :param message_dict: Dict which includes the necessary values to create the object
+        :type message_dict: Dict[str, str]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.base_models.Message`
+        """
+        return Message(**message_dict)

ai_core_sdk/models/docker_registry_secret.py

@@ -0,0 +1,23 @@
+from typing import Dict
+
+from ai_core_sdk.models import Name
+
+
+class DockerRegistrySecret(Name):
+    """The DockerRegistrySecret object defines the docker registry secret. Refer to
+    :class:`ai_api_client_sdk.models.base_models.Name`, for the object definition
+    """
+    def __str__(self):
+        return "DockerRegistrySecret name: " + str(self.name)
+
+    @staticmethod
+    def from_dict(docker_registry_secret_dict: Dict[str, str]):
+        """Returns a :class:`ai_core_sdk.models.docker_registry_secret.DockerRegistrySecret` object, created
+        from the values in the dict provided as parameter
+
+        :param docker_registry_secret_dict: Dict which includes the necessary values to create the object
+        :type docker_registry_secret_dict: Dict[str, str]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.docker_registry_secret.DockerRegistrySecret`
+        """
+        return DockerRegistrySecret(**docker_registry_secret_dict)

ai_core_sdk/models/docker_registry_secret_query_response.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List
+
+from ai_core_sdk.models import QueryResponse
+from ai_core_sdk.models.docker_registry_secret import DockerRegistrySecret
+
+
+class DockerRegistrySecretQueryResponse(QueryResponse):
+    """The DockerRegistrySecretQueryResponse object defines the response of the dockerRegistrySecrets query request
+    :param resources: List of the docker registry secrets returned from the server
+    :type resources: List[class:`ai_core_sdk.models.docker_registry_secret.DockerRegistrySecret`]
+    :param count: Total number of the queried docker registry secrets
+    :type count: int
+    :param `**kwargs`: The keyword arguments are there in case there are additional attributes returned from server
+    """
+    def __init__(self, resources: List[DockerRegistrySecret], count: int, **kwargs):
+        super().__init__(resources=resources, count=count, **kwargs)
+
+    @staticmethod
+    def from_dict(response_dict: Dict[str, Any]):
+        """Returns a
+        :class:`ai_core_sdk.models.docker_registry_secret_query_response.DockerRegistrySecretQueryResponse`
+        object, created from the values in the dict provided as parameter
+
+        :param response_dict: Dict which includes the necessary values to create the object
+        :type response_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.docker_registry_secret_query_response.DockerRegistrySecretQueryResponse`
+        """
+        response_dict['resources'] = [DockerRegistrySecret.from_dict(r) for r in response_dict['resources']]
+        return DockerRegistrySecretQueryResponse(**response_dict)

ai_core_sdk/models/kpi.py

@@ -0,0 +1,25 @@
+from typing import Any, Dict, List, Union
+
+
+class Kpi:
+    """The Kpi object defines the Kpi data.
+    """
+
+    def __init__(self, header: List[str], rows: List[Union[str, int]], **kwargs):
+        self.header: List[str] = header
+        self.rows: List[Union[str, int]] = rows
+
+    def __str__(self):
+        return "KPIs header(s): " + ', '.join(self.header)
+
+    @staticmethod
+    def from_dict(kpi_dict: Dict[str, Any]):
+        """Returns a :class:`ai_core_sdk.models.kpi.Kpi` object, created
+        from the values in the dict provided as parameter
+
+        :param kpi_dict: Dict which includes the necessary values to create the object
+        :type kpi_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.kpi.Kpi`
+        """
+        return Kpi(**kpi_dict)

ai_core_sdk/models/object_store_secret.py

@@ -0,0 +1,32 @@
+from typing import Any, Dict
+
+
+class ObjectStoreSecret:
+    """The ObjectStoreSecret object defines the object store secret response.
+    """
+
+    def __init__(self, name: str, metadata: Dict[str, str], **kwargs):
+        key_prefix = 'storage.ai.sap.com/'
+        path_prefix_key = f'{key_prefix}path_prefix'
+        self.name: str = name
+        self.metadata: Dict[str, str] = metadata
+        # pathPrefix key is getting converted into snake case during object mapping d
+        # The below code converts path prefix from snake case to camel case
+        if path_prefix_key in metadata:
+            self.metadata[f'{key_prefix}pathPrefix'] = metadata[path_prefix_key]
+            del metadata[path_prefix_key]
+
+    def __str__(self):
+        return "Object store secret name: " + str(self.name)
+
+    @staticmethod
+    def from_dict(object_store_secret_dict: Dict[str, Any]):
+        """Returns a :class:`ai_core_sdk.models.object_store_secret.ObjectStoreSecret` object, created
+        from the values in the dict provided as parameter
+
+        :param object_store_secret_dict: Dict which includes the necessary values to create the object
+        :type object_store_secret_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.object_store_secret.ObjectStoreSecret`
+        """
+        return ObjectStoreSecret(**object_store_secret_dict)

ai_core_sdk/models/object_store_secret_query_response.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List
+
+from ai_core_sdk.models import QueryResponse
+from ai_core_sdk.models.object_store_secret import ObjectStoreSecret
+
+
+class ObjectStoreSecretQueryResponse(QueryResponse):
+    """The ObjectStoreSecretQueryResponse object defines the response of the object store secret query request
+    :param resources: List of the object store secrets returned from the server
+    :type resources: List[class:`ai_core_sdk.models.object_store_secret.ObjectStoreSecret`]
+    :param count: Total number of the queried object store secrets
+    :type count: int
+    :param `**kwargs`: The keyword arguments are there in case there are additional attributes returned from server
+    """
+    def __init__(self, resources: List[ObjectStoreSecret], count: int, **kwargs):
+        super().__init__(resources=resources, count=count, **kwargs)
+
+    @staticmethod
+    def from_dict(response_dict: Dict[str, Any]):
+        """Returns a
+        :class:`ai_core_sdk.models.object_store_secret_query_response.ObjectStoreSecretQueryResponse`
+        object, created from the values in the dict provided as parameter
+
+        :param response_dict: Dict which includes the necessary values to create the object
+        :type response_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.object_store_secret_query_response.ObjectStoreSecretQueryResponse`
+        """
+        response_dict['resources'] = [ObjectStoreSecret.from_dict(r) for r in response_dict['resources']]
+        return ObjectStoreSecretQueryResponse(**response_dict)

ai_core_sdk/models/repository.py

@@ -0,0 +1,36 @@
+from typing import Dict
+
+from ai_core_sdk.models.repository_status import RepositoryStatus
+
+
+class Repository:
+    """The Repository object defines the repository
+
+    :param name: name of the repository
+    :type name: str
+    :param url: URL of the repository
+    :type url: str
+    :param status: status of the repository, defaults to None
+    :type status: class:`ai_core_sdk.models.repository_status.RepositoryStatus`, optional
+    """
+    def __init__(self, name: str, url: str, status: RepositoryStatus = None, **kwargs):
+        self.name: str = name
+        self.url: str = url
+        self.status: RepositoryStatus = status
+
+    def __str__(self):
+        return "Repository name: " + str(self.name) + ", Repository url: " + str(self.url)
+
+    @staticmethod
+    def from_dict(repository_dict: Dict[str, str]):
+        """Returns a :class:`ai_core_sdk.models.repository.Repository` object, created
+        from the values in the dict provided as parameter
+
+        :param repository_dict: Dict which includes the necessary values to create the object
+        :type repository_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.repository.Repository`
+        """
+        if 'status' in repository_dict:
+            repository_dict['status'] = RepositoryStatus(repository_dict['status'])
+        return Repository(**repository_dict)

ai_core_sdk/models/repository_query_response.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List
+
+from ai_core_sdk.models import QueryResponse
+from ai_core_sdk.models.repository import Repository
+
+
+class RepositoryQueryResponse(QueryResponse):
+    """The RepositoryQueryResponse object defines the response of the repository query request
+    :param resources: List of the repositories returned from the server
+    :type resources: List[class:`ai_core_sdk.models.repository.Repository`]
+    :param count: Total number of the queried repositories
+    :type count: int
+    :param `**kwargs`: The keyword arguments are there in case there are additional attributes returned from server
+    """
+    def __init__(self, resources: List[Repository], count: int, **kwargs):
+        super().__init__(resources=resources, count=count, **kwargs)
+
+    @staticmethod
+    def from_dict(response_dict: Dict[str, Any]):
+        """Returns a
+        :class:`ai_core_client_sdk.models.repository_query_response.RepositoryQueryResponse`
+        object, created from the values in the dict provided as parameter
+
+        :param response_dict: Dict which includes the necessary values to create the object
+        :type response_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.repository_query_response.RepositoryQueryResponse`
+        """
+        response_dict['resources'] = [Repository.from_dict(r) for r in response_dict['resources']]
+        return RepositoryQueryResponse(**response_dict)

ai_core_sdk/models/repository_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RepositoryStatus(Enum):
+    """RepositoryStatus is an Enum defining the valid values of the status of a repository
+    """
+    ERROR = 'ERROR'
+    IN_PROGRESS = 'IN-PROGRESS'
+    COMPLETED = 'COMPLETED'

ai_core_sdk/models/resource_group.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, List
+
+from ai_core_sdk.models import Label
+from ai_core_sdk.models.resource_group_status import ResourceGroupStatus
+
+
+class ResourceGroup:
+    """ResourceGroup represents the resource group.
+
+    :param resource_group_id: The resource_group_id of this ResourceGroup.
+    :type resource_group_id: str
+    :param tenant_id: The tenant_id of this ResourceGroup.
+    :type tenant_id: str
+    :param zone_id: The zone_id of this ResourceGroup.
+    :type zone_id: str
+    :param labels: The labels of this ResourceGroup.
+    :type labels: ResourceGroupLabels
+    :param status: The status of this ResourceGroup.
+    :type status: str
+    :param status_message: The status_message of this ResourceGroup.
+    :type status_message: str
+    """
+    def __init__(self, resource_group_id: str = None, tenant_id: str = None, zone_id: str = None,
+                 labels: List[Label] = None, status: ResourceGroupStatus = None, status_message: str = None, **kwargs):
+        self.resource_group_id: str = resource_group_id
+        self.tenant_id: str = tenant_id
+        self.zone_id: str = zone_id
+        self.labels: List[Label] = labels
+        self.status: ResourceGroupStatus = status
+        self.status_message: str = status_message
+
+    def __str__(self):
+        return "Resource group id: " + str(self.resource_group_id)
+
+    @staticmethod
+    def from_dict(resource_group_dict: Dict[str, Any]):
+        """Returns a :class:`ai_core_sdk.models.resource_group.ResourceGroup` object, created
+        from the values in the dict provided as parameter
+
+        :param resource_group_dict: Dict which includes the necessary values to create the object
+        :type resource_group_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.resource_group.ResourceGroup`
+        """
+        if 'resource_group_status' in resource_group_dict:
+            resource_group_dict['resource_group_status'] = \
+                ResourceGroupStatus(resource_group_dict['resource_group_status'])
+        if 'labels' in resource_group_dict:
+            resource_group_dict['labels'] = [Label.from_dict(l) for l in resource_group_dict['labels']]
+        return ResourceGroup(**resource_group_dict)

ai_core_sdk/models/resource_group_query_response.py

@@ -0,0 +1,31 @@
+from typing import Any, Dict, List
+
+from ai_core_sdk.models import QueryResponse
+from ai_core_sdk.models.resource_group import ResourceGroup
+
+
+class ResourceGroupQueryResponse(QueryResponse):
+    """The ResourceGroupQueryResponse object defines the response of the resourceGroups query request
+    :param resources: List of the resource groups returned from the server
+    :type resources: List[class:`ai_core_sdk.models.resource_group.ResourceGroup`]
+    :param count: Total number of the queried docker registry secrets
+    :type count: int
+    :param `**kwargs`: The keyword arguments are there in case there are additional attributes returned from server
+    """
+
+    def __init__(self, resources: List[ResourceGroup], count: int, **kwargs):
+        super().__init__(resources=resources, count=count, **kwargs)
+
+    @staticmethod
+    def from_dict(response_dict: Dict[str, Any]):
+        """Returns a
+        :class:`ai_core_sdk.models.docker_registry_secret_query_response.DockerRegistrySecretQueryResponse`
+        object, created from the values in the dict provided as parameter
+
+        :param response_dict: Dict which includes the necessary values to create the object
+        :type response_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.docker_registry_secret_query_response.DockerRegistrySecretQueryResponse`
+        """
+        response_dict['resources'] = [ResourceGroup.from_dict(r) for r in response_dict['resources']]
+        return ResourceGroupQueryResponse(**response_dict)

ai_core_sdk/models/resource_group_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ResourceGroupStatus(Enum):
+    """ResourceGroupStatus is an Enum defining the valid values of the status of a resource group
+    """
+    ERROR = 'ERROR'
+    PROVISIONED = 'PROVISIONED'
+    PROVISIONING = 'PROVISIONING'

ai_core_sdk/models/secret.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict
+
+
+class Secret:
+    """The Secret object defines the secret response.
+
+        :param name: Secret name
+        :type name: str
+        :param data: Secret data dictionary, defaults to None
+        :type data: dict, optional
+    """
+
+    def __init__(self, name: str, data: Dict[str, str] = None, **kwargs):
+        self.name: str = name
+        self.data: Dict[str, str] = data
+
+    def __str__(self):
+        return "Secret name: " + str(self.name)
+
+    @staticmethod
+    def from_dict(secret_dict: Dict[str, Any]):
+        """Returns a :class:`ai_core_sdk.models.secret.Secret` object, created
+        from the values in the dict provided as parameter
+
+        :param secret_dict: Dict which includes the necessary values to create the object
+        :type secret_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.secret.Secret`
+        """
+        return Secret(**secret_dict)

ai_core_sdk/models/secret_query_response.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List
+
+from ai_core_sdk.models import QueryResponse
+from ai_core_sdk.models.secret import Secret
+
+
+class SecretQueryResponse(QueryResponse):
+    """The SecretQueryResponse object defines the response of the secret query request
+    :param resources: List of the secrets returned from the server
+    :type resources: List[class:`ai_core_sdk.models.secret.Secret`]
+    :param count: Total number of the queried secrets
+    :type count: int
+    :param `**kwargs`: The keyword arguments are there in case there are additional attributes returned from server
+    """
+    def __init__(self, resources: List[Secret], count: int, **kwargs):
+        super().__init__(resources=resources, count=count, **kwargs)
+
+    @staticmethod
+    def from_dict(response_dict: Dict[str, Any]):
+        """Returns a
+        :class:`ai_core_sdk.models.secret_query_response.SecretQueryResponse`
+        object, created from the values in the dict provided as parameter
+
+        :param response_dict: Dict which includes the necessary values to create the object
+        :type response_dict: Dict[str, Any]
+        :return: An object, created from the values provided
+        :rtype: class:`ai_core_sdk.models.secret_query_response.SecretQueryResponse`
+        """
+        response_dict['resources'] = [Secret.from_dict(r) for r in response_dict['resources']]
+        return SecretQueryResponse(**response_dict)