mlrun 1.3.3__py3-none-any.whl → 1.4.0__py3-none-any.whl

mlrun/api/api/endpoints/runs.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,14 +16,14 @@ import datetime
 from http import HTTPStatus
 from typing import List
 
-from fastapi import APIRouter, Depends, Query, Request
+from fastapi import APIRouter, Body, Depends, Query, Request, Response
 from fastapi.concurrency import run_in_threadpool
 from sqlalchemy.orm import Session
 
 import mlrun.api.crud
-import mlrun.api.schemas
 import mlrun.api.utils.auth.verifier
 import mlrun.api.utils.singletons.project_member
+import mlrun.common.schemas
 from mlrun.api.api import deps
 from mlrun.api.api.utils import log_and_raise
 from mlrun.utils.helpers import datetime_from_iso
@@ -37,7 +37,7 @@ async def store_run(
     project: str,
     uid: str,
     iter: int = 0,
-    auth_info: mlrun.api.schemas.AuthInfo = Depends(deps.authenticate_request),
+    auth_info: mlrun.common.schemas.AuthInfo = Depends(deps.authenticate_request),
     db_session: Session = Depends(deps.get_db_session),
 ):
     await run_in_threadpool(
@@ -47,10 +47,10 @@ async def store_run(
         auth_info=auth_info,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.run,
+        mlrun.common.schemas.AuthorizationResourceTypes.run,
         project,
         uid,
-        mlrun.api.schemas.AuthorizationAction.store,
+        mlrun.common.schemas.AuthorizationAction.store,
         auth_info,
     )
     data = None
@@ -76,14 +76,14 @@ async def update_run(
     project: str,
     uid: str,
     iter: int = 0,
-    auth_info: mlrun.api.schemas.AuthInfo = Depends(deps.authenticate_request),
+    auth_info: mlrun.common.schemas.AuthInfo = Depends(deps.authenticate_request),
     db_session: Session = Depends(deps.get_db_session),
 ):
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.run,
+        mlrun.common.schemas.AuthorizationResourceTypes.run,
         project,
         uid,
-        mlrun.api.schemas.AuthorizationAction.update,
+        mlrun.common.schemas.AuthorizationAction.update,
         auth_info,
     )
     data = None
