ethyca-fides 2.69.1rc0__py2.py3-none-any.whl → 2.76.0rc2__py2.py3-none-any.whl

fides/api/api/v1/endpoints/connection_endpoints.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 from typing import Annotated, Any, Dict, List, Optional
 
-from fastapi import Depends
+import sqlalchemy
+from fastapi import Depends, HTTPException
 from fastapi.params import Query, Security
 from fastapi_pagination import Page, Params
 from fastapi_pagination.bases import AbstractPage
@@ -13,10 +14,17 @@ from pydantic import Field
 from sqlalchemy import null, or_
 from sqlalchemy.orm import Session
 from sqlalchemy_utils import escape_like
-from starlette.status import HTTP_200_OK, HTTP_204_NO_CONTENT
+from starlette.status import (
+    HTTP_200_OK,
+    HTTP_204_NO_CONTENT,
+    HTTP_404_NOT_FOUND,
+    HTTP_422_UNPROCESSABLE_ENTITY,
+)
 
 from fides.api.api import deps
+from fides.api.models.connection_oauth_credentials import OAuthConfig
 from fides.api.models.connectionconfig import ConnectionConfig, ConnectionType
+from fides.api.models.event_audit import EventAuditType
 from fides.api.oauth.utils import verify_oauth_client
 from fides.api.schemas.connection_configuration import connection_secrets_schemas
 from fides.api.schemas.connection_configuration.connection_config import (
@@ -25,18 +33,22 @@ from fides.api.schemas.connection_configuration.connection_config import (
     ConnectionConfigurationResponseWithSystemKey,
     CreateConnectionConfigurationWithSecrets,
 )
+from fides.api.schemas.connection_configuration.connection_oauth_config import (
+    OAuthConfigSchema,
+)
 from fides.api.schemas.connection_configuration.connection_secrets import (
     TestStatusMessage,
 )
 from fides.api.schemas.connection_configuration.enums.system_type import SystemType
 from fides.api.schemas.connection_configuration.enums.test_status import TestStatus
+from fides.api.service.deps import get_connection_service
 from fides.api.util.api_router import APIRouter
 from fides.api.util.connection_util import (
     connection_status,
     delete_connection_config,
     get_connection_config_or_error,
     patch_connection_configs,
-    validate_secrets,
+    update_connection_secrets,
 )
 from fides.common.api.scope_registry import (
     CONNECTION_CREATE_OR_UPDATE,
@@ -45,11 +57,14 @@ from fides.common.api.scope_registry import (
 )
 from fides.common.api.v1.urn_registry import (
     CONNECTION_BY_KEY,
+    CONNECTION_OAUTH,
     CONNECTION_SECRETS,
     CONNECTION_TEST,
     CONNECTIONS,
     V1_URL_PREFIX,
 )
+from fides.service.connection.connection_service import ConnectionService
+from fides.service.event_audit_service import EventAuditService
 
 router = APIRouter(tags=["Connections"], prefix=V1_URL_PREFIX)
 
@@ -209,28 +224,6 @@ def delete_connection(
     delete_connection_config(db, connection_key)
 
 
-def validate_and_update_secrets(
-    connection_key: FidesKey,
-    connection_config: ConnectionConfig,
-    db: Session,
-    unvalidated_secrets: connection_secrets_schemas,
-    verify: Optional[bool],
-) -> TestStatusMessage:
-    connection_config.secrets = validate_secrets(
-        db, unvalidated_secrets, connection_config
-    ).model_dump(mode="json")
-    # Save validated secrets, regardless of whether they've been verified.
-    logger.info("Updating connection config secrets for '{}'", connection_key)
-    connection_config.save(db=db)
-
-    msg = f"Secrets updated for ConnectionConfig with key: {connection_key}."
-
-    if verify:
-        return connection_status(connection_config, msg, db)
-
-    return TestStatusMessage(msg=msg, test_status=None)
-
-
 @router.put(
     CONNECTION_SECRETS,
     status_code=HTTP_200_OK,
@@ -240,7 +233,7 @@ def validate_and_update_secrets(
 def put_connection_config_secrets(
     connection_key: FidesKey,
     *,
-    db: Session = Depends(deps.get_db),
+    connection_service: ConnectionService = Depends(get_connection_service),
     unvalidated_secrets: connection_secrets_schemas,
     verify: Optional[bool] = True,
 ) -> TestStatusMessage:
@@ -250,10 +243,8 @@ def put_connection_config_secrets(
     The specific secrets will be connection-dependent. For example, the components needed to connect to a Postgres DB
     will differ from Dynamo DB.
     """
-    connection_config = get_connection_config_or_error(db, connection_key)
-
-    return validate_and_update_secrets(
-        connection_key, connection_config, db, unvalidated_secrets, verify
+    return update_connection_secrets(
+        connection_service, connection_key, unvalidated_secrets, verify
     )
 
 
@@ -266,7 +257,7 @@ def put_connection_config_secrets(
 def patch_connection_config_secrets(
     connection_key: FidesKey,
     *,
-    db: Session = Depends(deps.get_db),
+    connection_service: ConnectionService = Depends(get_connection_service),
     unvalidated_secrets: connection_secrets_schemas,
     verify: Optional[bool] = True,
 ) -> TestStatusMessage:
@@ -276,22 +267,12 @@ def patch_connection_config_secrets(
     The specific secrets will be connection-dependent. For example, the components needed to connect to a Postgres DB
     will differ from Dynamo DB.
     """
-    connection_config = get_connection_config_or_error(db, connection_key)
-
-    existing_secrets: Optional[Dict[str, Any]] = connection_config.secrets
-
-    # We create the new secrets object by combining the existing secrets with the new secrets.
-    patched_secrets = {}
-    if existing_secrets:
-        patched_secrets = {**existing_secrets}
-
-    patched_secrets = {
-        **patched_secrets,
-        **unvalidated_secrets,  # type: ignore[dict-item]
-    }
-
-    return validate_and_update_secrets(
-        connection_key, connection_config, db, patched_secrets, verify  # type: ignore[arg-type]
+    return update_connection_secrets(
+        connection_service,
+        connection_key,
+        unvalidated_secrets,
+        verify,
+        merge_with_existing=True,
     )
 
 
@@ -312,3 +293,166 @@ def test_connection_config_secrets(
     connection_config = get_connection_config_or_error(db, connection_key)
     msg = f"Test completed for ConnectionConfig with key: {connection_key}."
     return connection_status(connection_config, msg, db)
+
+
+@router.put(
+    CONNECTION_OAUTH,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTION_CREATE_OR_UPDATE])],
+    status_code=HTTP_200_OK,
+)
+def put_connection_oauth_config(
+    connection_key: FidesKey,
+    *,
+    oauth_config: OAuthConfigSchema,
+    db: Session = Depends(deps.get_db),
+    verify: Optional[bool] = True,
+) -> TestStatusMessage:
+    """
+    Create or update the OAuth2 configuration for a given connection.
+    """
+    connection_config = get_connection_config_or_error(db, connection_key)
+
+    if connection_config.connection_type != ConnectionType.https:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="OAuth2 configuration can only be set for HTTPS connections.",
+        )
+
+    logger.info("Updating OAuth2 config for '{}'", connection_key)
+    connection_config.oauth_config = OAuthConfig(
+        **oauth_config.model_dump(mode="json")  # type: ignore[arg-type]
+    )
+    connection_config.save(db=db)
+
+    event_audit_service = EventAuditService(db)
+    connection_service = ConnectionService(db, event_audit_service)
+
+    # Create secrets audit event for OAuth credential changes
+    connection_service.create_secrets_audit_event(
+        EventAuditType.connection_secrets_updated,
+        connection_config,
+        oauth_config.model_dump(exclude_unset=True),  # The OAuth secrets being updated
+    )
+
+    msg = (
+        f"OAuth2 configuration updated for ConnectionConfig with key: {connection_key}."
+    )
+
+    if verify:
+        return connection_status(connection_config, msg, db)
+
+    return TestStatusMessage(msg=msg, test_status=None)
+
+
+@router.delete(
+    CONNECTION_OAUTH,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTION_CREATE_OR_UPDATE])],
+    status_code=HTTP_204_NO_CONTENT,
+    response_model=None,
+)
+def delete_connection_oauth_config(
+    connection_key: FidesKey,
+    *,
+    db: Session = Depends(deps.get_db),
+) -> None:
+    """
+    Delete the OAuth2 configuration for a given connection.
+    """
+    connection_config = get_connection_config_or_error(db, connection_key)
+
+    if connection_config.connection_type != ConnectionType.https:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="OAuth2 configuration can only be deleted for HTTPS connections",
+        )
+
+    if not connection_config.oauth_config:
+        raise HTTPException(
+            status_code=HTTP_404_NOT_FOUND,
+            detail="No OAuth2 configuration found to delete.",
+        )
+
+    logger.info("Deleting OAuth2 config for '{}'", connection_key)
+    connection_config.oauth_config = None
+    connection_config.save(db=db)
+
+
+@router.patch(
+    CONNECTION_OAUTH,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTION_CREATE_OR_UPDATE])],
+    status_code=HTTP_200_OK,
+)
+def patch_connection_oauth_config(
+    connection_key: FidesKey,
+    *,
+    oauth_config: OAuthConfigSchema,
+    db: Session = Depends(deps.get_db),
+    verify: Optional[bool] = True,
+) -> TestStatusMessage:
+    """
+    Partially update the OAuth2 configuration for a given connection.
+    """
+    connection_config = get_connection_config_or_error(db, connection_key)
+
+    if connection_config.connection_type != ConnectionType.https:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="OAuth2 configuration can only be set for HTTPS connections.",
+        )
+
+    existing_oauth_config: Optional[Dict[str, Any]] = (
+        {
+            "grant_type": connection_config.oauth_config.grant_type.value,
+            "token_url": connection_config.oauth_config.token_url,
+            "scope": connection_config.oauth_config.scope,
+            "client_id": connection_config.oauth_config.client_id,
+            "client_secret": connection_config.oauth_config.client_secret,
+        }
+        if connection_config.oauth_config
+        else None
+    )
+
+    # Combine the existing config with the new config overlaid
+    patched_oauth_config = {}
+    if existing_oauth_config:
+        patched_oauth_config = {**existing_oauth_config}
+
+    patched_oauth_config = {
+        **patched_oauth_config,
+        **{k: v for (k, v) in oauth_config.model_dump(mode="json").items() if v is not None},  # type: ignore[dict-item]
+    }
+
+    logger.info("Patching OAuth2 config for '{}'", connection_key)
+    validated_config = OAuthConfigSchema.model_validate(patched_oauth_config)
+    try:
+        connection_config.oauth_config = OAuthConfig(
+            **validated_config.model_dump(mode="json")
+        )
+        connection_config.save(db=db)
+    except sqlalchemy.exc.IntegrityError as exc:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Invalid OAuth2 configuration.",
+        ) from exc
+
+    # Create audit event for OAuth config update (OAuth credentials are secrets)
+    event_audit_service = EventAuditService(db)
+    connection_service = ConnectionService(db, event_audit_service)
+
+    # Create secrets audit event for OAuth credential changes
+    connection_service.create_secrets_audit_event(
+        EventAuditType.connection_secrets_updated,
+        connection_config,
+        validated_config.model_dump(
+            exclude_unset=True
+        ),  # The OAuth secrets being updated
+    )
+
+    msg = (
+        f"OAuth2 configuration updated for ConnectionConfig with key: {connection_key}."
+    )
+
+    if verify:
+        return connection_status(connection_config, msg, db)
+
+    return TestStatusMessage(msg=msg, test_status=None)

