frogml-core 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

frogml_core/automations/common.py

@@ -0,0 +1,106 @@
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+
+from frogml_proto.qwak.automation.v1.action_pb2 import Action as ActionProto
+from frogml_proto.qwak.automation.v1.action_pb2 import MemoryUnit
+from frogml_proto.qwak.automation.v1.common_pb2 import MetricThresholdDirection
+from frogml_proto.qwak.user_application.common.v0.resources_pb2 import (
+    MemoryUnit as CommonMemoryUnit,
+)
+
+
+@dataclass
+class Action(ABC):
+    @abstractmethod
+    def to_proto(self):
+        # abstract method
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def from_proto(message: ActionProto):
+        # abstract method
+        pass
+
+
+def map_memory_units(memory: str):
+    memory_unit = re.sub(r"\d+", "", memory)
+    if memory_unit == "Gi":
+        return MemoryUnit.GIB
+    elif memory_unit == "Mib":
+        return MemoryUnit.MIB
+    else:
+        return MemoryUnit.UNKNOWN
+
+
+def map_common_memory_units(memory: str):
+    memory_unit = re.sub(r"\d+", "", memory)
+    if memory_unit == "Gi":
+        return CommonMemoryUnit.GIB
+    elif memory_unit == "Mib":
+        return CommonMemoryUnit.MIB
+    else:
+        return CommonMemoryUnit.INVALID_MEMORY_UNIT
+
+
+def map_memory_units_proto(memory_unit: MemoryUnit):
+    if memory_unit == MemoryUnit.MIB:
+        return "Mib"
+    elif memory_unit == MemoryUnit.GIB:
+        return "Gi"
+    else:
+        return ""
+
+
+def map_common_memory_units_proto(memory_unit: CommonMemoryUnit):
+    if memory_unit == CommonMemoryUnit.MIB:
+        return "Mib"
+    elif memory_unit == CommonMemoryUnit.GIB:
+        return "Gi"
+    else:
+        return ""
+
+
+def get_memory_amount(memory: str):
+    return int(
+        re.sub(
+            r"\D",
+            "",
+            memory,
+        )
+    )
+
+
+class ThresholdDirection(Enum):
+    ABOVE = 1
+    BELOW = 2
+    EQUALS = 3
+    BELOW_OR_EQUALS = 4
+    ABOVE_OR_EQUALS = 5
+
+
+threshold_to_proto_mapping = {
+    ThresholdDirection.ABOVE: MetricThresholdDirection.ABOVE,
+    ThresholdDirection.BELOW: MetricThresholdDirection.BELOW,
+    ThresholdDirection.EQUALS: MetricThresholdDirection.EQUALS,
+    ThresholdDirection.BELOW_OR_EQUALS: MetricThresholdDirection.BELOW_OR_EQUALS,
+    ThresholdDirection.ABOVE_OR_EQUALS: MetricThresholdDirection.ABOVE_OR_EQUALS,
+}
+
+proto_threshold_to_threshold = {v: k for k, v in threshold_to_proto_mapping.items()}
+
+
+def map_threshold_direction_to_proto(
+    direction: ThresholdDirection,
+) -> MetricThresholdDirection:
+    return threshold_to_proto_mapping.get(
+        direction, MetricThresholdDirection.INVALID_METRIC_DIRECTION
+    )
+
+
+def map_proto_threshold_to_direction(
+    direction: MetricThresholdDirection,
+) -> ThresholdDirection:
+    return proto_threshold_to_threshold.get(direction)

frogml_core/clients/_inner/edge_communications.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from frogml_core.clients.administration.eco_system.client import EcosystemClient
+from frogml_core.exceptions import FrogmlException
+
+
+def get_endpoint_url(
+    endpoint_url: Optional[str] = None, environment_id: Optional[str] = None
+) -> str:
+    if not endpoint_url:
+        user_context = EcosystemClient().get_authenticated_user_context().user
+        if not environment_id:
+            environment_id = user_context.account_details.default_environment_id
+
+        if environment_id not in user_context.account_details.environment_by_id:
+            raise FrogmlException(
+                f"Configuration for environment '{environment_id}' was not found"
+            )
+
+        endpoint_url = user_context.account_details.environment_by_id[
+            environment_id
+        ].configuration.edge_services_url
+
+    return endpoint_url

