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

mlrun/api/api/endpoints/schedules.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.
@@ -20,23 +20,24 @@ from fastapi.concurrency import run_in_threadpool
 from sqlalchemy.orm import Session
 
 import mlrun.api.api.utils
+import mlrun.api.crud
 import mlrun.api.utils.auth.verifier
 import mlrun.api.utils.clients.chief
 import mlrun.api.utils.singletons.project_member
-from mlrun.api import schemas
+import mlrun.common.schemas
 from mlrun.api.api import deps
 from mlrun.api.utils.singletons.scheduler import get_scheduler
 from mlrun.utils import logger
 
-router = APIRouter()
+router = APIRouter(prefix="/projects/{project}/schedules")
 
 
-@router.post("/projects/{project}/schedules")
+@router.post("")
 async def create_schedule(
     project: str,
-    schedule: schemas.ScheduleInput,
+    schedule: mlrun.common.schemas.ScheduleInput,
     request: fastapi.Request,
-    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(
@@ -46,16 +47,16 @@ async def create_schedule(
         auth_info=auth_info,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.schedule,
+        mlrun.common.schemas.AuthorizationResourceTypes.schedule,
         project,
         schedule.name,
-        mlrun.api.schemas.AuthorizationAction.create,
+        mlrun.common.schemas.AuthorizationAction.create,
         auth_info,
     )
     # to reduce redundant load on the chief, we re-route the request only if the user has permissions
     if (
         mlrun.mlconf.httpdb.clusterization.role
-        != mlrun.api.schemas.ClusterizationRole.chief
+        != mlrun.common.schemas.ClusterizationRole.chief
     ):
         logger.info(
             "Requesting to create schedule, re-routing to chief",
@@ -86,26 +87,26 @@ async def create_schedule(
     return Response(status_code=HTTPStatus.CREATED.value)
 
 
-@router.put("/projects/{project}/schedules/{name}")
+@router.put("/{name}")
 async def update_schedule(
     project: str,
     name: str,
-    schedule: schemas.ScheduleUpdate,
+    schedule: mlrun.common.schemas.ScheduleUpdate,
     request: fastapi.Request,
-    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.schedule,
+        mlrun.common.schemas.AuthorizationResourceTypes.schedule,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.update,
+        mlrun.common.schemas.AuthorizationAction.update,
         auth_info,
     )
     # to reduce redundant load on the chief, we re-route the request only if the user has permissions
     if (
         mlrun.mlconf.httpdb.clusterization.role
-        != mlrun.api.schemas.ClusterizationRole.chief
+        != mlrun.common.schemas.ClusterizationRole.chief
     ):
         logger.info(
             "Requesting to update schedule, re-routing to chief",
@@ -136,20 +137,20 @@ async def update_schedule(
     return Response(status_code=HTTPStatus.OK.value)
 
 
-@router.get("/projects/{project}/schedules", response_model=schemas.SchedulesOutput)
+@router.get("", response_model=mlrun.common.schemas.SchedulesOutput)
 async def list_schedules(
     project: str,
     name: str = None,
     labels: str = None,
-    kind: schemas.ScheduleKinds = None,
+    kind: mlrun.common.schemas.ScheduleKinds = None,
     include_last_run: bool = False,
     include_credentials: bool = fastapi.Query(False, alias="include-credentials"),
-    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_permissions(
         project,
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )
     schedules = await run_in_threadpool(
@@ -163,7 +164,7 @@ async def list_schedules(
         include_credentials,
     )
     filtered_schedules = await mlrun.api.utils.auth.verifier.AuthVerifier().filter_project_resources_by_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.schedule,
+        mlrun.common.schemas.AuthorizationResourceTypes.schedule,
         schedules.schedules,
         lambda schedule: (
             schedule.project,
@@ -176,14 +177,15 @@ async def list_schedules(
 
 
 @router.get(
-    "/projects/{project}/schedules/{name}", response_model=schemas.ScheduleOutput
+    "/{name}",
+    response_model=mlrun.common.schemas.ScheduleOutput,
 )
 async def get_schedule(
     project: str,
     name: str,
     include_last_run: bool = False,
     include_credentials: bool = fastapi.Query(False, alias="include-credentials"),
-    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),
 ):
     schedule = await run_in_threadpool(
@@ -195,34 +197,34 @@ async def get_schedule(
         include_credentials,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.schedule,
+        mlrun.common.schemas.AuthorizationResourceTypes.schedule,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )
     return schedule
 
 
-@router.post("/projects/{project}/schedules/{name}/invoke")
+@router.post("/{name}/invoke")
 async def invoke_schedule(
     project: str,
     name: str,
     request: fastapi.Request,
-    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.schedule,
+        mlrun.common.schemas.AuthorizationResourceTypes.schedule,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.update,
+        mlrun.common.schemas.AuthorizationAction.update,
         auth_info,
     )
     # to reduce redundant load on the chief, we re-route the request only if the user has permissions
     if (
         mlrun.mlconf.httpdb.clusterization.role
-        != mlrun.api.schemas.ClusterizationRole.chief
+        != mlrun.common.schemas.ClusterizationRole.chief
     ):
         logger.info(
             "Requesting to invoke schedule, re-routing to chief",
@@ -237,27 +239,25 @@ async def invoke_schedule(
     return await get_scheduler().invoke_schedule(db_session, auth_info, project, name)
 
 
-@router.delete(
-    "/projects/{project}/schedules/{name}", status_code=HTTPStatus.NO_CONTENT.value
-)
+@router.delete("/{name}", status_code=HTTPStatus.NO_CONTENT.value)
 async def delete_schedule(
     project: str,
     name: str,
     request: fastapi.Request,
-    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.schedule,
+        mlrun.common.schemas.AuthorizationResourceTypes.schedule,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.delete,
+        mlrun.common.schemas.AuthorizationAction.delete,
         auth_info,
     )
     # to reduce redundant load on the chief, we re-route the request only if the user has permissions
     if (
         mlrun.mlconf.httpdb.clusterization.role
-        != mlrun.api.schemas.ClusterizationRole.chief
+        != mlrun.common.schemas.ClusterizationRole.chief
     ):
         logger.info(
             "Requesting to delete schedule, re-routing to chief",
@@ -273,11 +273,11 @@ async def delete_schedule(
     return Response(status_code=HTTPStatus.NO_CONTENT.value)
 
 
-@router.delete("/projects/{project}/schedules", status_code=HTTPStatus.NO_CONTENT.value)
+@router.delete("", status_code=HTTPStatus.NO_CONTENT.value)
 async def delete_schedules(
     project: str,
     request: fastapi.Request,
-    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),
 ):
     schedules = await run_in_threadpool(
@@ -286,16 +286,16 @@ async def delete_schedules(
         project,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resources_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.schedule,
+        mlrun.common.schemas.AuthorizationResourceTypes.schedule,
         schedules.schedules,
         lambda schedule: (schedule.project, schedule.name),
-        mlrun.api.schemas.AuthorizationAction.delete,
+        mlrun.common.schemas.AuthorizationAction.delete,
         auth_info,
     )
     # to reduce redundant load on the chief, we re-route the request only if the user has permissions
     if (
         mlrun.mlconf.httpdb.clusterization.role
-        != mlrun.api.schemas.ClusterizationRole.chief
+        != mlrun.common.schemas.ClusterizationRole.chief
     ):
         logger.info(
             "Requesting to delete all project schedules, re-routing to chief",
@@ -306,3 +306,60 @@ async def delete_schedules(
 
     await run_in_threadpool(get_scheduler().delete_schedules, db_session, project)
     return Response(status_code=HTTPStatus.NO_CONTENT.value)
+
+
+@router.put("/{name}/notifications", status_code=HTTPStatus.OK.value)
+async def set_schedule_notifications(
+    project: str,
+    name: str,
+    request: fastapi.Request,
+    set_notifications_request: mlrun.common.schemas.SetNotificationRequest = fastapi.Body(
+        ...
+    ),
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
+        mlrun.api.api.deps.authenticate_request
+    ),
+    db_session: Session = fastapi.Depends(mlrun.api.api.deps.get_db_session),
+):
+    await fastapi.concurrency.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.schedule,
+        project,
+        resource_name=name,
+        action=mlrun.common.schemas.AuthorizationAction.update,
+        auth_info=auth_info,
+    )
+
+    if (
+        mlrun.mlconf.httpdb.clusterization.role
+        != mlrun.common.schemas.ClusterizationRole.chief
+    ):
+        logger.info(
+            "Requesting to set schedule notifications, re-routing to chief",
+            project=project,
+            schedule=set_notifications_request.dict(),
+        )
+        chief_client = mlrun.api.utils.clients.chief.Client()
+        return await chief_client.set_schedule_notifications(
+            project=project,
+            schedule_name=name,
+            request=request,
+            json=set_notifications_request.dict(),
+        )
+
+    await fastapi.concurrency.run_in_threadpool(
+        mlrun.api.crud.Notifications().set_object_notifications,
+        db_session,
+        auth_info,
+        project,
+        set_notifications_request.notifications,
+        mlrun.common.schemas.ScheduleIdentifier(name=name),
+    )
+    return fastapi.Response(status_code=HTTPStatus.OK.value)

mlrun/api/api/endpoints/secrets.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,9 +23,8 @@ import mlrun.api.api.deps
 import mlrun.api.crud
 import mlrun.api.utils.auth.verifier
 import mlrun.api.utils.singletons.project_member
+import mlrun.common.schemas
 import mlrun.errors
-from mlrun.api import schemas
-from mlrun.utils.vault import add_vault_user_secrets
 
 router = fastapi.APIRouter()
 
@@ -33,8 +32,8 @@ router = fastapi.APIRouter()
 @router.post("/projects/{project}/secrets", status_code=HTTPStatus.CREATED.value)
 async def store_project_secrets(
     project: str,
-    secrets: schemas.SecretsData,
-    auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends(
+    secrets: mlrun.common.schemas.SecretsData,
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
         mlrun.api.api.deps.authenticate_request
     ),
     db_session: Session = fastapi.Depends(mlrun.api.api.deps.get_db_session),
@@ -50,10 +49,10 @@ async def store_project_secrets(
     )
 
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.secret,
+        mlrun.common.schemas.AuthorizationResourceTypes.secret,
         project,
         secrets.provider,
-        mlrun.api.schemas.AuthorizationAction.create,
+        mlrun.common.schemas.AuthorizationAction.create,
         auth_info,
     )
     await run_in_threadpool(
@@ -66,9 +65,9 @@ async def store_project_secrets(
 @router.delete("/projects/{project}/secrets", status_code=HTTPStatus.NO_CONTENT.value)
 async def delete_project_secrets(
     project: str,
-    provider: schemas.SecretProviderName = schemas.SecretProviderName.kubernetes,
+    provider: mlrun.common.schemas.SecretProviderName = mlrun.common.schemas.SecretProviderName.kubernetes,
     secrets: List[str] = fastapi.Query(None, alias="secret"),
-    auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends(
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
         mlrun.api.api.deps.authenticate_request
     ),
     db_session: Session = fastapi.Depends(mlrun.api.api.deps.get_db_session),
@@ -81,10 +80,10 @@ async def delete_project_secrets(
     )
 
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.secret,
+        mlrun.common.schemas.AuthorizationResourceTypes.secret,
         project,
         provider,
-        mlrun.api.schemas.AuthorizationAction.delete,
+        mlrun.common.schemas.AuthorizationAction.delete,
         auth_info,
     )
     await run_in_threadpool(
@@ -94,12 +93,17 @@ async def delete_project_secrets(
     return fastapi.Response(status_code=HTTPStatus.NO_CONTENT.value)
 
 
-@router.get("/projects/{project}/secret-keys", response_model=schemas.SecretKeysData)
+@router.get(
+    "/projects/{project}/secret-keys",
+    response_model=mlrun.common.schemas.SecretKeysData,
+)
 async def list_project_secret_keys(
     project: str,
-    provider: schemas.SecretProviderName = schemas.SecretProviderName.kubernetes,
-    token: str = fastapi.Header(None, alias=schemas.HeaderNames.secret_store_token),
-    auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends(
+    provider: mlrun.common.schemas.SecretProviderName = mlrun.common.schemas.SecretProviderName.kubernetes,
+    token: str = fastapi.Header(
+        None, alias=mlrun.common.schemas.HeaderNames.secret_store_token
+    ),
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
         mlrun.api.api.deps.authenticate_request
     ),
     db_session: Session = fastapi.Depends(mlrun.api.api.deps.get_db_session),
@@ -111,10 +115,10 @@ async def list_project_secret_keys(
         auth_info.session,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.secret,
+        mlrun.common.schemas.AuthorizationResourceTypes.secret,
         project,
         provider,
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )
     return await run_in_threadpool(
@@ -122,13 +126,17 @@ async def list_project_secret_keys(
     )
 
 
-@router.get("/projects/{project}/secrets", response_model=schemas.SecretsData)
+@router.get(
+    "/projects/{project}/secrets", response_model=mlrun.common.schemas.SecretsData
+)
 async def list_project_secrets(
     project: str,
     secrets: List[str] = fastapi.Query(None, alias="secret"),
-    provider: schemas.SecretProviderName = schemas.SecretProviderName.kubernetes,
-    token: str = fastapi.Header(None, alias=schemas.HeaderNames.secret_store_token),
-    auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends(
+    provider: mlrun.common.schemas.SecretProviderName = mlrun.common.schemas.SecretProviderName.kubernetes,
+    token: str = fastapi.Header(
+        None, alias=mlrun.common.schemas.HeaderNames.secret_store_token
+    ),
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
         mlrun.api.api.deps.authenticate_request
     ),
     db_session: Session = fastapi.Depends(mlrun.api.api.deps.get_db_session),
@@ -140,10 +148,10 @@ async def list_project_secrets(
         auth_info.session,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.secret,
+        mlrun.common.schemas.AuthorizationResourceTypes.secret,
         project,
         provider,
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )
     return await run_in_threadpool(
@@ -153,13 +161,10 @@ async def list_project_secrets(
 
 @router.post("/user-secrets", status_code=HTTPStatus.CREATED.value)
 def add_user_secrets(
-    secrets: schemas.UserSecretCreationRequest,
+    secrets: mlrun.common.schemas.UserSecretCreationRequest,
 ):
-    if secrets.provider != schemas.SecretProviderName.vault:
-        return fastapi.Response(
-            status_code=HTTPStatus.BAD_REQUEST.vault,
-            content=f"Invalid secrets provider {secrets.provider}",
-        )
-
-    add_vault_user_secrets(secrets.user, secrets.secrets)
-    return fastapi.Response(status_code=HTTPStatus.CREATED.value)
+    # vault is not used
+    return fastapi.Response(
+        status_code=HTTPStatus.BAD_REQUEST.value,
+        content=f"Invalid secrets provider {secrets.provider}",
+    )

mlrun/api/api/endpoints/submit.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.
@@ -20,10 +20,10 @@ from fastapi import APIRouter, Depends, Header, Request
 from sqlalchemy.orm import Session
 
 import mlrun.api.api.utils
-import mlrun.api.schemas
 import mlrun.api.utils.auth.verifier
 import mlrun.api.utils.clients.chief
 import mlrun.api.utils.singletons.project_member
+import mlrun.common.schemas
 import mlrun.utils.helpers
 from mlrun.api.api import deps
 from mlrun.utils import logger
@@ -38,13 +38,13 @@ router = APIRouter()
 async def submit_job(
     request: Request,
     username: Optional[str] = Header(None, alias="x-remote-user"),
-    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),
     client_version: Optional[str] = Header(
-        None, alias=mlrun.api.schemas.HeaderNames.client_version
+        None, alias=mlrun.common.schemas.HeaderNames.client_version
     ),
     client_python_version: Optional[str] = Header(
-        None, alias=mlrun.api.schemas.HeaderNames.python_version
+        None, alias=mlrun.common.schemas.HeaderNames.python_version
     ),
 ):
     data = None
@@ -70,18 +70,18 @@ async def submit_job(
             _,
         ) = mlrun.utils.helpers.parse_versioned_object_uri(function_url)
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-            mlrun.api.schemas.AuthorizationResourceTypes.function,
+            mlrun.common.schemas.AuthorizationResourceTypes.function,
             function_project,
             function_name,
-            mlrun.api.schemas.AuthorizationAction.read,
+            mlrun.common.schemas.AuthorizationAction.read,
             auth_info,
         )
     if data.get("schedule"):
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-            mlrun.api.schemas.AuthorizationResourceTypes.schedule,
+            mlrun.common.schemas.AuthorizationResourceTypes.schedule,
             data["task"]["metadata"]["project"],
             data["task"]["metadata"]["name"],
-            mlrun.api.schemas.AuthorizationAction.create,
+            mlrun.common.schemas.AuthorizationAction.create,
             auth_info,
         )
         # schedules are meant to be run solely by the chief, then if run is configured to run as scheduled
@@ -89,7 +89,7 @@ async def submit_job(
         # to reduce redundant load on the chief, we re-route the request only if the user has permissions
         if (
             mlrun.mlconf.httpdb.clusterization.role
-            != mlrun.api.schemas.ClusterizationRole.chief
+            != mlrun.common.schemas.ClusterizationRole.chief
         ):
             logger.info(
                 "Requesting to submit job with schedules, re-routing to chief",
@@ -102,10 +102,10 @@ async def submit_job(
 
     else:
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-            mlrun.api.schemas.AuthorizationResourceTypes.run,
+            mlrun.common.schemas.AuthorizationResourceTypes.run,
             data["task"]["metadata"]["project"],
             "",
-            mlrun.api.schemas.AuthorizationAction.create,
+            mlrun.common.schemas.AuthorizationAction.create,
             auth_info,
         )
 

mlrun/api/api/endpoints/tags.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.
@@ -20,20 +20,20 @@ import sqlalchemy.orm
 
 import mlrun.api.api.deps
 import mlrun.api.crud.tags
-import mlrun.api.schemas
 import mlrun.api.utils.auth.verifier
 import mlrun.api.utils.singletons.project_member
+import mlrun.common.schemas
 from mlrun.utils.helpers import tag_name_regex_as_string
 
-router = fastapi.APIRouter()
+router = fastapi.APIRouter(prefix="/projects/{project}/tags")
 
 
-@router.post("/projects/{project}/tags/{tag}", response_model=mlrun.api.schemas.Tag)
+@router.post("/{tag}", response_model=mlrun.common.schemas.Tag)
 async def overwrite_object_tags_with_tag(
     project: str,
     tag: str = fastapi.Path(..., regex=tag_name_regex_as_string()),
-    tag_objects: mlrun.api.schemas.TagObjects = fastapi.Body(...),
-    auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends(
+    tag_objects: mlrun.common.schemas.TagObjects = fastapi.Body(...),
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
         mlrun.api.api.deps.authenticate_request
     ),
     db_session: sqlalchemy.orm.Session = fastapi.Depends(
@@ -49,11 +49,11 @@ async def overwrite_object_tags_with_tag(
 
     # check permission per object type
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        getattr(mlrun.api.schemas.AuthorizationResourceTypes, tag_objects.kind),
+        getattr(mlrun.common.schemas.AuthorizationResourceTypes, tag_objects.kind),
         project,
         resource_name="",
         # not actually overwriting objects, just overwriting the objects tags
-        action=mlrun.api.schemas.AuthorizationAction.update,
+        action=mlrun.common.schemas.AuthorizationAction.update,
         auth_info=auth_info,
     )
 
@@ -64,15 +64,15 @@ async def overwrite_object_tags_with_tag(
         tag,
         tag_objects,
     )
-    return mlrun.api.schemas.Tag(name=tag, project=project)
+    return mlrun.common.schemas.Tag(name=tag, project=project)
 
 
-@router.put("/projects/{project}/tags/{tag}", response_model=mlrun.api.schemas.Tag)
+@router.put("/{tag}", response_model=mlrun.common.schemas.Tag)
 async def append_tag_to_objects(
     project: str,
     tag: str = fastapi.Path(..., regex=tag_name_regex_as_string()),
-    tag_objects: mlrun.api.schemas.TagObjects = fastapi.Body(...),
-    auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends(
+    tag_objects: mlrun.common.schemas.TagObjects = fastapi.Body(...),
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
         mlrun.api.api.deps.authenticate_request
     ),
     db_session: sqlalchemy.orm.Session = fastapi.Depends(
@@ -87,10 +87,10 @@ async def append_tag_to_objects(
     )
 
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        getattr(mlrun.api.schemas.AuthorizationResourceTypes, tag_objects.kind),
+        getattr(mlrun.common.schemas.AuthorizationResourceTypes, tag_objects.kind),
         project,
         resource_name="",
-        action=mlrun.api.schemas.AuthorizationAction.update,
+        action=mlrun.common.schemas.AuthorizationAction.update,
         auth_info=auth_info,
     )
 
@@ -101,17 +101,15 @@ async def append_tag_to_objects(
         tag,
         tag_objects,
     )
-    return mlrun.api.schemas.Tag(name=tag, project=project)
+    return mlrun.common.schemas.Tag(name=tag, project=project)
 
 
-@router.delete(
-    "/projects/{project}/tags/{tag}", status_code=http.HTTPStatus.NO_CONTENT.value
-)
+@router.delete("/{tag}", status_code=http.HTTPStatus.NO_CONTENT.value)
 async def delete_tag_from_objects(
     project: str,
     tag: str,
-    tag_objects: mlrun.api.schemas.TagObjects,
-    auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends(
+    tag_objects: mlrun.common.schemas.TagObjects,
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
         mlrun.api.api.deps.authenticate_request
     ),
     db_session: sqlalchemy.orm.Session = fastapi.Depends(
@@ -126,11 +124,11 @@ async def delete_tag_from_objects(
     )
 
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        getattr(mlrun.api.schemas.AuthorizationResourceTypes, tag_objects.kind),
+        getattr(mlrun.common.schemas.AuthorizationResourceTypes, tag_objects.kind),
         project,
         resource_name="",
         # not actually deleting objects, just deleting the objects tags
-        action=mlrun.api.schemas.AuthorizationAction.update,
+        action=mlrun.common.schemas.AuthorizationAction.update,
         auth_info=auth_info,
     )