ethyca-fides 2.58.2b3__py2.py3-none-any.whl → 2.58.2rc0__py2.py3-none-any.whl

fides/api/alembic/migrations/versions/6e565c16dae1_add_tcf_publisher_restrictions.py

@@ -1,107 +0,0 @@
-"""Add TCF Publisher Restrictions
-
-Revision ID: 6e565c16dae1
-Revises: 67d01c4e124e
-Create Date: 2025-04-02 12:35:34.105607
-
-"""
-
-import sqlalchemy as sa
-from alembic import op
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision = "6e565c16dae1"
-down_revision = "67d01c4e124e"
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # Create tcf_configuration table
-    op.create_table(
-        "tcf_configuration",
-        sa.Column("id", sa.String(length=255), nullable=False),
-        sa.Column(
-            "created_at",
-            sa.DateTime(timezone=True),
-            server_default=sa.text("now()"),
-            nullable=True,
-        ),
-        sa.Column(
-            "updated_at",
-            sa.DateTime(timezone=True),
-            server_default=sa.text("now()"),
-            nullable=True,
-        ),
-        sa.Column("name", sa.String(), nullable=False),
-        sa.PrimaryKeyConstraint("id"),
-        sa.UniqueConstraint("name"),
-    )
-    # Create tcf_publisher_restriction table
-    op.create_table(
-        "tcf_publisher_restriction",
-        sa.Column("id", sa.String(length=255), nullable=False),
-        sa.Column(
-            "created_at",
-            sa.DateTime(timezone=True),
-            server_default=sa.text("now()"),
-            nullable=True,
-        ),
-        sa.Column(
-            "updated_at",
-            sa.DateTime(timezone=True),
-            server_default=sa.text("now()"),
-            nullable=True,
-        ),
-        sa.Column("tcf_configuration_id", sa.String(255), nullable=False),
-        sa.Column("purpose_id", sa.Integer(), nullable=False),
-        sa.Column(
-            "restriction_type",
-            sa.Enum(
-                "purpose_restriction",
-                "require_consent",
-                "require_legitimate_interest",
-                name="tcfrestrictiontype",
-            ),
-            nullable=False,
-        ),
-        sa.Column(
-            "vendor_restriction",
-            sa.Enum(
-                "restrict_all_vendors",
-                "allow_specific_vendors",
-                "restrict_specific_vendors",
-                name="tcfvendorrestriction",
-            ),
-            nullable=False,
-        ),
-        sa.Column(
-            "range_entries",
-            postgresql.ARRAY(postgresql.JSONB(astext_type=sa.Text())),
-            server_default="{}",
-            nullable=False,
-        ),
-        sa.ForeignKeyConstraint(
-            ["tcf_configuration_id"],
-            ["tcf_configuration.id"],
-            ondelete="CASCADE",
-        ),
-        sa.PrimaryKeyConstraint("id"),
-    )
-    op.create_index(
-        op.f("ix_tcf_publisher_restriction_config_purpose"),
-        "tcf_publisher_restriction",
-        ["tcf_configuration_id", "purpose_id"],
-        unique=False,
-    )
-
-
-def downgrade():
-    # Drop tables
-    op.drop_table("tcf_publisher_restriction")
-    op.drop_table("tcf_configuration")
-
-    # Drop enums
-    op.execute("DROP TYPE tcfrestrictiontype")
-    op.execute("DROP TYPE tcfvendorrestriction")

fides/api/alembic/migrations/versions/99c603c1b8f9_add_password_login_enabled_and_totp_secret_to_fidesuser.py

@@ -1,45 +0,0 @@
-"""add password login enabled and totp secret to fidesuser
-
-Revision ID: 99c603c1b8f9
-Revises: 6e565c16dae1
-Create Date: 2025-04-02 01:55:57.890545
-
-"""
-
-import sqlalchemy as sa
-import sqlalchemy_utils
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = "99c603c1b8f9"
-down_revision = "6e565c16dae1"
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    op.add_column(
-        "fidesuser",
-        sa.Column(
-            "password_login_enabled",
-            sa.Boolean(),
-            nullable=True,
-        ),
-    )
-    op.add_column(
-        "fidesuser",
-        sa.Column(
-            "totp_secret",
-            sqlalchemy_utils.types.encrypted.encrypted_type.StringEncryptedType(),
-            nullable=True,
-        ),
-    )
-    op.alter_column("fidesuser", "hashed_password", nullable=True)
-    op.alter_column("fidesuser", "salt", nullable=True)
-
-
-def downgrade():
-    op.alter_column("fidesuser", "hashed_password", nullable=False)
-    op.alter_column("fidesuser", "salt", nullable=False)
-    op.drop_column("fidesuser", "totp_secret")
-    op.drop_column("fidesuser", "password_login_enabled")

