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

mlrun/api/api/endpoints/feature_store.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,10 +23,10 @@ from sqlalchemy.orm import Session
 import mlrun.api.crud
 import mlrun.api.utils.auth.verifier
 import mlrun.api.utils.singletons.project_member
+import mlrun.common.schemas
 import mlrun.errors
 import mlrun.feature_store
 from mlrun import v3io_cred
-from mlrun.api import schemas
 from mlrun.api.api import deps
 from mlrun.api.api.utils import log_and_raise, parse_reference
 from mlrun.data_types import InferOptions
@@ -34,15 +34,15 @@ from mlrun.datastore.targets import get_default_prefix_for_target
 from mlrun.feature_store.api import RunConfig, ingest
 from mlrun.model import DataSource, DataTargetBase
 
-router = APIRouter()
+router = APIRouter(prefix="/projects/{project}")
 
 
-@router.post("/projects/{project}/feature-sets", response_model=schemas.FeatureSet)
+@router.post("/feature-sets", response_model=mlrun.common.schemas.FeatureSet)
 async def create_feature_set(
     project: str,
-    feature_set: schemas.FeatureSet,
+    feature_set: mlrun.common.schemas.FeatureSet,
     versioned: bool = True,
-    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(
@@ -52,10 +52,10 @@ async def create_feature_set(
         auth_info=auth_info,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_set,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_set,
         project,
         feature_set.metadata.name,
-        mlrun.api.schemas.AuthorizationAction.create,
+        mlrun.common.schemas.AuthorizationAction.create,
         auth_info,
     )
     feature_set_uid = await run_in_threadpool(
@@ -77,16 +77,16 @@ async def create_feature_set(
 
 
 @router.put(
-    "/projects/{project}/feature-sets/{name}/references/{reference}",
-    response_model=schemas.FeatureSet,
+    "/feature-sets/{name}/references/{reference}",
+    response_model=mlrun.common.schemas.FeatureSet,
 )
 async def store_feature_set(
     project: str,
     name: str,
     reference: str,
-    feature_set: schemas.FeatureSet,
+    feature_set: mlrun.common.schemas.FeatureSet,
     versioned: bool = True,
-    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(
@@ -96,10 +96,10 @@ async def store_feature_set(
         auth_info=auth_info,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_set,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_set,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.store,
+        mlrun.common.schemas.AuthorizationAction.store,
         auth_info,
     )
     tag, uid = parse_reference(reference)
@@ -123,23 +123,24 @@ async def store_feature_set(
     )
 
 
-@router.patch("/projects/{project}/feature-sets/{name}/references/{reference}")
+@router.patch("/feature-sets/{name}/references/{reference}")
 async def patch_feature_set(
     project: str,
     name: str,
     feature_set_update: dict,
     reference: str,
-    patch_mode: schemas.PatchMode = Header(
-        schemas.PatchMode.replace, alias=schemas.HeaderNames.patch_mode
+    patch_mode: mlrun.common.schemas.PatchMode = Header(
+        mlrun.common.schemas.PatchMode.replace,
+        alias=mlrun.common.schemas.HeaderNames.patch_mode,
     ),
-    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.feature_set,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_set,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.update,
+        mlrun.common.schemas.AuthorizationAction.update,
         auth_info,
     )
     tag, uid = parse_reference(reference)
@@ -157,14 +158,14 @@ async def patch_feature_set(
 
 
 @router.get(
-    "/projects/{project}/feature-sets/{name}/references/{reference}",
-    response_model=schemas.FeatureSet,
+    "/feature-sets/{name}/references/{reference}",
+    response_model=mlrun.common.schemas.FeatureSet,
 )
 async def get_feature_set(
     project: str,
     name: str,
     reference: str,
-    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),
 ):
     tag, uid = parse_reference(reference)
@@ -177,29 +178,29 @@ async def get_feature_set(
         uid,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_set,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_set,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )
     return feature_set
 
 
-@router.delete("/projects/{project}/feature-sets/{name}")
-@router.delete("/projects/{project}/feature-sets/{name}/references/{reference}")
+@router.delete("/feature-sets/{name}")
+@router.delete("/feature-sets/{name}/references/{reference}")
 async def delete_feature_set(
     project: str,
     name: str,
     reference: str = 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),
 ):
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_set,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_set,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.delete,
+        mlrun.common.schemas.AuthorizationAction.delete,
         auth_info,
     )
     tag = uid = None
@@ -217,7 +218,8 @@ async def delete_feature_set(
 
 
 @router.get(
-    "/projects/{project}/feature-sets", response_model=schemas.FeatureSetsOutput
+    "/feature-sets",
+    response_model=mlrun.common.schemas.FeatureSetsOutput,
 )
 async def list_feature_sets(
     project: str,
@@ -227,20 +229,22 @@ async def list_feature_sets(
     entities: List[str] = Query(None, alias="entity"),
     features: List[str] = Query(None, alias="feature"),
     labels: List[str] = Query(None, alias="label"),
-    partition_by: schemas.FeatureStorePartitionByField = Query(
+    partition_by: mlrun.common.schemas.FeatureStorePartitionByField = Query(
         None, alias="partition-by"
     ),
     rows_per_partition: int = Query(1, alias="rows-per-partition", gt=0),
-    partition_sort_by: schemas.SortField = Query(None, alias="partition-sort-by"),
-    partition_order: schemas.OrderType = Query(
-        schemas.OrderType.desc, alias="partition-order"
+    partition_sort_by: mlrun.common.schemas.SortField = Query(
+        None, alias="partition-sort-by"
     ),
-    auth_info: mlrun.api.schemas.AuthInfo = Depends(deps.authenticate_request),
+    partition_order: mlrun.common.schemas.OrderType = Query(
+        mlrun.common.schemas.OrderType.desc, alias="partition-order"
+    ),
+    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,
     )
     feature_sets = await run_in_threadpool(
@@ -259,7 +263,7 @@ async def list_feature_sets(
         partition_order,
     )
     feature_sets = await mlrun.api.utils.auth.verifier.AuthVerifier().filter_project_resources_by_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_set,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_set,
         feature_sets.feature_sets,
         lambda feature_set: (
             feature_set.metadata.project,
@@ -267,17 +271,17 @@ async def list_feature_sets(
         ),
         auth_info,
     )
-    return mlrun.api.schemas.FeatureSetsOutput(feature_sets=feature_sets)
+    return mlrun.common.schemas.FeatureSetsOutput(feature_sets=feature_sets)
 
 
 @router.get(
-    "/projects/{project}/feature-sets/{name}/tags",
-    response_model=schemas.FeatureSetsTagsOutput,
+    "/feature-sets/{name}/tags",
+    response_model=mlrun.common.schemas.FeatureSetsTagsOutput,
 )
 async def list_feature_sets_tags(
     project: str,
     name: str,
-    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 name != "*":
@@ -286,7 +290,7 @@ async def list_feature_sets_tags(
         )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_permissions(
         project,
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )
     tag_tuples = await run_in_threadpool(
@@ -298,7 +302,7 @@ async def list_feature_sets_tags(
     auth_verifier = mlrun.api.utils.auth.verifier.AuthVerifier()
     allowed_feature_set_names = (
         await auth_verifier.filter_project_resources_by_permissions(
-            mlrun.api.schemas.AuthorizationResourceTypes.feature_set,
+            mlrun.common.schemas.AuthorizationResourceTypes.feature_set,
             list(feature_set_name_to_tag.keys()),
             lambda feature_set_name: (
                 project,
@@ -312,7 +316,7 @@ async def list_feature_sets_tags(
         for tag_tuple in tag_tuples
         if tag_tuple[1] in allowed_feature_set_names
     }
-    return mlrun.api.schemas.FeatureSetsTagsOutput(tags=list(tags))
+    return mlrun.common.schemas.FeatureSetsTagsOutput(tags=list(tags))
 
 
 def _has_v3io_path(data_source, data_targets, feature_set):
@@ -341,8 +345,8 @@ def _has_v3io_path(data_source, data_targets, feature_set):
 
 
 @router.post(
-    "/projects/{project}/feature-sets/{name}/references/{reference}/ingest",
-    response_model=schemas.FeatureSetIngestOutput,
+    "/feature-sets/{name}/references/{reference}/ingest",
+    response_model=mlrun.common.schemas.FeatureSetIngestOutput,
     status_code=HTTPStatus.ACCEPTED.value,
 )
 async def ingest_feature_set(
@@ -350,10 +354,10 @@ async def ingest_feature_set(
     name: str,
     reference: str,
     ingest_parameters: Optional[
-        schemas.FeatureSetIngestInput
-    ] = schemas.FeatureSetIngestInput(),
+        mlrun.common.schemas.FeatureSetIngestInput
+    ] = mlrun.common.schemas.FeatureSetIngestInput(),
     username: 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),
 ):
     """
@@ -361,17 +365,17 @@ async def ingest_feature_set(
     that already being happen on client side
     """
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_set,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_set,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.update,
+        mlrun.common.schemas.AuthorizationAction.update,
         auth_info,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.run,
+        mlrun.common.schemas.AuthorizationResourceTypes.run,
         project,
         "",
-        mlrun.api.schemas.AuthorizationAction.create,
+        mlrun.common.schemas.AuthorizationAction.create,
         auth_info,
     )
     data_source = data_targets = None
@@ -379,10 +383,10 @@ async def ingest_feature_set(
         data_source = DataSource.from_dict(ingest_parameters.source.dict())
     if data_source.schedule:
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-            mlrun.api.schemas.AuthorizationResourceTypes.schedule,
+            mlrun.common.schemas.AuthorizationResourceTypes.schedule,
             project,
             "",
-            mlrun.api.schemas.AuthorizationAction.create,
+            mlrun.common.schemas.AuthorizationAction.create,
             auth_info,
         )
     tag, uid = parse_reference(reference)
@@ -398,10 +402,10 @@ async def ingest_feature_set(
     if feature_set.spec.function and feature_set.spec.function.function_object:
         function = feature_set.spec.function.function_object
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-            mlrun.api.schemas.AuthorizationResourceTypes.function,
+            mlrun.common.schemas.AuthorizationResourceTypes.function,
             function.metadata.project,
             function.metadata.name,
-            mlrun.api.schemas.AuthorizationAction.read,
+            mlrun.common.schemas.AuthorizationAction.read,
             auth_info,
         )
     # Need to override the default rundb since we're in the server.
@@ -447,25 +451,25 @@ async def ingest_feature_set(
         run_config=run_config,
     )
     # ingest may modify the feature-set contents, so returning the updated feature-set.
-    result_feature_set = schemas.FeatureSet(**feature_set.to_dict())
-    return schemas.FeatureSetIngestOutput(
+    result_feature_set = mlrun.common.schemas.FeatureSet(**feature_set.to_dict())
+    return mlrun.common.schemas.FeatureSetIngestOutput(
         feature_set=result_feature_set, run_object=run_params.to_dict()
     )
 
 
-@router.get("/projects/{project}/features", response_model=schemas.FeaturesOutput)
+@router.get("/features", response_model=mlrun.common.schemas.FeaturesOutput)
 async def list_features(
     project: str,
     name: str = None,
     tag: str = None,
     entities: List[str] = Query(None, alias="entity"),
     labels: List[str] = Query(None, alias="label"),
-    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,
     )
     features = await run_in_threadpool(
@@ -478,7 +482,7 @@ async def list_features(
         labels,
     )
     features = await mlrun.api.utils.auth.verifier.AuthVerifier().filter_project_resources_by_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature,
         features.features,
         lambda feature_list_output: (
             feature_list_output.feature_set_digest.metadata.project,
@@ -486,21 +490,21 @@ async def list_features(
         ),
         auth_info,
     )
-    return mlrun.api.schemas.FeaturesOutput(features=features)
+    return mlrun.common.schemas.FeaturesOutput(features=features)
 
 
-@router.get("/projects/{project}/entities", response_model=schemas.EntitiesOutput)
+@router.get("/entities", response_model=mlrun.common.schemas.EntitiesOutput)
 async def list_entities(
     project: str,
     name: str = None,
     tag: str = None,
     labels: List[str] = Query(None, alias="label"),
-    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,
     )
     entities = await run_in_threadpool(
@@ -512,7 +516,7 @@ async def list_entities(
         labels,
     )
     entities = await mlrun.api.utils.auth.verifier.AuthVerifier().filter_project_resources_by_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.entity,
+        mlrun.common.schemas.AuthorizationResourceTypes.entity,
         entities.entities,
         lambda entity_list_output: (
             entity_list_output.feature_set_digest.metadata.project,
@@ -520,17 +524,18 @@ async def list_entities(
         ),
         auth_info,
     )
-    return mlrun.api.schemas.EntitiesOutput(entities=entities)
+    return mlrun.common.schemas.EntitiesOutput(entities=entities)
 
 
 @router.post(
-    "/projects/{project}/feature-vectors", response_model=schemas.FeatureVector
+    "/feature-vectors",
+    response_model=mlrun.common.schemas.FeatureVector,
 )
 async def create_feature_vector(
     project: str,
-    feature_vector: schemas.FeatureVector,
+    feature_vector: mlrun.common.schemas.FeatureVector,
     versioned: bool = True,
-    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(
@@ -540,10 +545,10 @@ async def create_feature_vector(
         auth_info=auth_info,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_vector,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_vector,
         project,
         feature_vector.metadata.name,
-        mlrun.api.schemas.AuthorizationAction.create,
+        mlrun.common.schemas.AuthorizationAction.create,
         auth_info,
     )
     await _verify_feature_vector_features_permissions(
@@ -568,14 +573,14 @@ async def create_feature_vector(
 
 
 @router.get(
-    "/projects/{project}/feature-vectors/{name}/references/{reference}",
-    response_model=schemas.FeatureVector,
+    "/feature-vectors/{name}/references/{reference}",
+    response_model=mlrun.common.schemas.FeatureVector,
 )
 async def get_feature_vector(
     project: str,
     name: str,
     reference: str,
-    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),
 ):
     tag, uid = parse_reference(reference)
@@ -588,10 +593,10 @@ async def get_feature_vector(
         uid,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_vector,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_vector,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )
     await _verify_feature_vector_features_permissions(
@@ -601,7 +606,8 @@ async def get_feature_vector(
 
 
 @router.get(
-    "/projects/{project}/feature-vectors", response_model=schemas.FeatureVectorsOutput
+    "/feature-vectors",
+    response_model=mlrun.common.schemas.FeatureVectorsOutput,
 )
 async def list_feature_vectors(
     project: str,
@@ -609,20 +615,22 @@ async def list_feature_vectors(
     state: str = None,
     tag: str = None,
     labels: List[str] = Query(None, alias="label"),
-    partition_by: schemas.FeatureStorePartitionByField = Query(
+    partition_by: mlrun.common.schemas.FeatureStorePartitionByField = Query(
         None, alias="partition-by"
     ),
     rows_per_partition: int = Query(1, alias="rows-per-partition", gt=0),
-    partition_sort_by: schemas.SortField = Query(None, alias="partition-sort-by"),
-    partition_order: schemas.OrderType = Query(
-        schemas.OrderType.desc, alias="partition-order"
+    partition_sort_by: mlrun.common.schemas.SortField = Query(
+        None, alias="partition-sort-by"
+    ),
+    partition_order: mlrun.common.schemas.OrderType = Query(
+        mlrun.common.schemas.OrderType.desc, alias="partition-order"
     ),
-    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,
     )
     feature_vectors = await run_in_threadpool(
@@ -639,7 +647,7 @@ async def list_feature_vectors(
         partition_order,
     )
     feature_vectors = await mlrun.api.utils.auth.verifier.AuthVerifier().filter_project_resources_by_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_vector,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_vector,
         feature_vectors.feature_vectors,
         lambda feature_vector: (
             feature_vector.metadata.project,
@@ -653,17 +661,17 @@ async def list_feature_vectors(
             for fv in feature_vectors
         ]
     )
-    return mlrun.api.schemas.FeatureVectorsOutput(feature_vectors=feature_vectors)
+    return mlrun.common.schemas.FeatureVectorsOutput(feature_vectors=feature_vectors)
 
 
 @router.get(
-    "/projects/{project}/feature-vectors/{name}/tags",
-    response_model=schemas.FeatureVectorsTagsOutput,
+    "/feature-vectors/{name}/tags",
+    response_model=mlrun.common.schemas.FeatureVectorsTagsOutput,
 )
 async def list_feature_vectors_tags(
     project: str,
     name: str,
-    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 name != "*":
@@ -672,7 +680,7 @@ async def list_feature_vectors_tags(
         )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_permissions(
         project,
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )
     tag_tuples = await run_in_threadpool(
@@ -686,7 +694,7 @@ async def list_feature_vectors_tags(
     auth_verifier = mlrun.api.utils.auth.verifier.AuthVerifier()
     allowed_feature_vector_names = (
         await auth_verifier.filter_project_resources_by_permissions(
-            mlrun.api.schemas.AuthorizationResourceTypes.feature_vector,
+            mlrun.common.schemas.AuthorizationResourceTypes.feature_vector,
             list(feature_vector_name_to_tag.keys()),
             lambda feature_vector_name: (
                 project,
@@ -700,20 +708,20 @@ async def list_feature_vectors_tags(
         for tag_tuple in tag_tuples
         if tag_tuple[1] in allowed_feature_vector_names
     }
-    return mlrun.api.schemas.FeatureVectorsTagsOutput(tags=list(tags))
+    return mlrun.common.schemas.FeatureVectorsTagsOutput(tags=list(tags))
 
 
 @router.put(
-    "/projects/{project}/feature-vectors/{name}/references/{reference}",
-    response_model=schemas.FeatureVector,
+    "/feature-vectors/{name}/references/{reference}",
+    response_model=mlrun.common.schemas.FeatureVector,
 )
 async def store_feature_vector(
     project: str,
     name: str,
     reference: str,
-    feature_vector: schemas.FeatureVector,
+    feature_vector: mlrun.common.schemas.FeatureVector,
     versioned: bool = True,
-    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(
@@ -723,10 +731,10 @@ async def store_feature_vector(
         auth_info=auth_info,
     )
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_vector,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_vector,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.update,
+        mlrun.common.schemas.AuthorizationAction.update,
         auth_info,
     )
     await _verify_feature_vector_features_permissions(
@@ -754,23 +762,24 @@ async def store_feature_vector(
     )
 
 
-@router.patch("/projects/{project}/feature-vectors/{name}/references/{reference}")
+@router.patch("/feature-vectors/{name}/references/{reference}")
 async def patch_feature_vector(
     project: str,
     name: str,
     feature_vector_patch: dict,
     reference: str,
-    patch_mode: schemas.PatchMode = Header(
-        schemas.PatchMode.replace, alias=schemas.HeaderNames.patch_mode
+    patch_mode: mlrun.common.schemas.PatchMode = Header(
+        mlrun.common.schemas.PatchMode.replace,
+        alias=mlrun.common.schemas.HeaderNames.patch_mode,
     ),
-    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.feature_vector,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_vector,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.update,
+        mlrun.common.schemas.AuthorizationAction.update,
         auth_info,
     )
     await _verify_feature_vector_features_permissions(
@@ -790,20 +799,20 @@ async def patch_feature_vector(
     return Response(status_code=HTTPStatus.OK.value)
 
 
-@router.delete("/projects/{project}/feature-vectors/{name}")
-@router.delete("/projects/{project}/feature-vectors/{name}/references/{reference}")
+@router.delete("/feature-vectors/{name}")
+@router.delete("/feature-vectors/{name}/references/{reference}")
 async def delete_feature_vector(
     project: str,
     name: str,
     reference: str = 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),
 ):
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_vector,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_vector,
         project,
         name,
-        mlrun.api.schemas.AuthorizationAction.delete,
+        mlrun.common.schemas.AuthorizationAction.delete,
         auth_info,
     )
     tag = uid = None
@@ -821,7 +830,7 @@ async def delete_feature_vector(
 
 
 async def _verify_feature_vector_features_permissions(
-    auth_info: mlrun.api.schemas.AuthInfo, project: str, feature_vector: dict
+    auth_info: mlrun.common.schemas.AuthInfo, project: str, feature_vector: dict
 ):
     features = []
     if feature_vector.get("spec", {}).get("features"):
@@ -840,12 +849,12 @@ async def _verify_feature_vector_features_permissions(
         for name in names:
             feature_set_project_name_tuples.append((_project, name))
     await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resources_permissions(
-        mlrun.api.schemas.AuthorizationResourceTypes.feature_set,
+        mlrun.common.schemas.AuthorizationResourceTypes.feature_set,
         feature_set_project_name_tuples,
         lambda feature_set_project_name_tuple: (
             feature_set_project_name_tuple[0],
             feature_set_project_name_tuple[1],
         ),
-        mlrun.api.schemas.AuthorizationAction.read,
+        mlrun.common.schemas.AuthorizationAction.read,
         auth_info,
     )