frogml-core 0.0.1__py3-none-any.whl

frogml_services_mock/mocks/model_version_manager_service.py

@@ -0,0 +1,100 @@
+import uuid
+from datetime import datetime
+from typing import Dict
+
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from _frogml_proto.jfml.model_version.v1.model_repository_spec_pb2 import (
+    ModelRepositorySpec,
+)
+from _frogml_proto.jfml.model_version.v1.model_version_framework_pb2 import (
+    CatboostFramework,
+)
+from _frogml_proto.jfml.model_version.v1.model_version_manager_service_pb2 import (
+    CreateModelVersionResponse,
+    CreateModelVersionRequest,
+    GetModelVersionByIdResponse,
+    GetModelVersionByIdRequest,
+    GetModelVersionByNameRequest,
+    GetModelVersionByNameResponse,
+)
+from _frogml_proto.jfml.model_version.v1.model_version_manager_service_pb2_grpc import (
+    ModelVersionManagerServiceServicer,
+)
+from _frogml_proto.jfml.model_version.v1.model_version_pb2 import (
+    ModelVersion,
+    ModelVersionCompletedStatus,
+    ModelVersionSpec,
+)
+
+timestamp = Timestamp()
+timestamp.FromDatetime(datetime.now())
+
+
+class ModelVersionManagerServiceMock(ModelVersionManagerServiceServicer):
+    def __init__(self):
+        super(ModelVersionManagerServiceMock, self).__init__()
+        self.model_versions: Dict[str, ModelVersion] = {}
+
+    def CreateModelVersion(self, request: CreateModelVersionRequest, context):
+        return CreateModelVersionResponse(
+            model_version=ModelVersion(
+                model_version_id=str(uuid.uuid4()),
+                spec=request.model_version,
+                status=ModelVersionCompletedStatus(),
+                created_by="mock",
+                created_at=timestamp,
+                updated_at=timestamp,
+            )
+        )
+
+    def GetModelVersionById(self, request: GetModelVersionByIdRequest, context):
+        return GetModelVersionByIdResponse(
+            model_version=ModelVersion(
+                model_version_id=request.model_version_id,
+                spec=ModelVersionSpec(
+                    repository_spec=ModelRepositorySpec(
+                        project_key="mock-project",
+                        repository_key="mock-repository",
+                        model_id=str(uuid.uuid4()),
+                    ),
+                    name="mock-model-version-name",
+                    framework=CatboostFramework(),
+                    python_version="3.9",
+                ),
+                status=ModelVersionCompletedStatus(),
+                created_by="mock",
+                created_at=timestamp,
+                updated_at=timestamp,
+            )
+        )
+
+    def GetModelVersionByName(self, request: GetModelVersionByNameRequest, context):
+        return GetModelVersionByNameResponse(
+            model_version=ModelVersion(
+                model_version_id=str(uuid.uuid4()),
+                spec=ModelVersionSpec(
+                    repository_spec=ModelRepositorySpec(
+                        project_key="mock-project",
+                        repository_key="mock-repository",
+                        model_id=request.model_id,
+                    ),
+                    name=request.model_version_name,
+                    framework=CatboostFramework(),
+                    python_version="3.9",
+                ),
+                status=ModelVersionCompletedStatus(),
+                created_by="mock",
+                created_at=timestamp,
+                updated_at=timestamp,
+            )
+        )
+
+    def InitPagination(self, request, context):
+        return super().InitPagination(request, context)
+
+    def ListModelVersions(self, request, context):
+        return super().ListModelVersions(request, context)
+
+    def DeleteModelVersionById(self, request, context):
+        return super().DeleteModelVersionById(request, context)

frogml_services_mock/mocks/project_manager_service.py