fides/api/models/tcf_publisher_restrictions.py

@@ -1,304 +0,0 @@
-from enum import Enum
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, Field, ValidationError, model_validator
-from sqlalchemy import Column
-from sqlalchemy import Enum as EnumColumn
-from sqlalchemy import ForeignKey, Index, Integer, String, insert, select, update
-from sqlalchemy.dialects.postgresql import ARRAY, JSONB
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.ext.declarative import declared_attr
-from sqlalchemy.orm import Session
-
-from fides.api.db.base_class import Base
-
-
-class TCFRestrictionType(str, Enum):
-    """Enum for TCF restriction types"""
-
-    purpose_restriction = "purpose_restriction"
-    require_consent = "require_consent"
-    require_legitimate_interest = "require_legitimate_interest"
-
-
-class TCFVendorRestriction(str, Enum):
-    """Enum for TCF vendor restriction types"""
-
-    restrict_all_vendors = "restrict_all_vendors"
-    allow_specific_vendors = "allow_specific_vendors"
-    restrict_specific_vendors = "restrict_specific_vendors"
-
-
-# This is Pydantic model used for validation, not a database model!
-class RangeEntry(BaseModel):
-    """
-    Pydantic model that represents a vendor range entry as per the TCF spec,
-    used for Publisher Restrictions.
-    A range entry must have a start_vendor_id and optionally an end_vendor_id.
-    If end_vendor_id is present, it must be greater than start_vendor_id.
-    """
-
-    start_vendor_id: int = Field(description="The starting vendor ID in the range")
-    end_vendor_id: Optional[int] = Field(
-        default=None, description="The ending vendor ID in the range (inclusive)"
-    )
-
-    @model_validator(mode="after")
-    def validate_vendor_range(self) -> "RangeEntry":
-        """Validates that end_vendor_id is greater than start_vendor_id if present."""
-        if (
-            self.end_vendor_id is not None
-            and self.end_vendor_id <= self.start_vendor_id
-        ):
-            raise ValueError("end_vendor_id must be greater than start_vendor_id")
-        return self
-
-    def get_end(self) -> int:
-        """Get the effective end of the range."""
-        return self.end_vendor_id or self.start_vendor_id
-
-    def overlaps_with(self, other: "RangeEntry") -> bool:
-        """
-        Check if this range overlaps with another range.
-        Two ranges overlap if the end of the range that starts first is greater than
-        or equal to the start of the range that starts second.
-        """
-        # Sort ranges by start_vendor_id
-        first = self if self.start_vendor_id <= other.start_vendor_id else other
-        second = other if self.start_vendor_id <= other.start_vendor_id else self
-
-        # If first range's end is >= second range's start, they overlap
-        return first.get_end() >= second.start_vendor_id
-
-
-class TCFConfiguration(Base):
-    """
-    Stores TCF Configuration settings.
-    """
-
-    @declared_attr
-    def __tablename__(self) -> str:
-        return "tcf_configuration"
-
-    name = Column(String, nullable=False, index=True, unique=True)
-
-
-class TCFPublisherRestriction(Base):
-    """
-    Stores TCF Publisher Restrictions. TCF Publisher Restrictions belong to a TCF Configuration,
-    and specify the restriction type and vendor restriction for a given purpose.
-    """
-
-    @declared_attr
-    def __tablename__(self) -> str:
-        return "tcf_publisher_restriction"
-
-    tcf_configuration_id = Column(
-        String(255),
-        ForeignKey("tcf_configuration.id", ondelete="CASCADE"),
-        nullable=False,
-        index=True,
-    )
-    purpose_id = Column(Integer, nullable=False)
-    restriction_type = Column(EnumColumn(TCFRestrictionType), nullable=False)
-    vendor_restriction = Column(EnumColumn(TCFVendorRestriction), nullable=False)
-
-    # range_entries represents a list of RangeEntry objects as per the TCF spec.
-    # A RangeEntry object will have a start_vendor_id and an end_vendor_id (the
-    # end vendor id is included in the range).
-    # If the range represents a single vendor, then the end_vendor_id can be omitted.
-    # TCF spec also includes an IsARange boolean, which we are omitting because it
-    # can be inferred from the presence of the end_vendor_id.
-    range_entries = Column(
-        ARRAY(JSONB),
-        nullable=True,
-        server_default="{}",
-        default=list,
-    )
-
-    __table_args__ = (
-        Index(
-            "ix_tcf_publisher_restriction_config_purpose",
-            "tcf_configuration_id",
-            "purpose_id",
-        ),
-    )
-
-    def __init__(self, **kwargs: Any) -> None:
-        validated_kwargs = self.validate_publisher_restriction_data(kwargs)
-        super().__init__(**validated_kwargs)
-
-    @staticmethod
-    def validate_entires_for_vendor_restriction(
-        entries: List[RangeEntry], vendor_restriction: TCFVendorRestriction
-    ) -> None:
-        """
-        Validates that if vendor_restriction is restrict_all_vendors, then the entries list is empty.
-        """
-        if vendor_restriction == TCFVendorRestriction.restrict_all_vendors and entries:
-            raise ValueError("restrict_all_vendors cannot have any range entries")
-
-    @staticmethod
-    def check_for_overlaps(entries: List[RangeEntry]) -> None:
-        """
-        Check for overlapping ranges in a list of RangeEntry objects,
-        raises a ValueError if any pair of RangeEntry overlaps with each other.
-        Sorts the ranges by start_vendor_id and compares adjacent ranges.
-        """
-        # Sort ranges by start_vendor_id
-        sorted_entries = sorted(entries, key=lambda x: x.start_vendor_id)
-
-        # Compare each range with the next one
-        for i in range(len(sorted_entries) - 1):
-            current = sorted_entries[i]
-            next_entry = sorted_entries[i + 1]
-            if current.overlaps_with(next_entry):
-                raise ValueError(
-                    f"Overlapping ranges found: {current.model_dump()} overlaps with {next_entry.model_dump()}"
-                )
-
-    @classmethod
-    def validate_publisher_restriction_data(
-        cls, data: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Validate the restriction data.
-        """
-        raw_range_entries = data.get("range_entries", [])
-
-        try:
-            # Validate each range entry using the Pydantic model
-            validated_entries = [
-                RangeEntry.model_validate(entry) for entry in raw_range_entries
-            ]
-        except ValidationError as e:
-            raise ValueError(f"Invalid range entry: {str(e)}")
-
-        # Validate the entries for the vendor restriction
-        cls.validate_entires_for_vendor_restriction(
-            validated_entries, data["vendor_restriction"]
-        )
-        # Check for overlapping ranges
-        cls.check_for_overlaps(validated_entries)
-
-        data["range_entries"] = [entry.model_dump() for entry in validated_entries]
-
-        return data
-
-    @classmethod
-    async def validate_vendor_overlaps_for_purpose(
-        cls,
-        async_db: AsyncSession,
-        configuration_id: str,
-        purpose_id: int,
-        new_data: dict,
-    ) -> None:
-        """
-        Validates that the new vendor ranges do not overlap with any existing vendor ranges for the purpose
-        in the given configuration.
-        Raises a ValueError if any vendor ranges overlap.
-        """
-        # First, get all the restrictions for the purpose in the given configuration
-        query = (
-            select(cls)  # type: ignore[arg-type]
-            .where(cls.tcf_configuration_id == configuration_id)
-            .where(cls.purpose_id == purpose_id)
-        )
-        restrictions = await async_db.execute(query)
-        restrictions = restrictions.scalars().all()
-
-        # If we have an existing id, we need to exclude the current restriction from the list of existing restrictions
-        # so that the new_data restrictions don't overlap with themselves
-        if "id" in new_data:
-            existing_entries = [
-                entry
-                for r in restrictions
-                for entry in r.range_entries
-                if r.id != new_data["id"]
-            ]
-        else:
-            existing_entries = [
-                entry for r in restrictions for entry in r.range_entries
-            ]
-
-        all_entries = [*existing_entries, *new_data.get("range_entries", [])]
-        cls.check_for_overlaps(
-            [RangeEntry.model_validate(entry) for entry in all_entries]
-        )
-
-    @classmethod
-    def create(
-        cls,
-        db: Session,
-        *,
-        data: Dict[str, Any],
-        check_name: bool = True,
-    ) -> "TCFPublisherRestriction":
-        raise NotImplementedError("Use create_async instead")
-
-    @classmethod
-    async def create_async(
-        cls,
-        async_db: AsyncSession,
-        *,
-        data: Dict[str, Any],
-    ) -> "TCFPublisherRestriction":
-        """
-        Create a new TCFPublisherRestriction with validated range_entries.
-        """
-
-        data = cls.validate_publisher_restriction_data(data)
-
-        values = {
-            "tcf_configuration_id": data["tcf_configuration_id"],
-            "purpose_id": data["purpose_id"],
-            "restriction_type": data["restriction_type"],
-            "vendor_restriction": data["vendor_restriction"],
-            "range_entries": data["range_entries"],
-        }
-
-        # Validate that the new vendor ranges do not overlap with any existing vendor ranges for the purpose
-        await cls.validate_vendor_overlaps_for_purpose(
-            async_db=async_db,
-            configuration_id=data["tcf_configuration_id"],
-            purpose_id=data["purpose_id"],
-            new_data=values,
-        )
-
-        # Insert the new restriction
-        insert_stmt = insert(cls).values(values)  # type: ignore[arg-type]
-        result = await async_db.execute(insert_stmt)
-        record_id = result.inserted_primary_key.id
-
-        created_record = await async_db.execute(select(cls).where(cls.id == record_id))  # type: ignore[arg-type]
-        return created_record.scalars().first()
-
-    async def update_async(
-        self, async_db: AsyncSession, data: Dict[str, Any]
-    ) -> "TCFPublisherRestriction":
-        """
-        Update a TCFPublisherRestriction with the data.
-        Validates the data and checks for vendor overlaps.
-        """
-        # Validate the data on its own
-        data = self.validate_publisher_restriction_data(data)
-
-        # Validate that the new vendor ranges do not overlap with any existing vendor ranges for the purpose
-        await self.validate_vendor_overlaps_for_purpose(
-            async_db=async_db,
-            configuration_id=self.tcf_configuration_id,
-            purpose_id=self.purpose_id,
-            new_data={**data, "id": self.id},  # Pass in id explicitly
-        )
-
-        # Finally, make the update
-        update_query = (
-            update(TCFPublisherRestriction)  # type: ignore[arg-type]
-            .where(TCFPublisherRestriction.id == self.id)
-            .values(**data)
-        )
-        await async_db.execute(update_query)
-        await async_db.commit()
-        await async_db.refresh(self)
-
-        return self

fides/service/error_handling/error_handler.py

@@ -1,202 +0,0 @@
-from functools import wraps
-from typing import Any, Callable, Optional, TypeVar
-
-from fastapi import HTTPException
-from loguru import logger
-from starlette.status import HTTP_400_BAD_REQUEST, HTTP_422_UNPROCESSABLE_ENTITY
-
-T = TypeVar("T")
-
-
-class ErrorHandler:
-    """Utility class for handling errors consistently throughout the application.
-
-    Usage Examples:
-    -----------------------------------------------------------------------------
-
-    1. Basic Validation:
-    ```python
-    from fastapi import FastAPI
-    from fides.service.error_handling.error_handler import ErrorHandler
-
-    app = FastAPI()
-
-    @app.post("/users")
-    def create_user(age: int):
-        # Simple validation
-        ErrorHandler.validate(age >= 18, "User must be 18 or older")
-        return {"message": "User created"}
-
-    @app.get("/items/{item_id}")
-    def get_item(item_id: str):
-        # Direct error raising
-        if not item_id:
-            ErrorHandler.raise_error("Item ID is required", status_code=400)
-        return {"item_id": item_id}
-    ```
-
-    2. Exception Handling Decorator:
-    ```python
-    @app.post("/orders")
-    @ErrorHandler.handle_exceptions("Failed to create order")
-    def create_order(order_data: dict):
-        if not order_data.get("items"):
-            raise ValueError("Order must contain items")
-        # Process order...
-        return {"message": "Order created"}
-
-    @app.get("/products/{product_id}")
-    @ErrorHandler.handle_exceptions("Failed to fetch product", status_code=404)
-    def get_product(product_id: str):
-        product = database.get_product(product_id)
-        if not product:
-            raise ValueError("Product not found")
-        return product
-    ```
-
-    3. Complex Validation:
-    ```python
-    @app.post("/payments")
-    @ErrorHandler.handle_exceptions("Payment processing failed")
-    def process_payment(payment: dict):
-        # Validate amount
-        ErrorHandler.validate(
-            payment.get("amount", 0) > 0,
-            "Payment amount must be positive",
-            HTTP_400_BAD_REQUEST
-        )
-
-        # Validate currency
-        ErrorHandler.validate(
-            payment.get("currency") in ["USD", "EUR"],
-            "Invalid currency",
-            HTTP_400_BAD_REQUEST,
-            "Unsupported currency provided"  # Optional log message
-        )
-
-        # Custom error for insufficient funds
-        if payment.get("amount", 0) > get_balance():
-            ErrorHandler.raise_error(
-                "Insufficient funds",
-                status_code=HTTP_400_BAD_REQUEST,
-                log_message="User attempted payment exceeding balance"
-            )
-
-        return {"status": "payment processed"}
-    ```
-
-    4. Error Logging:
-    ```python
-    @app.post("/imports")
-    @ErrorHandler.handle_exceptions("Import failed")
-    def import_data(data: dict):
-        try:
-            process_import(data)
-        except Exception as e:
-            # Log error with custom message before raising
-            ErrorHandler.raise_error(
-                "Import failed: invalid format",
-                status_code=400,
-                log_message=f"Import failed with error: {str(e)}"
-            )
-        return {"status": "import complete"}
-    ```
-
-    Key Features:
-    - Simple validation with custom error messages
-    - Consistent error handling across endpoints
-    - Built-in error logging
-    - HTTP status code customization
-    - Exception handling decorator for common patterns
-    """
-
-    @staticmethod
-    def raise_error(
-        detail: str,
-        status_code: int = HTTP_422_UNPROCESSABLE_ENTITY,
-        log_message: Optional[str] = None,
-    ) -> None:
-        """Raise an HTTPException with consistent logging.
-
-        Args:
-            detail: Error message to include in the HTTPException
-            status_code: HTTP status code to use (default: 422)
-            log_message: Optional message to log before raising the exception
-
-        Raises:
-            HTTPException: Always raised with the provided details
-        """
-        if log_message:
-            logger.error(log_message)
-        raise HTTPException(status_code=status_code, detail=detail)
-
-    @staticmethod
-    def validate(
-        condition: bool,
-        detail: str,
-        status_code: int = HTTP_400_BAD_REQUEST,
-        log_message: Optional[str] = None,
-    ) -> None:
-        """Validate a condition and raise an error if it's False.
-
-        Args:
-            condition: The condition to check
-            detail: Error message if condition is False
-            status_code: HTTP status code to use if condition is False
-            log_message: Optional message to log before raising the exception
-
-        Raises:
-            HTTPException: If the condition is False
-        """
-        if not condition:
-            ErrorHandler.raise_error(detail, status_code, log_message)
-
-    @classmethod
-    def handle_exceptions(
-        cls, error_message: str, status_code: int = HTTP_422_UNPROCESSABLE_ENTITY
-    ) -> Callable[[Callable[..., T]], Callable[..., T]]:
-        """Decorator to handle exceptions consistently.
-
-        Args:
-            error_message: Base error message to use
-            status_code: HTTP status code to use for unexpected errors
-
-        Returns:
-            Callable: The decorated function that handles exceptions
-
-        Note:
-            This decorator will catch specific exceptions and convert them to HTTPExceptions.
-            HTTPExceptions are re-raised as is, while other exceptions are wrapped with
-            additional context.
-        """
-
-        def decorator(func: Callable[..., T]) -> Callable[..., T]:
-            @wraps(func)
-            def wrapper(*args: Any, **kwargs: Any) -> Optional[T]:
-                try:
-                    return func(*args, **kwargs)
-                except HTTPException:
-                    # Re-raise HTTP exceptions without modification
-                    raise
-                except (ValueError, TypeError, AttributeError, KeyError) as e:
-                    # Handle common validation and data access errors
-                    cls.raise_error(
-                        f"{error_message}: {str(e)}",
-                        status_code,
-                        f"{error_message}: {e}",
-                    )
-                except Exception as e:  # pylint: disable=broad-except
-                    # Log unexpected errors with full context but present a sanitized message
-                    logger.error(
-                        f"Unexpected error in {func.__name__}: {str(e)}", exc_info=True
-                    )
-                    cls.raise_error(
-                        f"{error_message}: An unexpected error occurred",
-                        status_code,
-                        f"{error_message}: Unexpected {type(e).__name__}",
-                    )
-                return None  # This line is never reached but satisfies the return type checker
-
-            return wrapper  # type: ignore[return-value]
-
-        return decorator