frogml_core/clients/administration/authenticated_user/client.py

@@ -0,0 +1,41 @@
+import grpc
+from dependency_injector.wiring import Provide
+
+from frogml_proto.qwak.administration.authenticated_user.v1.authenticated_user_service_pb2 import (
+    GetCloudCredentialsRequest,
+    GetCloudCredentialsResponse,
+    GetDetailsRequest,
+    GetDetailsResponse,
+)
+from frogml_proto.qwak.administration.authenticated_user.v1.authenticated_user_service_pb2_grpc import (
+    AuthenticatedUserStub,
+)
+from frogml_core.exceptions import FrogmlException
+from frogml_core.inner.di_configuration import FrogmlContainer
+
+
+class AuthenticatedUserClient:
+    """
+    Used for interacting with JFrog ML Authenticated User service
+    """
+
+    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
+        self._authenticated_user = AuthenticatedUserStub(grpc_channel)
+
+    def get_details(self) -> GetDetailsResponse:
+        request = GetDetailsRequest()
+        try:
+            return self._authenticated_user.GetDetails(request)
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to get authenticated user details, error is {e.details()}"
+            )
+
+    def get_cloud_credentials(self) -> GetCloudCredentialsResponse:
+        request = GetCloudCredentialsRequest()
+        try:
+            return self._authenticated_user.GetCloudCredentials(request)
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to get cloud credentials, error is {e.details()}"
+            )

frogml_core/clients/administration/authentication/client.py

@@ -0,0 +1,34 @@
+import grpc
+from dependency_injector.wiring import Provide
+
+from frogml_proto.qwak.administration.v0.authentication.authentication_service_pb2 import (
+    AuthenticateRequest,
+)
+from frogml_proto.qwak.administration.v0.authentication.authentication_service_pb2 import (
+    QwakApiKeyMethod as JFrogMLApiKeyMethod,
+)
+from frogml_proto.qwak.administration.v0.authentication.authentication_service_pb2_grpc import (
+    AuthenticationServiceStub,
+)
+from frogml_core.exceptions import FrogmlException
+from frogml_core.inner.di_configuration import FrogmlContainer
+
+
+class AuthenticationClient:
+    """
+    Used for interacting with Frogml's Authentication service
+    """
+
+    def __init__(
+        self, grpc_channel=Provide[FrogmlContainer.unauthenticated_core_grpc_channel]
+    ):
+        self._authentication_service = AuthenticationServiceStub(grpc_channel)
+
+    def authenticate(self, api_key=None):
+        request = AuthenticateRequest(
+            qwak_api_key_method=JFrogMLApiKeyMethod(qwak_api_key=api_key)
+        )
+        try:
+            return self._authentication_service.Authenticate(request)
+        except grpc.RpcError as e:
+            raise FrogmlException(f"Failed to login, error is {e.details()}")

frogml_core/clients/administration/eco_system/client.py