@@ -0,0 +1,96 @@
+import uuid
+from typing import Dict
+
+import grpc
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from _frogml_proto.qwak.projects.projects_pb2 import (
+    CreateProjectRequest,
+    CreateProjectResponse,
+    DeleteProjectRequest,
+    DeleteProjectResponse,
+    GetProjectRequest,
+    GetProjectResponse,
+    ListProjectsRequest,
+    ListProjectsResponse,
+    Project,
+    ProjectSpec,
+)
+from _frogml_proto.qwak.projects.projects_pb2_grpc import (
+    ProjectsManagementServiceServicer,
+)
+
+
+class ProjectManagerServiceMock(ProjectsManagementServiceServicer):
+    def __init__(self):
+        self.projects: Dict[str, ProjectSpec] = dict()
+
+    def ListProjects(
+        self, request: ListProjectsRequest, context
+    ) -> ListProjectsResponse:
+        return ListProjectsResponse(
+            projects=[project for project in self.projects.values()]
+        )
+
+    def CreateProject(
+        self, request: CreateProjectRequest, context
+    ) -> CreateProjectResponse:
+        if request.project_name in self.projects.keys():
+            description = f"Project with name {request.project_name} already exists"
+            context.set_code(grpc.StatusCode.ALREADY_EXISTS)
+            context.set_details(description)
+            raise Exception(description)
+
+        now = Timestamp()
+        now.GetCurrentTime()
+
+        project_spec = ProjectSpec(
+            project_id=str(uuid.uuid4()),
+            project_name=request.project_name,
+            project_description=request.project_description,
+            project_status=ProjectSpec.Status.ACTIVE,
+            created_at=now,
+            last_modified_at=now,
+            models_active=0,
+            models_count=0,
+        )
+
+        self.projects[request.project_name] = project_spec
+
+        return CreateProjectResponse(project=project_spec)
+
+    def GetProject(self, request: GetProjectRequest, context) -> GetProjectResponse:
+        matched_projects = list(
+            filter(
+                lambda project: request.project_id == project.project_id,
+                self.projects.values(),
+            )
+        )
+
+        if not matched_projects:
+            description = f"Project with id {request.project_name} was not found"
+            context.set_code(grpc.StatusCode.NOT_FOUND)
+            context.set_details(description)
+            raise Exception(description)
+
+        return GetProjectResponse(project=Project(spec=matched_projects[0]))
+
+    def DeleteProject(
+        self, request: DeleteProjectRequest, context
+    ) -> DeleteProjectResponse:
+        matched_projects = list(
+            filter(
+                lambda project: request.project_id == project.project_id,
+                self.projects.values(),
+            )
+        )
+
+        if not matched_projects:
+            description = f"Project with id {request.project_name} was not found"
+            context.set_code(grpc.StatusCode.NOT_FOUND)
+            context.set_details(description)
+            raise Exception(description)
+
+        del self.projects[matched_projects[0].project_name]
+
+        return DeleteProjectResponse(info="Deleted")

frogml_services_mock/mocks/prompt_manager_service.py