@@ -108,17 +108,17 @@ async def get_run(
     project: str,
     uid: str,
     iter: int = 0,
-    auth_info: mlrun.api.schemas.AuthInfo = Depends(deps.authenticate_request),
+    auth_info: mlrun.common.schemas.AuthInfo = Depends(deps.authenticate_request),
     db_session: Session = Depends(deps.get_db_session),
 ):
     data = await run_in_threadpool(
         mlrun.api.crud.Runs().get_run, db_session, uid, iter, project
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.run,
+        mlrun.common.schemas.AuthorizationResourceTypes.run,
         project,
         uid,
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )
     return {
@@ -131,14 +131,14 @@ async def delete_run(
     project: str,
     uid: str,
     iter: int = 0,
-    auth_info: mlrun.api.schemas.AuthInfo = Depends(deps.authenticate_request),
+    auth_info: mlrun.common.schemas.AuthInfo = Depends(deps.authenticate_request),
     db_session: Session = Depends(deps.get_db_session),
 ):
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.run,
+        mlrun.common.schemas.AuthorizationResourceTypes.run,
         project,
         uid,
-        mlrun.api.schemas.AuthorizationAction.delete,
+        mlrun.common.schemas.AuthorizationAction.delete,
         auth_info,
     )
     await run_in_threadpool(
@@ -165,24 +165,25 @@ async def list_runs(
     start_time_to: str = None,
     last_update_time_from: str = None,
     last_update_time_to: str = None,
-    partition_by: mlrun.api.schemas.RunPartitionByField = Query(
+    partition_by: mlrun.common.schemas.RunPartitionByField = Query(
         None, alias="partition-by"
     ),
     rows_per_partition: int = Query(1, alias="rows-per-partition", gt=0),
-    partition_sort_by: mlrun.api.schemas.SortField = Query(
+    partition_sort_by: mlrun.common.schemas.SortField = Query(
         None, alias="partition-sort-by"
     ),
-    partition_order: mlrun.api.schemas.OrderType = Query(
-        mlrun.api.schemas.OrderType.desc, alias="partition-order"
+    partition_order: mlrun.common.schemas.OrderType = Query(
+        mlrun.common.schemas.OrderType.desc, alias="partition-order"
     ),
     max_partitions: int = Query(0, alias="max-partitions", ge=0),
-    auth_info: mlrun.api.schemas.AuthInfo = Depends(deps.authenticate_request),
+    with_notifications: bool = Query(False, alias="with-notifications"),
+    auth_info: mlrun.common.schemas.AuthInfo = Depends(deps.authenticate_request),
     db_session: Session = Depends(deps.get_db_session),
 ):
     if project != "*":
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_permissions(
             project,
-            mlrun.api.schemas.AuthorizationAction.read,
+            mlrun.common.schemas.AuthorizationAction.read,
             auth_info,
         )
     runs = await run_in_threadpool(
@@ -205,9 +206,10 @@ async def list_runs(
         partition_sort_by,
         partition_order,
         max_partitions,
+        with_notifications=with_notifications,
     )
     filtered_runs = await mlrun.api.utils.auth.verifier.AuthVerifier().filter_project_resources_by_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.run,
+        mlrun.common.schemas.AuthorizationResourceTypes.run,
         runs,
         lambda run: (
             run.get("metadata", {}).get("project", mlrun.mlconf.default_project),
@@ -227,7 +229,7 @@ async def delete_runs(
     labels: List[str] = Query([], alias="label"),
     state: str = None,
     days_ago: int = None,
-    auth_info: mlrun.api.schemas.AuthInfo = Depends(deps.authenticate_request),
+    auth_info: mlrun.common.schemas.AuthInfo = Depends(deps.authenticate_request),
     db_session: Session = Depends(deps.get_db_session),
 ):
     if not project or project != "*":
@@ -235,10 +237,10 @@ async def delete_runs(
         # Meaning there is no reason at the moment to query the permission for each run under the project
         # TODO check for every run when we will manage permission per run inside a project
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-            mlrun.api.schemas.AuthorizationResourceTypes.run,
+            mlrun.common.schemas.AuthorizationResourceTypes.run,
             project or mlrun.mlconf.default_project,
             "",
-            mlrun.api.schemas.AuthorizationAction.delete,
+            mlrun.common.schemas.AuthorizationAction.delete,
             auth_info,
         )
     else:
@@ -264,10 +266,10 @@ async def delete_runs(
             # currently we fail if the user doesn't has permissions to delete runs to one of the projects in the system
             # TODO Delete only runs from projects that user has permissions to
             await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-                mlrun.api.schemas.AuthorizationResourceTypes.run,
+                mlrun.common.schemas.AuthorizationResourceTypes.run,
                 run_project,
                 "",
-                mlrun.api.schemas.AuthorizationAction.delete,
+                mlrun.common.schemas.AuthorizationAction.delete,
                 auth_info,
             )
 
@@ -281,3 +283,43 @@ async def delete_runs(
         days_ago,
     )
     return {}
+
+
+@router.put(
+    "/projects/{project}/runs/{uid}/notifications",
+    status_code=HTTPStatus.OK.value,
+)
+async def set_run_notifications(
+    project: str,
+    uid: str,
+    set_notifications_request: mlrun.common.schemas.SetNotificationRequest = Body(...),
+    auth_info: mlrun.common.schemas.AuthInfo = Depends(
+        mlrun.api.api.deps.authenticate_request
+    ),
+    db_session: Session = Depends(mlrun.api.api.deps.get_db_session),
+):
+    await run_in_threadpool(
+        mlrun.api.utils.singletons.project_member.get_project_member().ensure_project,
+        db_session,
+        project,
+        auth_info=auth_info,
+    )
+
+    # check permission per object type
+    await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
+        mlrun.common.schemas.AuthorizationResourceTypes.run,
+        project,
+        resource_name=uid,
+        action=mlrun.common.schemas.AuthorizationAction.update,
+        auth_info=auth_info,
+    )
+
+    await run_in_threadpool(
+        mlrun.api.crud.Notifications().set_object_notifications,
+        db_session,
+        auth_info,
+        project,
+        set_notifications_request.notifications,
+        mlrun.common.schemas.RunIdentifier(uid=uid),
+    )
+    return Response(status_code=HTTPStatus.OK.value)

mlrun/api/api/endpoints/runtime_resources.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,18 +23,18 @@ from fastapi.concurrency import run_in_threadpool
 import mlrun
 import mlrun.api.api.deps
 import mlrun.api.crud
-import mlrun.api.schemas
 import mlrun.api.utils.auth.verifier
+import mlrun.common.schemas
 
-router = fastapi.APIRouter()
+router = fastapi.APIRouter(prefix="/projects/{project}/runtime-resources")
 
 
 @router.get(
-    "/projects/{project}/runtime-resources",
+    "",
     response_model=typing.Union[
-        mlrun.api.schemas.RuntimeResourcesOutput,
-        mlrun.api.schemas.GroupedByJobRuntimeResourcesOutput,
-        mlrun.api.schemas.GroupedByProjectRuntimeResourcesOutput,
+        mlrun.common.schemas.RuntimeResourcesOutput,
+        mlrun.common.schemas.GroupedByJobRuntimeResourcesOutput,
+        mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput,
     ],
 )
 async def list_runtime_resources(
@@ -43,9 +43,9 @@ async def list_runtime_resources(
     kind: typing.Optional[str] = None,
     object_id: typing.Optional[str] = fastapi.Query(None, alias="object-id"),
     group_by: typing.Optional[
-        mlrun.api.schemas.ListRuntimeResourcesGroupByField
+        mlrun.common.schemas.ListRuntimeResourcesGroupByField
     ] = fastapi.Query(None, alias="group-by"),
-    auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends(
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
         mlrun.api.api.deps.authenticate_request
     ),
 ):
@@ -55,8 +55,8 @@ async def list_runtime_resources(
 
 
 @router.delete(
-    "/projects/{project}/runtime-resources",
-    response_model=mlrun.api.schemas.GroupedByProjectRuntimeResourcesOutput,
+    "",
+    response_model=mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput,
 )
 async def delete_runtime_resources(
     project: str,
@@ -67,7 +67,7 @@ async def delete_runtime_resources(
     grace_period: int = fastapi.Query(
         mlrun.mlconf.runtime_resources_deletion_grace_period, alias="grace-period"
     ),
-    auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends(
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
         mlrun.api.api.deps.authenticate_request
     ),
     db_session: sqlalchemy.orm.Session = fastapi.Depends(
@@ -88,7 +88,7 @@ async def delete_runtime_resources(
 
 async def _delete_runtime_resources(
     db_session: sqlalchemy.orm.Session,
-    auth_info: mlrun.api.schemas.AuthInfo,
+    auth_info: mlrun.common.schemas.AuthInfo,
     project: str,
     label_selector: typing.Optional[str] = None,
     kind: typing.Optional[str] = None,
@@ -97,7 +97,7 @@ async def _delete_runtime_resources(
     grace_period: int = mlrun.mlconf.runtime_resources_deletion_grace_period,
     return_body: bool = True,
 ) -> typing.Union[
-    mlrun.api.schemas.GroupedByProjectRuntimeResourcesOutput, fastapi.Response
+    mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput, fastapi.Response
 ]:
     (
         allowed_projects,
@@ -110,7 +110,7 @@ async def _delete_runtime_resources(
         label_selector,
         kind,
         object_id,
-        mlrun.api.schemas.AuthorizationAction.delete,
+        mlrun.common.schemas.AuthorizationAction.delete,
     )
 
     # TODO: once we have more granular permissions, we should check if the user is allowed to delete the specific
@@ -162,7 +162,7 @@ async def _delete_runtime_resources(
         return mlrun.api.crud.RuntimeResources().filter_and_format_grouped_by_project_runtime_resources_output(
             grouped_by_project_runtime_resources_output,
             filtered_projects,
-            mlrun.api.schemas.ListRuntimeResourcesGroupByField.project,
+            mlrun.common.schemas.ListRuntimeResourcesGroupByField.project,
         )
     else:
         return fastapi.Response(status_code=http.HTTPStatus.NO_CONTENT.value)
@@ -170,17 +170,17 @@ async def _delete_runtime_resources(
 
 async def _list_runtime_resources(
     project: str,
-    auth_info: mlrun.api.schemas.AuthInfo,
+    auth_info: mlrun.common.schemas.AuthInfo,
     label_selector: typing.Optional[str] = None,
     group_by: typing.Optional[
-        mlrun.api.schemas.ListRuntimeResourcesGroupByField
+        mlrun.common.schemas.ListRuntimeResourcesGroupByField
     ] = None,
     kind_filter: typing.Optional[str] = None,
     object_id: typing.Optional[str] = None,
 ) -> typing.Union[
-    mlrun.api.schemas.RuntimeResourcesOutput,
-    mlrun.api.schemas.GroupedByJobRuntimeResourcesOutput,
-    mlrun.api.schemas.GroupedByProjectRuntimeResourcesOutput,
+    mlrun.common.schemas.RuntimeResourcesOutput,
+    mlrun.common.schemas.GroupedByJobRuntimeResourcesOutput,
+    mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput,
 ]:
     (
         allowed_projects,
@@ -199,31 +199,31 @@ async def _list_runtime_resources(
 
 async def _get_runtime_resources_allowed_projects(
     project: str,
-    auth_info: mlrun.api.schemas.AuthInfo,
+    auth_info: mlrun.common.schemas.AuthInfo,
     label_selector: typing.Optional[str] = None,
     kind: typing.Optional[str] = None,
     object_id: typing.Optional[str] = None,
-    action: mlrun.api.schemas.AuthorizationAction = mlrun.api.schemas.AuthorizationAction.read,
+    action: mlrun.common.schemas.AuthorizationAction = mlrun.common.schemas.AuthorizationAction.read,
 ) -> typing.Tuple[
     typing.List[str],
-    mlrun.api.schemas.GroupedByProjectRuntimeResourcesOutput,
+    mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput,
     bool,
     bool,
 ]:
     if project != "*":
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_permissions(
             project,
-            mlrun.api.schemas.AuthorizationAction.read,
+            mlrun.common.schemas.AuthorizationAction.read,
             auth_info,
         )
-    grouped_by_project_runtime_resources_output: mlrun.api.schemas.GroupedByProjectRuntimeResourcesOutput
+    grouped_by_project_runtime_resources_output: mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput
     grouped_by_project_runtime_resources_output = await run_in_threadpool(
         mlrun.api.crud.RuntimeResources().list_runtime_resources,
         project,
         kind,
         object_id,
         label_selector,
-        mlrun.api.schemas.ListRuntimeResourcesGroupByField.project,
+        mlrun.common.schemas.ListRuntimeResourcesGroupByField.project,
     )
 
     projects = []
@@ -237,7 +237,7 @@ async def _get_runtime_resources_allowed_projects(
             continue
         projects.append(project)
     allowed_projects = await mlrun.api.utils.auth.verifier.AuthVerifier().filter_project_resources_by_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.runtime_resource,
+        mlrun.common.schemas.AuthorizationResourceTypes.runtime_resource,
         projects,
         lambda project: (
             project,