@@ -0,0 +1,152 @@
+from typing import Dict, List, Optional, Set
+
+import grpc
+from dependency_injector.wiring import Provide
+
+from frogml_proto.qwak.ecosystem.v0.ecosystem_pb2 import (
+    AuthenticatedUserContext,
+    EnvironmentDetails,
+    UserContextAccountDetails,
+    UserContextEnvironmentDetails,
+)
+from frogml_proto.qwak.ecosystem.v0.ecosystem_runtime_service_pb2 import (
+    GetAuthenticatedUserContextRequest,
+    GetCloudCredentialsRequest,
+    GetCloudCredentialsResponse,
+)
+from frogml_proto.qwak.ecosystem.v0.ecosystem_runtime_service_pb2_grpc import (
+    QwakEcosystemRuntimeStub,
+)
+from frogml_core.exceptions import FrogmlException
+from frogml_core.inner.di_configuration import FrogmlContainer
+
+
+class FrogMLSuggestionException:
+    pass
+
+
+class EcosystemClient:
+    """
+    Used for interacting with Frogml's Ecosystem
+    """
+
+    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
+        self._ecosystem_service = QwakEcosystemRuntimeStub(grpc_channel)
+
+    def get_cloud_credentials(
+        self, request: GetCloudCredentialsRequest
+    ) -> GetCloudCredentialsResponse:
+        try:
+            return self._ecosystem_service.GetCloudCredentials(request)
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to get cloud credentials, error is {e.details()}"
+            )
+
+    def get_authenticated_user_context(self) -> AuthenticatedUserContext:
+        try:
+            return self._ecosystem_service.GetAuthenticatedUserContext(
+                GetAuthenticatedUserContextRequest()
+            ).authenticated_user_context
+
+        except grpc.RpcError as e:
+            raise FrogmlException(f"Failed to get user context, error is {e.details()}")
+
+    def get_account_details(self) -> UserContextAccountDetails:
+        return self.get_authenticated_user_context().user.account_details
+
+    def translate_environments_names_to_ids(
+        self,
+        environments_names: List[str],
+    ) -> List[str]:
+        names_to_selected_environments = self.get_environments_names_to_details(
+            environments_names
+        )
+
+        return [
+            names_to_selected_environments[env_name].id
+            for env_name in environments_names
+        ]
+
+    def get_environments_names_to_details(
+        self,
+        environments_names: List[str],
+    ) -> Dict[str, UserContextEnvironmentDetails]:
+        account_details = self.get_account_details()
+
+        if not environments_names:
+            environment = account_details.environment_by_id[
+                account_details.default_environment_id
+            ]
+            return {environment.name: environment}
+
+        environments_names_set = set(environments_names)
+
+        selected_environments = self.get_envs_by_names(
+            account_details, environments_names_set
+        )
+        if len(selected_environments) != len(environments_names):
+            available_environments_names = set(
+                self.get_available_envs_names(account_details)
+            )
+            missing_envs = environments_names_set - available_environments_names
+
+            raise FrogmlException(
+                message=f"The following environments were not found: {','.join(missing_envs)},"
+                f" Available environments are: {','.join(available_environments_names)}",
+            )
+
+        return {env.name: env for env in selected_environments}
+
+    def get_environments(self) -> Dict[str, UserContextEnvironmentDetails]:
+        account = self.get_account_details()
+
+        return account.environment_by_id
+
+    def get_environment_configuration(
+        self, environment_name: Optional[str] = None
+    ) -> EnvironmentDetails:
+        account_details = self.get_account_details()
+        if environment_name:
+            matching_envs = self.get_envs_by_names(account_details, {environment_name})
+            if not matching_envs:
+                available_environments_names = self.get_available_envs_names(
+                    account_details
+                )
+                raise FrogmlException(
+                    f"Environment with name {environment_name} was not found. Available "
+                    f"environments are: {', '.join(available_environments_names)}"
+                )
+            return matching_envs[0].configuration
+
+        else:
+            return account_details.environment_by_id[
+                account_details.default_environment_id
+            ]
+
+    def get_environment_model_api(self, environment_name: Optional[str] = None) -> str:
+        return self.get_environment_configuration(environment_name).model_api_url
+
+    @staticmethod
+    def get_available_envs_names(
+        account_details: UserContextAccountDetails,
+    ) -> List[str]:
+        available_environments_names = list(
+            map(
+                lambda env: env.name,
+                dict(account_details.environment_by_id).values(),
+            )
+        )
+        return available_environments_names
+
+    @staticmethod
+    def get_envs_by_names(
+        account_details: UserContextAccountDetails, environment_names: Set[str]
+    ) -> List[UserContextEnvironmentDetails]:
+        matching_envs = list(
+            filter(
+                lambda env: env.name in environment_names,
+                dict(account_details.environment_by_id).values(),
+            )
+        )
+        return matching_envs