@@ -0,0 +1,281 @@
+from typing import Dict, List, Tuple
+
+import grpc
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    CreatePromptRequest as ProtoCreatePromptRequest,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    CreatePromptResponse as ProtoCreatePromptResponse,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    CreatePromptVersionRequest as ProtoCreatePromptVersionRequest,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    CreatePromptVersionResponse as ProtoCreatePromptVersionResponse,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    DeletePromptRequest as ProtoDeletePromptRequest,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    DeletePromptResponse as ProtoDeletePromptResponse,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    DeletePromptVersionRequest as ProtoDeletePromptVersionRequest,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    DeletePromptVersionResponse as ProtoDeletePromptVersionResponse,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    GetPromptByNameRequest as ProtoGetPromptByNameRequest,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    GetPromptByNameResponse as ProtoGetPromptByNameResponse,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    GetPromptVersionByPromptNameRequest as ProtoGetPromptVersionByPromptNameRequest,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    GetPromptVersionByPromptNameResponse as ProtoGetPromptVersionByPromptNameResponse,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    SetDefaultPromptVersionRequest as ProtoSetDefaultPromptVersionRequest,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    SetDefaultPromptVersionResponse as ProtoSetDefaultPromptVersionResponse,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    UpdatePromptRequest as ProtoUpdatePromptRequest,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    UpdatePromptResponse as ProtoUpdatePromptResponse,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2_grpc import (
+    PromptManagerServiceServicer,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import Prompt as ProtoPrompt
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptMetadata as ProtoPromptMetadata,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import PromptSpec as ProtoPromptSpec
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptVersion as ProtoPromptVersion,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptVersionDefinition as ProtoPromptVersionDefinition,
+)
+from _frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptVersionMetadata as ProtoPromptVersionMetadata,
+)
+
+
+class PromptManagerServiceMock(PromptManagerServiceServicer):
+    prompts: Dict[str, ProtoPrompt] = {}
+    prompts_versions: Dict[Tuple[str, int], ProtoPromptVersionDefinition] = {}
+    prompts_next_version: Dict[str, int] = {}
+
+    def clear(self):
+        self.prompts = {}
+        self.prompts_versions = {}
+        self.prompts_next_version = {}
+
+    def _is_prompt_name_valid(self, test_str: str) -> bool:
+        import re
+
+        regex = r"^[a-z0-9](?:[-_]?[a-z0-9]+)+$"
+        return re.match(pattern=regex, string=test_str) is not None
+
+    def _raise_on_missing_prompt(self, prompt_name: str, context):
+        if prompt_name not in self.prompts:
+            context.set_code(grpc.StatusCode.NOT_FOUND)
+            context.set_details("Prompt name does not exist")
+            raise ValueError("Prompt name does not exist")
+
+    def _raise_on_missing_prompt_version(self, prompt_name: str, version: int, context):
+        if (
+            prompt_name not in self.prompts
+            or (prompt_name, version) not in self.prompts_versions
+        ):
+            context.set_code(grpc.StatusCode.NOT_FOUND)
+            context.set_details("Prompt version does not exist")
+            raise ValueError("Prompt version does not exist")
+
+    def CreatePrompt(self, request: ProtoCreatePromptRequest, context):
+        """Create a new prompt"""
+
+        if request.prompt_name in self.prompts:
+            context.set_code(grpc.StatusCode.ALREADY_EXISTS)
+            context.set_details("Prompt name already exists")
+            raise ValueError("Prompt name already exists")
+
+        if not self._is_prompt_name_valid(request.prompt_name):
+            context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
+            context.set_details("Bad Prompt name")
+            raise ValueError("Bad Prompt name")
+
+        prompt_version_definition = ProtoPromptVersionDefinition(
+            version_number=1,
+            version_spec=request.prompt_version_spec,
+            version_metadata=ProtoPromptVersionMetadata(
+                created_by="nirh@frogml.com", created_at=Timestamp().GetCurrentTime()
+            ),
+        )
+
+        prompt = ProtoPrompt(
+            name=request.prompt_name,
+            default_version_definition=prompt_version_definition,
+            metadata=ProtoPromptMetadata(
+                created_at=Timestamp().GetCurrentTime(), created_by="nirh@frogml.com"
+            ),
+            prompt_spec=ProtoPromptSpec(description=request.prompt_spec.description),
+        )
+
+        self.prompts[prompt.name] = prompt
+        self.prompts_next_version[prompt.name] = 2
+        self.prompts_versions[
+            (prompt.name, prompt.default_version_definition.version_number)
+        ] = prompt_version_definition
+
+        return ProtoCreatePromptResponse(prompt=prompt)
+
+    def CreatePromptVersion(self, request: ProtoCreatePromptVersionRequest, context):
+        """
+        Create new prompt version.
+        Set new version in versions dict.
+        Bump prompt next version.
+        Set default version if needed
+        """
+        self._raise_on_missing_prompt(prompt_name=request.prompt_name, context=context)
+
+        existing_prompt: ProtoPrompt = self.prompts[request.prompt_name]
+        new_prompt_version_number: int = self.prompts_next_version[request.prompt_name]
+        prompt_version_definition = ProtoPromptVersionDefinition(
+            version_number=new_prompt_version_number,
+            version_spec=request.prompt_version_spec,
+            version_metadata=ProtoPromptVersionMetadata(
+                created_by="nirh@frogml.com", created_at=Timestamp().GetCurrentTime()
+            ),
+        )
+
+        self.prompts_next_version[request.prompt_name] = new_prompt_version_number + 1
+
+        if request.set_default:
+            existing_prompt.default_version_definition.CopyFrom(
+                prompt_version_definition
+            )
+
+        self.prompts_versions[
+            (request.prompt_name, new_prompt_version_number)
+        ] = prompt_version_definition
+        return ProtoCreatePromptVersionResponse(
+            prompt_version=ProtoPromptVersion(
+                prompt_name=request.prompt_name,
+                prompt_version_definition=prompt_version_definition,
+            )
+        )
+
+    def UpdatePrompt(self, request: ProtoUpdatePromptRequest, context):
+        """Update Prompt"""
+        self._raise_on_missing_prompt(prompt_name=request.prompt_name, context=context)
+
+        existing_prompt: ProtoPrompt = self.prompts[request.prompt_name]
+        existing_prompt.prompt_spec.CopyFrom(request.prompt_spec)
+
+        return ProtoUpdatePromptResponse()
+
+    def GetPromptByName(self, request: ProtoGetPromptByNameRequest, context):
+        """Get prompt with its default version by name"""
+        self._raise_on_missing_prompt(prompt_name=request.prompt_name, context=context)
+
+        existing_prompt: ProtoPrompt = self.prompts[request.prompt_name]
+        return ProtoGetPromptByNameResponse(prompt=existing_prompt)
+
+    def GetPromptVersionByPromptName(
+        self, request: ProtoGetPromptVersionByPromptNameRequest, context
+    ):
+        """Get prompt version by name and optional version number"""
+
+        self._raise_on_missing_prompt(
+            prompt_name=request.prompt_name,
+            context=context,
+        )
+
+        self._raise_on_missing_prompt_version(
+            prompt_name=request.prompt_name,
+            version=request.version_number,
+            context=context,
+        )
+
+        return ProtoGetPromptVersionByPromptNameResponse(
+            prompt_version=ProtoPromptVersion(
+                prompt_name=request.prompt_name,
+                prompt_version_definition=self.prompts_versions[
+                    (request.prompt_name, request.version_number)
+                ],
+            )
+        )
+
+    def DeletePrompt(self, request: ProtoDeletePromptRequest, context):
+        """Delete prompt"""
+        self._raise_on_missing_prompt(prompt_name=request.prompt_name, context=context)
+
+        del self.prompts[request.prompt_name]
+        del self.prompts_next_version[request.prompt_name]
+
+        versions_to_delete: List[int] = [
+            version
+            for (name, version) in self.prompts_versions.keys()
+            if name == request.prompt_name
+        ]
+
+        for v in versions_to_delete:
+            del self.prompts_versions[(request.prompt_name, v)]
+
+        return ProtoDeletePromptResponse()
+
+    def DeletePromptVersion(self, request: ProtoDeletePromptVersionRequest, context):
+        """Delete prompt version"""
+        self._raise_on_missing_prompt(
+            prompt_name=request.prompt_name,
+            context=context,
+        )
+
+        self._raise_on_missing_prompt_version(
+            prompt_name=request.prompt_name,
+            version=request.version_number,
+            context=context,
+        )
+
+        prompt_default_version: ProtoPrompt = self.prompts[request.prompt_name]
+        if (
+            prompt_default_version.default_version_definition.version_number
+            == request.version_number
+        ):
+            context.set_code(grpc.StatusCode.FAILED_PRECONDITION)
+            context.set_details("Can't delete prompt default version")
+            raise ValueError("Can't delete prompt default version")
+
+        del self.prompts_versions[(request.prompt_name, request.version_number)]
+        return ProtoDeletePromptVersionResponse()
+
+    def SetDefaultPromptVersion(
+        self, request: ProtoSetDefaultPromptVersionRequest, context
+    ):
+        """Set default prompt version"""
+        self._raise_on_missing_prompt(
+            prompt_name=request.prompt_name,
+            context=context,
+        )
+
+        self._raise_on_missing_prompt_version(
+            prompt_name=request.prompt_name,
+            version=request.version_number,
+            context=context,
+        )
+        existing_prompt: ProtoPrompt = self.prompts[request.prompt_name]
+        prompt_version_definition: ProtoPromptVersionDefinition = self.prompts_versions[
+            (request.prompt_name, request.version_number)
+        ]
+        existing_prompt.default_version_definition.CopyFrom(prompt_version_definition)
+        return ProtoSetDefaultPromptVersionResponse()

