ethyca-fides 2.60.1rc0__py2.py3-none-any.whl → 2.60.2b1__py2.py3-none-any.whl

{ethyca_fides-2.60.1rc0.dist-info → ethyca_fides-2.60.2b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

fides/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-04-29T17:04:59-0400",
+ "date": "2025-05-05T14:14:41-0600",
  "dirty": false,
  "error": null,
- "full-revisionid": "6329ae1259afa234d4bb308672fb20cf5295f9c6",
- "version": "2.60.1rc0"
+ "full-revisionid": "fbfd80a33a65a68bffaadfdc0b5c93a90f78761c",
+ "version": "2.60.2b1"
 }
 '''  # END VERSION_JSON
 

fides/api/alembic/migrations/versions/d0cbfec0b2dd_add_okta_to_connection_types.py

@@ -0,0 +1,61 @@
+"""add okta to connection_types
+
+Revision ID: d0cbfec0b2dd
+Revises: c9c72b3d550b
+Create Date: 2025-04-23 15:22:57.920715
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = "d0cbfec0b2dd"
+down_revision = "c9c72b3d550b"
+branch_labels = None
+depends_on = None
+
+type_to_handle = "okta"
+
+
+def get_enum_values():
+    conn = op.get_bind()
+    result = conn.execute("SELECT unnest(enum_range(NULL::connectiontype))").fetchall()
+    return [row[0] for row in result]
+
+
+def upgrade():
+    # add 'okta' to ConnectionType enum
+    enum_values = [f"'{value}'" for value in get_enum_values() + [type_to_handle]]
+    enum_values.sort()  # Just to keep it fantastic
+
+    op.execute("ALTER TYPE connectiontype RENAME TO connectiontype_old")
+    op.execute(f"CREATE TYPE connectiontype AS ENUM ({', '.join(set(enum_values))})")
+    op.execute(
+        """
+        ALTER TABLE connectionconfig ALTER COLUMN connection_type TYPE connectiontype USING
+        connection_type::text::connectiontype
+    """
+    )
+    op.execute("DROP TYPE connectiontype_old")
+
+
+def downgrade():
+    # Remove 'okta' from ConnectionType enum
+    enum_values = [f"'{v.strip()}'" for v in get_enum_values() if v != type_to_handle]
+    enum_values.sort()  # Just to keep it fantastic
+
+    op.execute(
+        f"DELETE FROM connectionconfig WHERE connection_type IN ('{type_to_handle}')"
+    )
+    op.execute("ALTER TYPE connectiontype RENAME TO connectiontype_old")
+
+    op.execute(f"CREATE TYPE connectiontype AS ENUM ({', '.join(set(enum_values))})")
+    op.execute(
+        """
+        ALTER TABLE connectionconfig ALTER COLUMN connection_type TYPE connectiontype USING
+        connection_type::text::connectiontype
+    """
+    )
+    op.execute("DROP TYPE connectiontype_old")

fides/api/api/deps.py

@@ -1,10 +1,12 @@
-from contextlib import contextmanager
-from typing import Generator
+from contextlib import asynccontextmanager, contextmanager
+from typing import AsyncGenerator, Generator
 
 from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
 from fides.api.common_exceptions import RedisNotConfigured
+from fides.api.db.ctl_session import async_session
 from fides.api.db.session import get_db_engine, get_db_session
 from fides.api.util.cache import get_cache as get_redis_connection
 from fides.config import CONFIG, FidesConfig
@@ -102,3 +104,17 @@ def get_cache() -> Generator:
             "Application redis cache required, but it is currently disabled! Please update your application configuration to enable integration with a Redis cache."
         )
     yield get_redis_connection()
+
+
+@asynccontextmanager
+async def get_async_autoclose_db_session() -> AsyncGenerator[AsyncSession, None]:
+    """
+    Return an async database session as an async context manager that automatically closes when the context exits.
+
+    Use this when you need manual control over the async session lifecycle outside of API endpoints.
+    """
+    session = async_session()
+    try:
+        yield session
+    finally:
+        await session.close()

fides/api/api/v1/endpoints/admin.py

@@ -16,6 +16,7 @@ ADMIN_ROUTER = APIRouter(prefix=API_PREFIX, tags=["Admin"])
 
 class DBActions(str, Enum):
     "The available path parameters for the `/admin/db/{action}` endpoint."
+
     upgrade = "upgrade"
     reset = "reset"
     downgrade = "downgrade"
@@ -29,7 +30,7 @@ class DBActions(str, Enum):
     ],
     status_code=status.HTTP_200_OK,
 )
-async def db_action(action: DBActions, revision: Optional[str] = "head") -> Dict:
+def db_action(action: DBActions, revision: Optional[str] = "head") -> Dict:
     """
     Initiate one of the enumerated DBActions.
 
@@ -40,7 +41,7 @@ async def db_action(action: DBActions, revision: Optional[str] = "head") -> Dict
 
     if action == DBActions.downgrade:
         try:
-            await migrate_db(database_url=CONFIG.database.sync_database_uri, revision=revision, downgrade=True)  # type: ignore[arg-type]
+            migrate_db(database_url=CONFIG.database.sync_database_uri, revision=revision, downgrade=True)  # type: ignore[arg-type]
             action_text = "downgrade"
         except Exception as e:
             logger.exception("Database downgrade failed")
@@ -68,7 +69,7 @@ async def db_action(action: DBActions, revision: Optional[str] = "head") -> Dict
 
         try:
             logger.info("Database being configured...")
-            await configure_db(CONFIG.database.sync_database_uri, revision=revision)
+            configure_db(CONFIG.database.sync_database_uri, revision=revision)
         except Exception as e:
             logger.exception("Database configuration failed: {e}")
             raise HTTPException(

fides/api/app_setup.py

@@ -16,7 +16,11 @@ from slowapi.extension import _rate_limit_exceeded_handler  # type: ignore
 from slowapi.middleware import SlowAPIMiddleware  # type: ignore
 
 import fides
-from fides.api.api.deps import get_api_session
+from fides.api.api.deps import (
+    get_api_session,
+    get_async_autoclose_db_session,
+    get_autoclose_db_session,
+)
 from fides.api.api.v1 import CTL_ROUTER
 from fides.api.api.v1.api import api_router
 from fides.api.api.v1.endpoints.admin import ADMIN_ROUTER
@@ -24,7 +28,8 @@ from fides.api.api.v1.endpoints.generic_overrides import GENERIC_OVERRIDES_ROUTE
 from fides.api.api.v1.endpoints.health import HEALTH_ROUTER
 from fides.api.api.v1.exception_handlers import ExceptionHandlers
 from fides.api.common_exceptions import RedisConnectionError, RedisNotConfigured
-from fides.api.db.database import configure_db
+from fides.api.db import seed
+from fides.api.db.database import configure_db, seed_db
 from fides.api.db.seed import create_or_update_parent_user
 from fides.api.models.application_config import ApplicationConfig
 from fides.api.oauth.system_manager_oauth_util import (
@@ -165,9 +170,12 @@ async def run_database_startup(app: FastAPI) -> None:
 
     if CONFIG.database.automigrate:
         try:
-            await configure_db(
-                CONFIG.database.sync_database_uri, samples=CONFIG.database.load_samples
-            )
+            configure_db(CONFIG.database.sync_database_uri)
+            with get_autoclose_db_session() as session:
+                seed_db(session)
+            if CONFIG.database.load_samples:
+                async with get_async_autoclose_db_session() as async_session:
+                    await seed.load_samples(async_session)
         except Exception as e:
             logger.error("Error occurred during database configuration: {}", str(e))
     else:

fides/api/db/database.py

@@ -14,8 +14,7 @@ from sqlalchemy_utils.functions import create_database, database_exists
 from sqlalchemy_utils.types.encrypted.encrypted_type import InvalidCiphertextError
 
 from fides.api.db.base import Base  # type: ignore[attr-defined]
-from fides.api.db.ctl_session import async_session
-from fides.api.db.seed import load_default_resources, load_samples
+from fides.api.db.seed import load_default_resources
 from fides.api.util.errors import get_full_exception_name
 from fides.core.utils import get_db_engine
 
@@ -48,9 +47,8 @@ def downgrade_db(alembic_config: Config, revision: str = "head") -> None:
     command.downgrade(alembic_config, revision)
 
 
-async def migrate_db(
+def migrate_db(
     database_url: str,
-    samples: bool = False,
     revision: str = "head",
     downgrade: bool = False,
 ) -> None:
@@ -66,11 +64,6 @@ async def migrate_db(
     else:
         upgrade_db(alembic_config, revision)
 
-        async with async_session() as session:
-            await load_default_resources(session)
-            if samples:
-                await load_samples(session)
-
 
 def create_db_if_not_exists(database_url: str) -> None:
     """
@@ -121,13 +114,17 @@ def get_db_health(
         return ("unhealthy", None)
 
 
-async def configure_db(
-    database_url: str, samples: bool = False, revision: Optional[str] = "head"
-) -> None:
-    """Set up the db to be used by the app."""
+def seed_db(session: Session) -> None:
+    """Load default resources into the database, and optionally load samples."""
+    load_default_resources(session)
+
+
+def configure_db(database_url: str, revision: Optional[str] = "head") -> None:
+    """Set up the db to be used by the app. Creates db if needed and runs migrations."""
     try:
         create_db_if_not_exists(database_url)
-        await migrate_db(database_url, samples=samples, revision=revision)  # type: ignore[arg-type]
+        migrate_db(database_url, revision=revision)  # type: ignore[arg-type]
+
     except InvalidCiphertextError as cipher_error:
         log.error(
             "Unable to configure database due to a decryption error! Check to ensure your `app_encryption_key` has not changed."

fides/api/db/seed.py

@@ -25,6 +25,7 @@ from fides.api.models.fides_user_permissions import FidesUserPermissions
 from fides.api.models.policy import Policy, Rule, RuleTarget
 from fides.api.models.sql_models import (  # type: ignore[attr-defined]
     Dataset,
+    Organization,
     System,
     sql_model_map,
 )
@@ -44,7 +45,7 @@ from fides.api.util.text import to_snake_case
 from fides.config import CONFIG
 from fides.service.dataset.dataset_config_service import DatasetConfigService
 
-from .crud import create_resource, get_resource, list_resource, upsert_resources
+from .crud import upsert_resources
 from .samples import (
     load_sample_connections_from_project,
     load_sample_resources_from_project,
@@ -282,106 +283,41 @@ def load_default_erasure_policy(
     )
 
 
-def load_default_dsr_policies() -> None:
+def load_default_dsr_policies(session: Session) -> None:
     """
     Checks whether DSR execution policies exist in the database, and
     inserts them to target a default set of data categories if not.
     """
-    with sync_session() as db_session:  # type: ignore[attr-defined]
-        client_id = get_client_id(db_session)
+    client_id = get_client_id(session)
 
-        # By default, include all categories *except* those related to a user's
-        # financial, payment, and credentials data. These are typically not
-        # included in access and erasure requests as they are covered by other
-        # compliance programs (e.g. legal, tax, security) and most
-        # organizations need to be extra careful about how these are used -
-        # especially for erasure! Therefore, a safe default for "out of the
-        # box" behaviour is to exclude these
+    # By default, include all categories *except* those related to a user's
+    # financial, payment, and credentials data. These are typically not
+    # included in access and erasure requests as they are covered by other
+    # compliance programs (e.g. legal, tax, security) and most
+    # organizations need to be extra careful about how these are used -
+    # especially for erasure! Therefore, a safe default for "out of the
+    # box" behaviour is to exclude these
 
-        default_data_categories = get_user_data_categories()
+    default_data_categories = get_user_data_categories()
 
-        log.debug(
-            f"Preparing to create default rules for the following Data Categories: {default_data_categories} if they do not already exist"
-        )
-
-        load_default_access_policy(db_session, client_id, default_data_categories)
-        load_default_erasure_policy(db_session, client_id, default_data_categories)
-
-        log.info("All default policies & rules created")
-
-
-async def load_default_organization(async_session: AsyncSession) -> None:
-    """
-    Seed the database with a default organization unless
-    one with a matching name already exists.
-    """
-
-    log.info("Loading the default organization...")
-    organizations: List[Dict] = list(
-        map(dict, DEFAULT_TAXONOMY.model_dump(mode="json")["organization"])
+    log.debug(
+        f"Preparing to create default rules for the following Data Categories: {default_data_categories} if they do not already exist"
     )
 
-    inserted = 0
-    for org in organizations:
-        try:
-            existing = await get_resource(
-                sql_model_map["organization"],
-                org["fides_key"],
-                async_session,
-                raise_not_found=False,
-            )
-            if not existing:
-                await create_resource(sql_model_map["organization"], org, async_session)
-                inserted += 1
-        except AlreadyExistsError:
-            pass
+    load_default_access_policy(session, client_id, default_data_categories)
+    load_default_erasure_policy(session, client_id, default_data_categories)
 
-    log.debug(f"INSERTED {inserted} organization resource(s)")
-    log.debug(f"SKIPPED {len(organizations)-inserted} organization resource(s)")
-
-
-async def load_default_taxonomy(async_session: AsyncSession) -> None:
-    """Seed the database with the default taxonomy resources."""
-
-    upsert_resource_types = list(DEFAULT_TAXONOMY.model_fields_set)
-    upsert_resource_types.remove("organization")
-
-    log.info("Loading the default fideslang taxonomy resources...")
-    for resource_type in upsert_resource_types:
-        log.debug(f"Processing {resource_type} resources...")
-        default_resources = DEFAULT_TAXONOMY.model_dump(mode="json")[resource_type]
-        existing_resources = await list_resource(
-            sql_model_map[resource_type], async_session
-        )
-        existing_keys = [item.fides_key for item in existing_resources]
-        resources = [
-            resource
-            for resource in default_resources
-            if resource["fides_key"] not in existing_keys
-        ]
-
-        if len(resources) == 0:
-            log.debug(f"No new {resource_type} resources to add from default taxonomy.")
-            continue
-
-        try:
-            await upsert_resources(
-                sql_model_map[resource_type], resources, async_session
-            )
-        except QueryError:  # pragma: no cover
-            pass  # The create_resource function will log the error
-        else:
-            log.debug(f"UPSERTED {len(resources)} {resource_type} resource(s)")
+    log.info("All default policies & rules created")
 
 
-async def load_default_resources(async_session: AsyncSession) -> None:
+def load_default_resources(session: Session) -> None:
     """
     Seed the database with default resources that the application
     expects to be available.
     """
-    await load_default_organization(async_session)
-    await load_default_taxonomy(async_session)
-    load_default_dsr_policies()
+    load_default_organization(session)
+    load_default_taxonomy(session)
+    load_default_dsr_policies(session)
 
 
 async def load_samples(async_session: AsyncSession) -> None:
@@ -549,3 +485,70 @@ async def load_samples(async_session: AsyncSession) -> None:
 
     except QueryError:  # pragma: no cover
         pass  # The upsert_resources function will log any error
+
+
+def load_default_organization(db: Session) -> None:
+    """
+    Seed the database with a default organization unless
+    one with a matching name already exists.
+    """
+    log.info("Loading the default organization...")
+    organizations: List[Dict] = list(
+        map(dict, DEFAULT_TAXONOMY.model_dump(mode="json")["organization"])
+    )
+
+    inserted = 0
+    for org in organizations:
+        try:
+            existing = Organization.get_by(
+                db=db, field="fides_key", value=org["fides_key"]
+            )
+            if not existing:
+                Organization.create(db=db, data=org, check_name=False)
+                inserted += 1
+        except AlreadyExistsError:
+            pass
+
+    log.debug(f"INSERTED {inserted} organization resource(s)")
+    log.debug(f"SKIPPED {len(organizations)-inserted} organization resource(s)")
+
+
+def load_default_taxonomy(db: Session) -> None:
+    """Synchronous version: Seed the database with the default taxonomy resources."""
+    upsert_resource_types = list(DEFAULT_TAXONOMY.model_fields_set)
+    upsert_resource_types.remove("organization")
+
+    log.info("Loading the default fideslang taxonomy resources...")
+    for resource_type in upsert_resource_types:
+        sql_model = sql_model_map[resource_type]
+        log.debug(f"Processing {resource_type} resources...")
+        default_resources = DEFAULT_TAXONOMY.model_dump(mode="json")[resource_type]
+
+        try:
+            # Fetch existing keys first
+            existing_keys = {item[0] for item in db.query(sql_model.fides_key).all()}
+        except Exception as exc:
+            log.error(f"Error fetching existing keys for {resource_type}: {exc}")
+            continue  # Skip this resource type if we can't get existing keys
+
+        # Filter for resources that don't exist
+        resources_to_create = [
+            resource
+            for resource in default_resources
+            if resource["fides_key"] not in existing_keys
+        ]
+
+        if not resources_to_create:
+            log.debug(f"No new {resource_type} resources to add from default taxonomy.")
+            continue
+
+        created_count = 0
+        for resource_data in resources_to_create:
+            try:
+                sql_model.create_or_update(db=db, data=resource_data)
+                created_count += 1
+            except Exception:
+                pass
+
+        if created_count > 0:
+            log.debug(f"UPSERTED {created_count} {resource_type} resource(s)")

fides/api/models/connectionconfig.py

@@ -57,6 +57,7 @@ class ConnectionType(enum.Enum):
     mongodb = "mongodb"
     mssql = "mssql"
     mysql = "mysql"
+    okta = "okta"
     postgres = "postgres"
     rds_mysql = "rds_mysql"
     rds_postgres = "rds_postgres"
@@ -92,6 +93,7 @@ class ConnectionType(enum.Enum):
             ConnectionType.mongodb.value: "MongoDB",
             ConnectionType.mssql.value: "Microsoft SQL Server",
             ConnectionType.mysql.value: "MySQL",
+            ConnectionType.okta.value: "Okta",
             ConnectionType.postgres.value: "PostgreSQL",
             ConnectionType.rds_mysql.value: "RDS MySQL",
             ConnectionType.rds_postgres.value: "RDS Postgres",
@@ -135,6 +137,7 @@ class ConnectionType(enum.Enum):
             ConnectionType.mongodb.value: SystemType.database,
             ConnectionType.mssql.value: SystemType.database,
             ConnectionType.mysql.value: SystemType.database,
+            ConnectionType.okta.value: SystemType.system,
             ConnectionType.postgres.value: SystemType.database,
             ConnectionType.rds_mysql.value: SystemType.database,
             ConnectionType.rds_postgres.value: SystemType.database,

fides/api/schemas/connection_configuration/__init__.py

@@ -92,6 +92,12 @@ from fides.api.schemas.connection_configuration.connection_secrets_mysql import
 from fides.api.schemas.connection_configuration.connection_secrets_mysql import (
     MySQLSchema as MySQLSchema,
 )
+from fides.api.schemas.connection_configuration.connection_secrets_okta import (
+    OktaDocsSchema as OktaDocsSchema,
+)
+from fides.api.schemas.connection_configuration.connection_secrets_okta import (
+    OktaSchema as OktaSchema,
+)
 from fides.api.schemas.connection_configuration.connection_secrets_postgres import (
     PostgreSQLDocsSchema as PostgreSQLDocsSchema,
 )
@@ -172,6 +178,7 @@ secrets_schemas: Dict[str, Any] = {
     ConnectionType.mariadb.value: MariaDBSchema,
     ConnectionType.mongodb.value: MongoDBSchema,
     ConnectionType.mssql.value: MicrosoftSQLServerSchema,
+    ConnectionType.okta.value: OktaSchema,
     ConnectionType.mysql.value: MySQLSchema,
     ConnectionType.postgres.value: PostgreSQLSchema,
     ConnectionType.rds_mysql.value: RDSMySQLSchema,
@@ -231,9 +238,10 @@ connection_secrets_schemas = Union[
     MongoDBDocsSchema,
     MSSQLDocsSchema,
     MySQLDocsSchema,
+    OktaDocsSchema,
+    PostgreSQLDocsSchema,
     RDSMySQLDocsSchema,
     RDSPostgresDocsSchema,
-    PostgreSQLDocsSchema,
     RedshiftDocsSchema,
     S3DocsSchema,
     SaaSSchema,

fides/api/schemas/connection_configuration/connection_secrets_okta.py

@@ -0,0 +1,28 @@
+from typing import ClassVar, List
+
+from pydantic import Field
+
+from fides.api.schemas.base_class import NoValidationSchema
+from fides.api.schemas.connection_configuration.connection_secrets import (
+    ConnectionConfigSecretsSchema,
+)
+
+
+class OktaSchema(ConnectionConfigSecretsSchema):
+    """Schema to validate the secrets needed to connect to Okta"""
+
+    org_url: str = Field(
+        title="Organization URL",
+        description="The URL of your Okta organization (e.g. https://your-org.okta.com)",
+    )
+    api_token: str = Field(
+        title="API Token",
+        description="The API token used to authenticate with Okta",
+        json_schema_extra={"sensitive": True},
+    )
+
+    _required_components: ClassVar[List[str]] = ["org_url", "api_token"]
+
+
+class OktaDocsSchema(OktaSchema, NoValidationSchema):
+    """Okta Secrets Schema for API Docs"""

fides/api/schemas/connection_configuration/enums/system_type.py

@@ -7,4 +7,5 @@ class SystemType(Enum):
     email = "email"
     manual = "manual"
     saas = "saas"
+    system = "system"
     website = "website"

fides/api/service/connectors/__init__.py

@@ -54,6 +54,7 @@ from fides.api.service.connectors.mongodb_connector import (
 from fides.api.service.connectors.mysql_connector import (
     MySQLConnector as MySQLConnector,
 )
+from fides.api.service.connectors.okta_connector import OktaConnector as OktaConnector
 from fides.api.service.connectors.postgres_connector import (
     PostgreSQLConnector as PostgreSQLConnector,
 )
@@ -96,6 +97,7 @@ supported_connectors: Dict[str, Any] = {
     ConnectionType.mongodb.value: MongoDBConnector,
     ConnectionType.mssql.value: MicrosoftSQLServerConnector,
     ConnectionType.mysql.value: MySQLConnector,
+    ConnectionType.okta.value: OktaConnector,
     ConnectionType.postgres.value: PostgreSQLConnector,
     ConnectionType.rds_mysql.value: RDSMySQLConnector,
     ConnectionType.rds_postgres.value: RDSPostgresConnector,

fides/api/service/connectors/okta_connector.py

@@ -0,0 +1,82 @@
+from typing import Any, Dict, List, Optional
+
+from okta.client import Client as OktaClient
+from okta.exceptions import OktaAPIException
+
+from fides.api.common_exceptions import ConnectionException
+from fides.api.graph.execution import ExecutionNode
+from fides.api.models.connectionconfig import ConnectionTestStatus
+from fides.api.models.policy import Policy
+from fides.api.models.privacy_request import PrivacyRequest, RequestTask
+from fides.api.service.connectors.base_connector import BaseConnector
+from fides.api.service.connectors.query_configs.query_config import QueryConfig
+from fides.api.util.collection_util import Row
+
+
+class OktaConnector(BaseConnector):
+    """
+    Okta connector for integrating with Okta's API.
+    This connector allows for user management and authentication operations.
+    """
+
+    @property
+    def dsr_supported(self) -> bool:
+        return False
+
+    def create_client(self) -> OktaClient:
+        """Creates and returns an Okta client instance"""
+        try:
+            return OktaClient(
+                {
+                    "orgUrl": self.configuration.secrets["org_url"],
+                    "token": self.configuration.secrets["api_token"],
+                }
+            )
+        except Exception as e:
+            raise ConnectionException(f"Failed to create Okta client: {str(e)}")
+
+    def query_config(self, node: ExecutionNode) -> QueryConfig[Any]:
+        """Return the query config that corresponds to this connector type"""
+        raise NotImplementedError("Query config not implemented for Okta")
+
+    def test_connection(self) -> Optional[ConnectionTestStatus]:
+        """
+        Validates the connection to Okta by attempting to list users.
+        """
+        try:
+            client = self.client()
+            # Try to list applications as a test of the connection
+            client.list_applications()
+            return ConnectionTestStatus.succeeded
+        except OktaAPIException as e:
+            raise ConnectionException(f"Failed to connect to Okta: {str(e)}")
+        except Exception as e:
+            raise ConnectionException(
+                f"Unexpected error testing Okta connection: {str(e)}"
+            )
+
+    def retrieve_data(
+        self,
+        node: ExecutionNode,
+        policy: Policy,
+        privacy_request: PrivacyRequest,
+        request_task: RequestTask,
+        input_data: Dict[str, List[Any]],
+    ) -> List[Row]:
+        """DSR execution not supported for Okta connector"""
+        return []
+
+    def mask_data(
+        self,
+        node: ExecutionNode,
+        policy: Policy,
+        privacy_request: PrivacyRequest,
+        request_task: RequestTask,
+        rows: List[Row],
+    ) -> int:
+        """DSR execution not supported for Okta connector"""
+        return 0
+
+    def close(self) -> None:
+        """Close any held resources"""
+        # No resources to close for Okta client

fides/api/service/connectors/website_connector.py

@@ -20,6 +20,9 @@ class WebsiteConnector(BaseConnector):
     NOTE: No DSR processing is supported for Website connectors.
     """
 
+    def dsr_supported(self) -> bool:
+        return False
+
     def create_client(self) -> Any:  # type: ignore
         """Returns a client for the website"""