frogml_core/clients/administration/eco_system/eco_system_utils.py

@@ -0,0 +1,15 @@
+from frogml_core.clients.administration.eco_system.client import EcosystemClient
+
+
+class EcosystemUtils:
+    def __init__(self):
+        self._client = EcosystemClient()
+
+    def get_user_context(self):
+        return self._client.get_authenticated_user_context().user
+
+    def get_default_environment_id(self) -> str:
+        return self.get_user_context().account_details.default_environment_id
+
+    def get_current_environment_name(self) -> str:
+        return self.get_user_context().environment_details.name.lower()

frogml_core/clients/administration/environment/client.py

@@ -0,0 +1,77 @@
+import grpc
+from dependency_injector.wiring import Provide
+
+from frogml_proto.qwak.administration.v0.environments.environment_pb2 import (
+    QwakEnvironmentStatus,
+)
+from frogml_proto.qwak.administration.v0.environments.environment_service_pb2 import (
+    GetEnvironmentApplicationUserCredentialsRequest,
+    GetEnvironmentApplicationUserCredentialsResponse,
+    ListEnvironmentsRequest,
+    ListEnvironmentsResponse,
+)
+from frogml_proto.qwak.administration.v0.environments.environment_service_pb2_grpc import (
+    EnvironmentServiceStub,
+)
+from frogml_core.exceptions import FrogmlException
+from frogml_core.inner.di_configuration import FrogmlContainer
+
+
+class EnvironmentClient:
+    """
+    Used for interacting with Frogml's Environemt
+    """
+
+    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
+        self._environment_service = EnvironmentServiceStub(grpc_channel)
+
+    def list_environments(self) -> ListEnvironmentsResponse:
+        """
+        List of all environment without filter
+        Return ListEnvironmentsResponse
+        """
+        request = ListEnvironmentsRequest()
+        try:
+            return self._environment_service.ListEnvironments(request)
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to get List of environments, error is {e.details()}"
+            )
+
+    def list_environments_by_status(
+        self, status: QwakEnvironmentStatus
+    ) -> ListEnvironmentsResponse:
+        """
+        List of all environment without filter
+        Args: status which filter environment by
+        Return: ListEnvironmentsResponse
+
+        """
+        try:
+            request = ListEnvironmentsRequest(
+                filter=ListEnvironmentsRequest.Filter(environment_status=status)
+            )
+            return self._environment_service.ListEnvironments(request)
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to get List of environments with status, error is {e.details()}"
+            )
+
+    def get_environment_application_user(
+        self, environment_id: str
+    ) -> GetEnvironmentApplicationUserCredentialsResponse:
+        """
+        Get application user by environment id
+        Return: GetEnvironmentApplicationUserCredentialsResponse
+        """
+        request = GetEnvironmentApplicationUserCredentialsRequest(
+            environment_id=environment_id
+        )
+        try:
+            return self._environment_service.GetEnvironmentApplicationUserCredentials(
+                request
+            )
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to get application user, error is {e.details()}"
+            )

frogml_core/clients/administration/self_service/client.py