frogml_services_mock/mocks/repository_service_mock.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+from typing import Dict
+
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from _frogml_proto.qwak.jfrog.gateway.v0.repository_pb2 import RepositorySpec
+from _frogml_proto.qwak.jfrog.gateway.v0.repository_service_pb2 import (
+    GetRepositoryConfigurationResponse,
+    GetRepositoryConfigurationRequest,
+)
+from _frogml_proto.qwak.jfrog.gateway.v0.repository_service_pb2_grpc import (
+    RepositoryServiceServicer,
+)
+from frogml.exceptions import FrogmlNotFoundException
+from frogml_services_mock.mocks.utils.exception_handlers import (
+    raise_not_found_grpc_error,
+)
+
+timestamp = Timestamp()
+timestamp.FromDatetime(datetime.now())
+
+
+class RepositoryServiceMock(RepositoryServiceServicer):
+    def __init__(self):
+        super(RepositoryServiceMock, self).__init__()
+        self.repositories: Dict[str, RepositorySpec] = {}
+
+    def GetRepositoryConfiguration(
+        self, request: GetRepositoryConfigurationRequest, context
+    ) -> GetRepositoryConfigurationResponse:
+        repository_key: str = request.repository_key
+
+        if repository_key not in self.repositories:
+            raise_not_found_grpc_error(
+                context,
+                FrogmlNotFoundException(f"Repository {repository_key} not found"),
+            )
+
+        return self.repositories[repository_key]

