frogml 1.2.37__tar.gz → 1.2.38__tar.gz

{frogml-1.2.37 → frogml-1.2.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: frogml
-Version: 1.2.37
+Version: 1.2.38
 Summary: frogml contains the necessary objects and communication tools for using the JFrog ml Platform
 License: Apache-2.0
 Keywords: mlops,ml,deployment,serving,model

{frogml-1.2.37 → frogml-1.2.38}/frogml/__init__.py

@@ -1,5 +1,5 @@
 __author__ = "jfrog"
-__version__ = "1.2.37"
+__version__ = "1.2.38"
 
 from frogml.sdk.model.decorators.api import api_decorator as api
 from frogml.sdk.model_loggers.model_logger import load_model, log_model

{frogml-1.2.37 → frogml-1.2.38}/frogml/core/clients/batch_job_management/client.py

@@ -71,7 +71,7 @@ from .results import (
     GetExecutionReportResult,
     StartExecutionResult,
 )
-from typing import List
+from typing import List, Optional
 
 CLIENT_TIMEOUT = 180  # Seconds
 
@@ -359,15 +359,21 @@ class BatchJobManagerClient:
         except grpc.RpcError as e:
             raise FrogmlException(f"Failed to cancel execution, error is {e}")
 
-    def get_execution_report(self, execution_id: str) -> GetExecutionReportResult:
+    def get_execution_report(
+        self,
+        execution_id: str,
+        model_id: Optional[str] = None,
+        model_group_name: Optional[str] = None,
+    ) -> GetExecutionReportResult:
         """
 
         Args:
-            execution_id: the batch execution id to get the current status of
+            execution_id: The batch execution id to get the report for.
+            model_id: The model ID. This is the display name(identifier), not the UUID.
+            model_group_name: The model group name.
 
         Returns:
-            A full report of all the events that occurred as part of the execution job
-
+            A full report of all the events that occurred as part of the execution job.
         """
         try:
             self.logging_client = (
@@ -383,7 +389,9 @@ class BatchJobManagerClient:
             try:
                 execution_log_response: ReadLogsResponse = (
                     self.logging_client.read_execution_models_logs(
-                        execution_id=execution_id
+                        execution_id=execution_id,
+                        model_id=model_id,
+                        model_group_name=model_group_name,
                     )
                 )
                 execution_logs = execution_log_response.log_line

frogml-1.2.38/frogml/core/clients/logging_client/client.py

@@ -0,0 +1,227 @@
+from typing import Optional
+
+from frogml._proto.qwak.logging.log_filter_pb2 import LogText, SearchFilter
+from frogml._proto.qwak.logging.log_reader_service_pb2 import (
+    ReadLogsRequest,
+    ReadLogsResponse,
+)
+from frogml._proto.qwak.logging.log_reader_service_pb2_grpc import LogReaderServiceStub
+from frogml._proto.qwak.logging.log_source_pb2 import (
+    InferenceExecutionSource,
+    LogSource,
+    ModelRuntimeSource,
+    RemoteBuildSource,
+)
+from frogml.core.clients.administration.eco_system.client import EcosystemClient
+from frogml.core.exceptions import FrogmlException
+from frogml.core.inner.tool.grpc.grpc_tools import create_grpc_channel
+from frogml.core.inner.tool.grpc.grpc_try_wrapping import grpc_try_catch_wrapper
+
+
+class LoggingClient:
+    """
+    Used for interacting with Logging endpoint
+    """
+
+    def __init__(
+        self,
+        endpoint_url: Optional[str] = None,
+        enable_ssl: bool = True,
+        environment_id: Optional[str] = None,
+    ):
+        if endpoint_url is None:
+            user_context = EcosystemClient().get_authenticated_user_context().user
+            if environment_id is None:
+                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
+
+        self._channel = create_grpc_channel(url=endpoint_url, enable_ssl=enable_ssl)
+
+        self._logging_service = LogReaderServiceStub(self._channel)
+
+    def read_build_logs(
+        self,
+        build_id: Optional[str] = None,
+        before_offset: Optional[str] = None,
+        after_offset: Optional[str] = None,
+        max_number_of_results: Optional[int] = None,
+        log_text_filter: Optional[str] = None,
+        model_id: Optional[str] = None,
+        model_group_name: Optional[str] = None,
+    ) -> ReadLogsResponse:
+        """
+        Read logs for a remote build.
+
+        Args:
+            build_id: The build ID to fetch logs for
+            before_offset: Optional offset to read logs before this point
+            after_offset: Optional offset to read logs after this point
+            max_number_of_results: Optional maximum number of log lines to return
+            log_text_filter: Optional text filter to search for in logs
+            model_id: The model ID. This is the display name(identifier), not the UUID.
+            model_group_name: The model group name.
+
+        Returns:
+            ReadLogsResponse containing the log lines
+
+        Raises:
+            FrogmlException: If reading logs fails
+        """
+        try:
+            remote_build_source = RemoteBuildSource(
+                build_id=build_id,
+                model_id=model_id,
+                model_group_name=model_group_name,
+            )
+
+            response = self.read_logs(
+                source=LogSource(remote_build=remote_build_source),
+                before_offset=before_offset,
+                after_offset=after_offset,
+                log_text_filter=log_text_filter,
+                max_number_of_results=max_number_of_results,
+            )
+
+            return response
+        except FrogmlException as e:
+            raise FrogmlException(f"Failed to fetch build logs, error is [{e}]")
+
+    def read_model_runtime_logs(
+        self,
+        build_id: Optional[str] = None,
+        deployment_id: Optional[str] = None,
+        before_offset: Optional[str] = None,
+        after_offset: Optional[str] = None,
+        max_number_of_results: Optional[int] = None,
+        log_text_filter: Optional[str] = None,
+        model_id: Optional[str] = None,
+        model_group_name: Optional[str] = None,
+    ) -> ReadLogsResponse:
+        """
+        Read logs for a model runtime (deployment).
+
+        Args:
+            build_id: The build ID to fetch logs for
+            deployment_id: The deployment ID to fetch logs for
+            before_offset: Optional offset to read logs before this point
+            after_offset: Optional offset to read logs after this point
+            max_number_of_results: Optional maximum number of log lines to return
+            log_text_filter: Optional text filter to search for in logs
+            model_id: The model ID. This is the display name(identifier), not the UUID.
+            model_group_name: The model group name.
+
+        Returns:
+            ReadLogsResponse containing the log lines
+
+        Raises:
+            FrogmlException: If reading logs fails
+        """
+        try:
+            model_runtime_source = ModelRuntimeSource(
+                build_id=build_id,
+                deployment_id=deployment_id,
+                model_id=model_id,
+                model_group_name=model_group_name,
+            )
+
+            response = self.read_logs(
+                source=LogSource(model_runtime=model_runtime_source),
+                before_offset=before_offset,
+                after_offset=after_offset,
+                log_text_filter=log_text_filter,
+                max_number_of_results=max_number_of_results,
+            )
+
+            return response
+        except FrogmlException as e:
+            raise FrogmlException(f"Failed to fetch runtime logs, error is [{e}]")
+
+    def read_execution_models_logs(
+        self,
+        execution_id: str,
+        before_offset: Optional[str] = None,
+        after_offset: Optional[str] = None,
+        max_number_of_results: Optional[int] = None,
+        log_text_filter: Optional[str] = None,
+        model_id: Optional[str] = None,
+        model_group_name: Optional[str] = None,
+    ) -> ReadLogsResponse:
+        """
+        Read logs for a model inference execution (batch job).
+
+        Args:
+            execution_id: The execution/inference job ID to fetch logs for
+            before_offset: Optional offset to read logs before this point
+            after_offset: Optional offset to read logs after this point
+            max_number_of_results: Optional maximum number of log lines to return
+            log_text_filter: Optional text filter to search for in logs
+            model_id: The model ID. This is the display name(identifier), not the UUID.
+            model_group_name: The model group name.
+
+        Returns:
+            ReadLogsResponse containing the log lines
+
+        Raises:
+            FrogmlException: If reading logs fails
+        """
+        try:
+            inference_execution_source = InferenceExecutionSource(
+                inference_job_id=execution_id,
+                model_id=model_id,
+                model_group_name=model_group_name,
+            )
+
+            response = self.read_logs(
+                source=LogSource(inference_execution=inference_execution_source),
+                before_offset=before_offset,
+                after_offset=after_offset,
+                log_text_filter=log_text_filter,
+                max_number_of_results=max_number_of_results,
+            )
+
+            return response
+        except FrogmlException as e:
+            raise FrogmlException(f"Failed to fetch execution logs, error is [{e}]")
+
+    @grpc_try_catch_wrapper("Failed to read logs request")
+    def read_logs(
+        self,
+        source: LogSource,
+        before_offset: Optional[str],
+        after_offset: Optional[str],
+        max_number_of_results: Optional[int],
+        log_text_filter: Optional[str],
+    ) -> ReadLogsResponse:
+        """
+        Low-level method to read logs from any source.
+
+        Args:
+            source: The log source to read from
+            before_offset: Optional offset to read logs before this point
+            after_offset: Optional offset to read logs after this point
+            max_number_of_results: Optional maximum number of log lines to return
+            log_text_filter: Optional text filter to search for in logs
+
+        Returns:
+            ReadLogsResponse containing the log lines
+        """
+        response: ReadLogsResponse = self._logging_service.ReadLogs(
+            ReadLogsRequest(
+                source=source,
+                before_offset=before_offset,
+                after_offset=after_offset,
+                search_filter=SearchFilter(
+                    log_text_filter=LogText(contains=log_text_filter)
+                ),
+                max_number_of_results=max_number_of_results,
+            )
+        )
+        return response

{frogml-1.2.37 → frogml-1.2.38}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "frogml"
-version = "1.2.37"
+version = "1.2.38"
 description = "frogml contains the necessary objects and communication tools for using the JFrog ml Platform"
 authors = ["JFrog"]
 readme = "README.md"

frogml-1.2.37/frogml/core/clients/logging_client/client.py

@@ -1,142 +0,0 @@
-from typing import Optional
-
-from frogml._proto.qwak.logging.log_filter_pb2 import LogText, SearchFilter
-from frogml._proto.qwak.logging.log_reader_service_pb2 import (
-    ReadLogsRequest,
-    ReadLogsResponse,
-)
-from frogml._proto.qwak.logging.log_reader_service_pb2_grpc import LogReaderServiceStub
-from frogml._proto.qwak.logging.log_source_pb2 import (
-    InferenceExecutionSource,
-    LogSource,
-    ModelRuntimeSource,
-    RemoteBuildSource,
-)
-from frogml.core.clients.administration.eco_system.client import EcosystemClient
-from frogml.core.exceptions import FrogmlException
-from frogml.core.inner.tool.grpc.grpc_tools import create_grpc_channel
-from frogml.core.inner.tool.grpc.grpc_try_wrapping import grpc_try_catch_wrapper
-
-
-class LoggingClient:
-    """
-    Used for interacting with Logging endpoint
-    """
-
-    def __init__(
-        self,
-        endpoint_url: Optional[str] = None,
-        enable_ssl: bool = True,
-        environment_id: Optional[str] = None,
-    ):
-        if endpoint_url is None:
-            user_context = EcosystemClient().get_authenticated_user_context().user
-            if environment_id is None:
-                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
-
-        self._channel = create_grpc_channel(url=endpoint_url, enable_ssl=enable_ssl)
-
-        self._logging_service = LogReaderServiceStub(self._channel)
-
-    def read_build_logs(
-        self,
-        build_id=None,
-        before_offset=None,
-        after_offset=None,
-        max_number_of_results=None,
-        log_text_filter=None,
-    ):
-        try:
-            response = self.read_logs(
-                source=LogSource(remote_build=RemoteBuildSource(build_id=build_id)),
-                before_offset=before_offset,
-                after_offset=after_offset,
-                log_text_filter=log_text_filter,
-                max_number_of_results=max_number_of_results,
-            )
-
-            return response
-        except FrogmlException as e:
-            raise FrogmlException(f"Failed to fetch build logs, error is [{e}]")
-
-    def read_model_runtime_logs(
-        self,
-        build_id=None,
-        deployment_id=None,
-        before_offset=None,
-        after_offset=None,
-        max_number_of_results=None,
-        log_text_filter=None,
-    ) -> ReadLogsResponse:
-        try:
-            response = self.read_logs(
-                source=LogSource(
-                    model_runtime=ModelRuntimeSource(
-                        build_id=build_id, deployment_id=deployment_id
-                    )
-                ),
-                before_offset=before_offset,
-                after_offset=after_offset,
-                log_text_filter=log_text_filter,
-                max_number_of_results=max_number_of_results,
-            )
-
-            return response
-        except FrogmlException as e:
-            raise FrogmlException(f"Failed to fetch runtime logs, error is [{e}]")
-
-    def read_execution_models_logs(
-        self,
-        execution_id,
-        before_offset=None,
-        after_offset=None,
-        max_number_of_results=None,
-        log_text_filter=None,
-    ) -> ReadLogsResponse:
-        try:
-            response = self.read_logs(
-                source=LogSource(
-                    inference_execution=InferenceExecutionSource(
-                        inference_job_id=execution_id
-                    )
-                ),
-                before_offset=before_offset,
-                after_offset=after_offset,
-                log_text_filter=log_text_filter,
-                max_number_of_results=max_number_of_results,
-            )
-
-            return response
-        except FrogmlException as e:
-            raise FrogmlException(f"Failed to fetch execution logs, error is [{e}]")
-
-    @grpc_try_catch_wrapper("Failed to read logs request")
-    def read_logs(
-        self,
-        source,
-        before_offset,
-        after_offset,
-        max_number_of_results,
-        log_text_filter,
-    ) -> ReadLogsResponse:
-        response: ReadLogsResponse = self._logging_service.ReadLogs(
-            ReadLogsRequest(
-                source=source,
-                before_offset=before_offset,
-                after_offset=after_offset,
-                search_filter=SearchFilter(
-                    log_text_filter=LogText(contains=log_text_filter)
-                ),
-                max_number_of_results=max_number_of_results,
-            )
-        )
-        return response