fides/api/api/v1/endpoints/connector_template_endpoints.py

@@ -0,0 +1,167 @@
+from io import BytesIO
+from typing import List
+from zipfile import BadZipFile, ZipFile
+
+from fastapi import Body, Depends, HTTPException
+from fastapi.params import Security
+from fastapi.responses import JSONResponse, Response
+from loguru import logger
+from sqlalchemy.orm import Session
+from starlette.status import HTTP_404_NOT_FOUND
+
+from fides.api.api import deps
+from fides.api.oauth.utils import verify_oauth_client
+from fides.api.schemas.saas.connector_template import ConnectorTemplateListResponse
+from fides.api.service.connectors.saas.connector_registry_service import (
+    ConnectorRegistry,
+    CustomConnectorTemplateLoader,
+)
+from fides.api.util.api_router import APIRouter
+from fides.common.api.scope_registry import (
+    CONNECTOR_TEMPLATE_READ,
+    CONNECTOR_TEMPLATE_REGISTER,
+)
+from fides.common.api.v1.urn_registry import (
+    CONNECTOR_TEMPLATES,
+    CONNECTOR_TEMPLATES_CONFIG,
+    CONNECTOR_TEMPLATES_DATASET,
+    CONNECTOR_TEMPLATES_REGISTER,
+    REGISTER_CONNECTOR_TEMPLATE,
+    V1_URL_PREFIX,
+)
+
+router = APIRouter(tags=["Connector Templates"], prefix=V1_URL_PREFIX)
+
+
+@router.get(
+    CONNECTOR_TEMPLATES,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_READ])],
+    response_model=List[ConnectorTemplateListResponse],
+)
+def get_all_connector_templates() -> List[ConnectorTemplateListResponse]:
+    """
+    Returns a list of all available connector templates with summary information.
+
+    Each template includes:
+    - **type**: The unique identifier for the connector (used in other endpoints)
+    - **name**: Human-readable name of the connector
+    - **supported_actions**: List of actions this connector supports (e.g., access, erasure)
+    - **category**: Optional category classification for the connector
+    - **custom**: Whether this is a custom connector (true) or built-in (false)
+    """
+    logger.info("Retrieving all connector templates")
+    return ConnectorRegistry.get_all_connector_templates_summary()
+
+
+@router.post(
+    CONNECTOR_TEMPLATES_REGISTER,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_REGISTER])],
+)
+def register_connector_template(
+    file: bytes = Body(..., media_type="application/zip"),
+    db: Session = Depends(deps.get_db),
+) -> JSONResponse:
+    """
+    Registers a custom connector template from a zip file uploaded by the user.
+
+    The endpoint performs the following steps:
+    1. Validates the uploaded file is a proper zip file.
+    2. Uses the CustomConnectorTemplateLoader to validate, register, and save the template to the database.
+
+    If the uploaded file is not a valid zip file or there are any validation errors
+    when creating the ConnectorTemplates an HTTP 400 status code with error details is returned.
+    """
+    try:
+        with ZipFile(BytesIO(file), "r") as zip_file:
+            CustomConnectorTemplateLoader.save_template(db=db, zip_file=zip_file)
+    except BadZipFile:
+        raise HTTPException(status_code=400, detail="Invalid zip file")
+    except Exception as exc:
+        logger.exception("Error loading connector template from zip file.")
+        raise HTTPException(status_code=400, detail=str(exc))
+
+    return JSONResponse(
+        content={"message": "Connector template successfully registered."}
+    )
+
+
+@router.post(
+    REGISTER_CONNECTOR_TEMPLATE,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_REGISTER])],
+    deprecated=True,
+)
+def register_custom_connector_template_deprecated(
+    file: bytes = Body(..., media_type="application/zip"),
+    db: Session = Depends(deps.get_db),
+) -> JSONResponse:
+    """
+    **DEPRECATED**: Use `POST /connector-templates/register` instead.
+
+    Registers a custom connector template from a zip file uploaded by the user.
+    This endpoint is maintained for backward compatibility only.
+    """
+    return register_connector_template(file=file, db=db)
+
+
+@router.get(
+    CONNECTOR_TEMPLATES_CONFIG,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_READ])],
+)
+def get_connector_template_config(
+    connector_template_type: str,
+) -> Response:
+    """
+    Retrieves the SaaS config YAML for a connector template by its type.
+
+    The `connector_template_type` parameter comes from the `type` field
+    returned by the `GET /connector-templates` endpoint.
+
+    Returns the raw YAML configuration that can be used to understand
+    or customize the connector template.
+    """
+    logger.info("Finding connector template with type '{}'", connector_template_type)
+    template = ConnectorRegistry.get_connector_template(connector_template_type)
+
+    if not template:
+        raise HTTPException(
+            status_code=HTTP_404_NOT_FOUND,
+            detail=f"No connector template found with type '{connector_template_type}'",
+        )
+
+    return Response(
+        content=template.config,
+        media_type="text/yaml",
+    )
+
+
+@router.get(
+    CONNECTOR_TEMPLATES_DATASET,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_READ])],
+)
+def get_connector_template_dataset(
+    connector_template_type: str,
+) -> Response:
+    """
+    Retrieves the dataset YAML for a connector template by its type.
+
+    The `connector_template_type` parameter comes from the `type` field
+    returned by the `GET /connector-templates` endpoint.
+
+    Returns the raw dataset YAML configuration that defines the data structure
+    for the connector template.
+    """
+    logger.info(
+        "Finding connector template dataset with type '{}'", connector_template_type
+    )
+    template = ConnectorRegistry.get_connector_template(connector_template_type)
+
+    if not template:
+        raise HTTPException(
+            status_code=HTTP_404_NOT_FOUND,
+            detail=f"No connector template found with type '{connector_template_type}'",
+        )
+
+    return Response(
+        content=template.dataset,
+        media_type="text/yaml",
+    )