frogml_services_mock/mocks/secret_service.py

@@ -0,0 +1,43 @@
+import grpc
+
+from _frogml_proto.qwak.secret_service.secret_service_pb2 import (
+    DeleteSecretRequest,
+    DeleteSecretResponse,
+    GetSecretRequest,
+    GetSecretResponse,
+    SetSecretRequest,
+    SetSecretResponse,
+)
+from _frogml_proto.qwak.secret_service.secret_service_pb2_grpc import (
+    SecretServiceServicer,
+)
+
+
+class SecretServiceMock(SecretServiceServicer):
+    secrets = {}
+
+    def SetSecret(self, request: SetSecretRequest, context) -> SetSecretResponse:
+        """Set a value for a secret"""
+        self.secrets[request.name] = request.value
+        return SetSecretResponse()
+
+    def GetSecret(self, request: GetSecretRequest, context) -> GetSecretResponse:
+        """Get a secret value"""
+        if request.name in self.secrets:
+            return GetSecretResponse(
+                name=request.name, value=self.secrets[request.name]
+            )
+        context.set_code(grpc.StatusCode.NOT_FOUND)
+        context.set_details("Secret not found")
+        return GetSecretResponse()
+
+    def DeleteSecret(
+        self, request: DeleteSecretRequest, context
+    ) -> DeleteSecretResponse:
+        """Remove a secret"""
+        if request.name in self.secrets:
+            del self.secrets[request.name]
+            return DeleteSecretResponse()
+        context.set_code(grpc.StatusCode.NOT_FOUND)
+        context.set_details("Secret not found")
+        return DeleteSecretResponse()