@@ -0,0 +1,73 @@
+from dependency_injector.wiring import Provide
+from grpc import RpcError, StatusCode
+
+from frogml_proto.qwak.self_service.user.v1.user_service_pb2 import (
+    GenerateApiKeyRequest,
+    GenerateApiKeyResponse,
+    RevokeApiKeyRequest,
+    RevokeApiKeyResponse,
+)
+from frogml_proto.qwak.self_service.user.v1.user_service_pb2_grpc import (
+    UserServiceStub,
+)
+from frogml_core.exceptions import FrogmlException
+from frogml_core.inner.di_configuration import FrogmlContainer
+
+APIKEY_ALREADY_EXISTS = "Api-key already exists"
+
+
+class SelfServiceUserClient:
+    """
+    Used for interacting with Frogml's Self service -  user service
+    """
+
+    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
+        self._user_service = UserServiceStub(grpc_channel)
+
+    def generate_apikey(
+        self,
+        user_id: str,
+        environment_id: str,
+        force: bool = False,
+    ) -> GenerateApiKeyResponse:
+        """
+        Generate api key
+        user_id: the wanted user id.
+        environment_id: the wanted environment id
+        force: if override existing one.
+        Return Api Key for the wanted user and environment.
+        """
+        request = GenerateApiKeyRequest(
+            user_id=user_id, environment_id=environment_id, force=force
+        )
+        try:
+            return self._user_service.GenerateApiKey(request)
+        except RpcError as e:
+            if e.code() == StatusCode.PERMISSION_DENIED:
+                raise FrogmlException(
+                    f"You are not authorized to perform administration operations. error is  {e.details()}"
+                )
+            elif e.code() == StatusCode.ALREADY_EXISTS:
+                raise FrogmlException(APIKEY_ALREADY_EXISTS)
+            raise FrogmlException(f"Failed to generate apikey, error is {e.details()}")
+
+    def revoke_apikey(self, user_id: str, environment_id: str) -> RevokeApiKeyResponse:
+        """
+        Revoke api eky
+        user_id: the wanted user id to revoke from
+        environment_id: the wanted environment id
+        Return if the api key has been revoked
+
+        """
+        try:
+            request = RevokeApiKeyRequest(
+                user_id=user_id, environment_id=environment_id
+            )
+            return self._user_service.RevokeApiKey(request)
+
+        except RpcError as e:
+            if e.code() == StatusCode.PERMISSION_DENIED:
+                raise FrogmlException(
+                    f"You are not authorized to perform administration operations. error is  {e.details()}"
+                )
+            raise FrogmlException(f"Failed to generate apikey, error is {e.details()}")

frogml_core/clients/alert_management/client.py

@@ -0,0 +1,64 @@
+import grpc
+from dependency_injector.wiring import Provide
+
+from frogml_proto.qwak.deployment.alert_pb2 import (
+    NotificationChannel,
+    NotificationChannelSettings,
+)
+from frogml_proto.qwak.deployment.alert_service_pb2 import (
+    ApplyNotificationChannelRequest,
+    DeleteNotificationChannelRequest,
+    GetNotificationChannelDetailsListRequest,
+)
+from frogml_proto.qwak.deployment.alert_service_pb2_grpc import (
+    AlertManagementServiceStub,
+)
+from frogml_core.exceptions import FrogmlException
+from frogml_core.inner.di_configuration import FrogmlContainer
+
+
+class AlertsManagementClient:
+    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
+        self._alerts_management_service = AlertManagementServiceStub(grpc_channel)
+
+    def configure_channel(
+        self, channel_name: str, notification_settings: NotificationChannelSettings
+    ):
+        try:
+            self._alerts_management_service.ApplyNotificationChannel(
+                ApplyNotificationChannelRequest(
+                    notification_channel=NotificationChannel(
+                        notification_channel_name=channel_name,
+                        notification_settings=notification_settings,
+                    ),
+                )
+            )
+
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to save notification channel, error is {e.details()}"
+            )
+
+    def list_channels(self):
+        try:
+            return self._alerts_management_service.GetNotificationChannelDetailsList(
+                GetNotificationChannelDetailsListRequest()
+            )
+
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to fetch notification channels, error is {e.details()}"
+            )
+
+    def delete_channel(self, notification_channel_id):
+        try:
+            self._alerts_management_service.DeleteNotificationChannel(
+                DeleteNotificationChannelRequest(
+                    notification_channel_id=notification_channel_id
+                )
+            )
+
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to delete notification channel, error is {e.details()}"
+            )