fides/api/api/v1/endpoints/generic_overrides.py

@@ -1,7 +1,7 @@
 from functools import partial
 from typing import Dict, List, Optional, Union
 
-from fastapi import Depends, HTTPException, Query, Response, Security
+from fastapi import Body, Depends, HTTPException, Query, Response, Security
 from fastapi.concurrency import run_in_threadpool
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse
@@ -54,6 +54,7 @@ from fides.common.api.v1.urn_registry import DATASETS_CLEAN, V1_URL_PREFIX
 from fides.service.dataset.dataset_service import (
     DatasetNotFoundException,
     DatasetService,
+    LinkedDatasetException,
 )
 from fides.service.taxonomy.taxonomy_service import TaxonomyService
 
@@ -126,7 +127,7 @@ async def update_dataset(
     except DatasetNotFoundException as e:
         raise HTTPException(
             status_code=HTTP_404_NOT_FOUND,
-            detail={"message": str(e)},
+            detail=str(e),
         )
 
 
@@ -248,7 +249,7 @@ async def get_dataset(
     except DatasetNotFoundException as e:
         raise HTTPException(
             status_code=HTTP_404_NOT_FOUND,
-            detail={"message": str(e)},
+            detail=str(e),
         )
 
 
@@ -275,7 +276,12 @@ async def delete_dataset(
     except DatasetNotFoundException as e:
         raise HTTPException(
             status_code=HTTP_404_NOT_FOUND,
-            detail={"message": str(e)},
+            detail=str(e),
+        )
+    except LinkedDatasetException as e:
+        raise HTTPException(
+            status_code=HTTP_400_BAD_REQUEST,
+            detail=str(e),
         )
 
 
@@ -362,12 +368,12 @@ async def create_data_use(
     """
     try:
         return taxonomy_service.create_or_update_element(
-            "data_uses", data_use.model_dump()
+            "data_use", data_use.model_dump()
         )
-    except KeyOrNameAlreadyExists:
+    except KeyOrNameAlreadyExists as e:
         raise HTTPException(
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Data use with key {data_use.fides_key} or name {data_use.name} already exists.",
+            detail=str(e),
         )
     except (ValidationError, PydanticValidationError) as e:
         raise HTTPException(
@@ -393,12 +399,12 @@ async def create_data_category(
 
     try:
         return taxonomy_service.create_or_update_element(
-            "data_categories", data_category.model_dump()
+            "data_category", data_category.model_dump()
         )
-    except KeyOrNameAlreadyExists:
+    except KeyOrNameAlreadyExists as e:
         raise HTTPException(
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Data category with key {data_category.fides_key} or name {data_category.name} already exists.",
+            detail=str(e),
         )
     except (ValidationError, PydanticValidationError) as e:
         raise HTTPException(
@@ -424,12 +430,12 @@ async def create_data_subject(
 
     try:
         return taxonomy_service.create_or_update_element(
-            "data_subjects", data_subject.model_dump()
+            "data_subject", data_subject.model_dump()
         )
-    except KeyOrNameAlreadyExists:
+    except KeyOrNameAlreadyExists as e:
         raise HTTPException(
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Data subject with key {data_subject.fides_key} or name {data_subject.name} already exists.",
+            detail=str(e),
         )
     except (ValidationError, PydanticValidationError) as e:
         raise HTTPException(
@@ -459,7 +465,7 @@ async def update_data_use(
         )
     try:
         result = taxonomy_service.update_element(
-            "data_uses", data_use.fides_key, data_use.model_dump()
+            "data_use", data_use.fides_key, data_use.model_dump()
         )
         if not result:
             raise HTTPException(
@@ -495,7 +501,7 @@ async def update_data_category(
         )
     try:
         result = taxonomy_service.update_element(
-            "data_categories", data_category.fides_key, data_category.model_dump()
+            "data_category", data_category.fides_key, data_category.model_dump()
         )
         if not result:
             raise HTTPException(
@@ -510,6 +516,75 @@ async def update_data_category(
         )
 
 
+@data_category_router.patch(
+    "/data_category/{fides_key}/tagging_instructions",
+    dependencies=[Security(verify_oauth_client, scopes=[DATA_CATEGORY_UPDATE])],
+    response_model=DataCategory,
+    status_code=status.HTTP_200_OK,
+    name="Update tagging instructions",
+)
+async def update_data_category_tagging_instructions(
+    fides_key: str,
+    tagging_instructions: str = Body(..., embed=True),
+    taxonomy_service: TaxonomyService = Depends(get_taxonomy_service),
+) -> Dict:
+    """
+    Update or add tagging_instructions for a data category.
+    This is used by LLM-based classification to provide custom instructions for tagging.
+    """
+    try:
+        result = taxonomy_service.update_element(
+            "data_category",
+            fides_key,
+            {"tagging_instructions": tagging_instructions},
+        )
+        if not result:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Data category not found with key: {fides_key}",
+            )
+        return result
+    except (ValidationError, PydanticValidationError) as e:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=str(e),
+        )
+
+
+@data_category_router.delete(
+    "/data_category/{fides_key}/tagging_instructions",
+    dependencies=[Security(verify_oauth_client, scopes=[DATA_CATEGORY_UPDATE])],
+    response_model=DataCategory,
+    status_code=status.HTTP_200_OK,
+    name="Delete tagging instructions",
+)
+async def delete_data_category_tagging_instructions(
+    fides_key: str,
+    taxonomy_service: TaxonomyService = Depends(get_taxonomy_service),
+) -> Dict:
+    """
+    Remove tagging_instructions from a data category.
+    Sets the tagging_instructions field to None.
+    """
+    try:
+        result = taxonomy_service.update_element(
+            "data_category",
+            fides_key,
+            {"tagging_instructions": None},
+        )
+        if not result:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Data category not found with key: {fides_key}",
+            )
+        return result
+    except (ValidationError, PydanticValidationError) as e:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=str(e),
+        )
+
+
 GENERIC_OVERRIDES_ROUTER = APIRouter()
 GENERIC_OVERRIDES_ROUTER.include_router(dataset_router)
 GENERIC_OVERRIDES_ROUTER.include_router(data_use_router)