frogml_services_mock/mocks/self_service_user_service.py

@@ -0,0 +1,31 @@
+from typing import Dict
+
+from _frogml_proto.qwak.self_service.user.v1.user_service_pb2 import (
+    GenerateApiKeyResponse,
+    RevokeApiKeyResponse,
+)
+from _frogml_proto.qwak.self_service.user.v1.user_service_pb2_grpc import (
+    UserServiceServicer,
+)
+
+API_KEY_FORMAT = "apikey-for-{}-{}"
+
+
+class SelfServiceUserServiceMock(UserServiceServicer):
+    def __init__(self):
+        super(SelfServiceUserServiceMock, self).__init__()
+        self.apikeys: Dict[(str, str), str] = dict()
+
+    def RevokeApiKey(self, request, context) -> RevokeApiKeyResponse:
+        if self.apikeys.get((request.user_id, request.environment_id)):
+            self.apikeys.pop((request.user_id, request.environment_id))
+            return RevokeApiKeyResponse(status=RevokeApiKeyResponse.Status.REVOKED)
+        else:
+            return RevokeApiKeyResponse(
+                status=RevokeApiKeyResponse.Status.INVALID_USER_STATUS
+            )
+
+    def GenerateApiKey(self, request, context) -> GenerateApiKeyResponse:
+        api_key = API_KEY_FORMAT.format(request.user_id, request.environment_id)
+        self.apikeys[(request.user_id, request.environment_id)] = api_key
+        return GenerateApiKeyResponse(api_key=api_key)

frogml_services_mock/mocks/system_secret_service.py

@@ -0,0 +1,55 @@
+from typing import Dict, Tuple
+
+import grpc
+
+from _frogml_proto.qwak.admiral.secret.v0.secret_pb2 import (
+    EnvironmentSecretIdentifier,
+    SetSystemEnvironmentSecretOptions,
+    SystemSecretDefinition,
+)
+from _frogml_proto.qwak.admiral.secret.v0.system_secret_service_pb2 import (
+    DeleteSystemSecretRequest,
+    DeleteSystemSecretResponse,
+    GetSystemSecretRequest,
+    GetSystemSecretResponse,
+    SetSystemSecretRequest,
+    SetSystemSecretResponse,
+)
+from _frogml_proto.qwak.admiral.secret.v0.system_secret_service_pb2_grpc import (
+    SystemSecretServiceServicer,
+)
+
+
+class SystemSecretServiceMock(SystemSecretServiceServicer):
+    _secrets: Dict[Tuple[str, str], SystemSecretDefinition] = dict()
+
+    def clear(self):
+        self._secrets.clear()
+
+    def SetSystemSecret(self, request: SetSystemSecretRequest, context):
+        """Set a value for a secret"""
+
+        options: SetSystemEnvironmentSecretOptions = request.options
+        identifier: EnvironmentSecretIdentifier = options.identifier
+        definition: SystemSecretDefinition = SystemSecretDefinition(
+            identifier=identifier, spec=options.spec
+        )
+
+        self._secrets[(identifier.name, identifier.environment_id)] = definition
+        return SetSystemSecretResponse()
+
+    def DeleteSystemSecret(self, request: DeleteSystemSecretRequest, context):
+        """Delete secret"""
+        name: str = request.identifier.name
+        env_id: str = request.identifier.environment_id
+
+        if (name, env_id) in self._secrets:
+            del self._secrets[(name, env_id)]
+
+        return DeleteSystemSecretResponse()
+
+    def GetSystemSecret(self, request: GetSystemSecretRequest, context):
+        """Get secret"""
+        name: str = request.identifier.name
+        env_id: str = request.identifier.environment_id
+        return GetSystemSecretResponse(secret_definition=self._secrets[(name, env_id)])