ethyca-fides 2.70.6rc0__py2.py3-none-any.whl → 2.71.0__py2.py3-none-any.whl

fides/api/models/detection_discovery/classification_benchmark.py

@@ -0,0 +1,140 @@
+"""
+Database model for classification benchmark results.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import ARRAY, Column, ForeignKey, String
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.ext.mutable import MutableDict
+from sqlalchemy.orm import Query, RelationshipProperty, Session, relationship
+
+from fides.api.db.base_class import Base, FidesBase
+from fides.api.models.detection_discovery.core import MonitorConfig
+from fides.api.models.sql_models import Dataset  # type: ignore[attr-defined]
+
+
+class ClassificationBenchmark(Base, FidesBase):
+    """
+    Database model for storing classification benchmark results.
+
+    This model stores the results of classification accuracy benchmarks that compare
+    system-assigned classifications on staged resources with ground truth data from datasets.
+    """
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return "classification_benchmark"
+
+    # Foreign key relationships
+    monitor_config_key = Column(
+        String,
+        ForeignKey(MonitorConfig.key, ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    dataset_fides_key = Column(
+        String,
+        ForeignKey(Dataset.fides_key, ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+
+    # Resource URNs (array of strings)
+    resource_urns = Column(
+        ARRAY(String),
+        nullable=False,
+        server_default="{}",
+        default=list,
+    )
+
+    # Overall accuracy metrics stored as JSONB
+    overall_metrics = Column(
+        MutableDict.as_mutable(JSONB),
+        nullable=True,
+        server_default=None,
+        default=None,
+    )
+
+    # Field-level accuracy details stored as JSONB array
+    field_accuracy_details = Column(
+        ARRAY(JSONB),
+        nullable=False,
+        server_default="{}",
+        default=list,
+    )
+
+    # Status and messages for tracking benchmark execution
+    status = Column(
+        String,
+        nullable=False,
+        server_default="'pending'",
+        default="pending",
+        index=True,
+    )
+    messages = Column(
+        ARRAY(String),
+        nullable=False,
+        server_default="{}",
+        default=list,
+    )
+
+    # Relationships
+    monitor_config: RelationshipProperty[MonitorConfig] = relationship(
+        MonitorConfig,
+        foreign_keys=[monitor_config_key],
+        primaryjoin="ClassificationBenchmark.monitor_config_key == MonitorConfig.key",
+    )
+
+    dataset: RelationshipProperty[Dataset] = relationship(
+        Dataset,
+        foreign_keys=[dataset_fides_key],
+        primaryjoin="ClassificationBenchmark.dataset_fides_key == Dataset.fides_key",
+    )
+
+    @classmethod
+    def list_benchmarks(
+        cls,
+        db: Session,
+        monitor_config_key: Optional[str] = None,
+        dataset_fides_key: Optional[str] = None,
+        created_after: Optional[datetime] = None,
+        created_before: Optional[datetime] = None,
+        status: Optional[str] = None,
+    ) -> Query:
+        """
+        Get a filtered query for benchmarks.
+
+        Args:
+            db: Database session
+            monitor_config_key: Filter by monitor config key
+            dataset_fides_key: Filter by dataset fides key
+            created_after: Filter by creation date (inclusive)
+            created_before: Filter by creation date (exclusive)
+            status: Filter by status
+        Returns:
+            Filtered query (not executed)
+        """
+        # Build the query with filters
+        query = db.query(cls)
+
+        # Apply filters
+        if monitor_config_key:
+            query = query.filter(cls.monitor_config_key == monitor_config_key)
+        if dataset_fides_key:
+            query = query.filter(cls.dataset_fides_key == dataset_fides_key)
+        if created_after:
+            query = query.filter(cls.created_at >= created_after)
+        if created_before:
+            query = query.filter(cls.created_at < created_before)
+        if status:
+            query = query.filter(cls.status == status)
+
+        # Apply sorting
+        query = query.order_by(cls.created_at.desc())
+
+        return query

fides/api/models/detection_discovery/core.py

@@ -599,6 +599,17 @@ class StagedResource(Base):
             "vendor_id",
             text("(meta->>'consent_aggregated')"),
         ),
+        # GIN indices for array operations (&&, @>, <@)
+        Index(
+            "idx_stagedresource_classifications_gin",
+            "classifications",
+            postgresql_using="gin",
+        ),
+        Index(
+            "idx_stagedresource_user_categories_gin",
+            "user_assigned_data_categories",
+            postgresql_using="gin",
+        ),
     )
 
     @classmethod

fides/api/models/detection_discovery/monitor_task.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from enum import Enum
 from typing import List, Optional
 
-from sqlalchemy import ARRAY, Column
+from sqlalchemy import ARRAY, Boolean, Column
 from sqlalchemy import Enum as SQLAlchemyEnum
 from sqlalchemy import ForeignKey, String
 from sqlalchemy.dialects.postgresql import JSONB
@@ -51,6 +51,7 @@ class MonitorTask(WorkerTask, Base):
     )
     staged_resource_urns = Column(ARRAY(String), nullable=True)
     child_resource_urns = Column(ARRAY(String), nullable=True)
+    dismissed = Column(Boolean, nullable=False, default=False)
 
     monitor_config = relationship(MonitorConfig, cascade="all, delete")
     execution_logs = relationship(

fides/api/models/digest/__init__.py

@@ -0,0 +1,10 @@
+"""Digest models package."""
+
+from fides.api.models.digest.conditional_dependencies import DigestConditionType
+from fides.api.models.digest.digest_config import DigestConfig, DigestType
+
+__all__ = [
+    "DigestConfig",
+    "DigestType",
+    "DigestConditionType",
+]

fides/api/models/digest/conditional_dependencies.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class DigestConditionType(str, Enum):
+    """Types of digest conditions - each can have their own tree."""
+
+    RECEIVER = "receiver"
+    CONTENT = "content"
+    PRIORITY = "priority"

fides/api/models/digest/digest_config.py

@@ -0,0 +1,76 @@
+from enum import Enum
+from typing import Optional, Union
+
+from sqlalchemy import Boolean, Column, DateTime, String, Text
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import Session
+
+from fides.api.db.base_class import Base
+from fides.api.db.util import EnumColumn
+from fides.api.models.digest.conditional_dependencies import DigestConditionType
+from fides.api.schemas.messaging.messaging import MessagingMethod
+from fides.api.task.conditional_dependencies.schemas import (
+    Condition,
+    ConditionGroup,
+    ConditionLeaf,
+)
+
+
+class DigestType(str, Enum):
+    """Types of digests that can be configured."""
+
+    MANUAL_TASKS = "manual_tasks"
+    PRIVACY_REQUESTS = "privacy_requests"
+    # More types can be added here
+
+
+class DigestConfig(Base):
+    """Generic configuration for any type of digest."""
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return "digest_config"
+
+    # Digest identification
+    digest_type = Column(EnumColumn(DigestType), nullable=False, index=True)
+    name = Column(String(255), nullable=False)
+    description = Column(Text, nullable=True)
+
+    # Configuration
+    enabled = Column(Boolean, nullable=False, default=True, index=True)
+    messaging_service_type = Column(
+        EnumColumn(MessagingMethod),
+        nullable=False,
+        default=MessagingMethod.EMAIL,
+        index=True,
+    )
+    cron_expression = Column(String(100), nullable=False, default="0 9 * * 1")
+    timezone = Column(String(50), nullable=False, default="US/Eastern")
+    last_sent_at = Column(DateTime(timezone=True), nullable=True)
+    next_scheduled_at = Column(DateTime(timezone=True), nullable=True, index=True)
+    config_metadata = Column(JSONB, nullable=True, default={})
+
+    def get_receiver_conditions(
+        self, db: Session
+    ) -> Optional[Union[ConditionLeaf, ConditionGroup]]:
+        """Get receiver conditions for this digest config."""
+        raise NotImplementedError("Conditions are not implemented for digests")
+
+    def get_content_conditions(
+        self, db: Session
+    ) -> Optional[Union[ConditionLeaf, ConditionGroup]]:
+        """Get content conditions for this digest config."""
+        raise NotImplementedError("Conditions are not implemented for digests")
+
+    def get_priority_conditions(
+        self, db: Session
+    ) -> Optional[Union[ConditionLeaf, ConditionGroup]]:
+        """Get priority conditions for this digest config."""
+        raise NotImplementedError("Conditions are not implemented for digests")
+
+    def get_all_conditions(
+        self, db: Session
+    ) -> dict["DigestConditionType", Optional[Condition]]:
+        """Get all condition types for this digest config."""
+        raise NotImplementedError("Conditions are not implemented for digests")

fides/api/models/manual_task/conditional_dependency.py

@@ -1,13 +1,14 @@
-from enum import Enum
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
-from sqlalchemy import Column, ForeignKey, Index, Integer, String
-from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy import Column, ForeignKey, Index, String
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import Session, relationship
 
-from fides.api.db.base_class import Base, FidesBase
-from fides.api.db.util import EnumColumn
+from fides.api.db.base_class import FidesBase
+from fides.api.models.conditional_dependency.conditional_dependency_base import (
+    ConditionalDependencyBase,
+    ConditionalDependencyType,
+)
 from fides.api.task.conditional_dependencies.schemas import (
     ConditionGroup,
     ConditionLeaf,
@@ -17,42 +18,16 @@ if TYPE_CHECKING:
     from fides.api.models.manual_task.manual_task import ManualTask
 
 
-class ManualTaskConditionalDependencyType(str, Enum):
-    """Enum for manual task conditional dependency types.
-
-    This enum defines the two types of nodes in a conditional dependency tree:
-
-    - leaf: A terminal node that represents a single condition (e.g., "user.age >= 18")
-    - group: A non-terminal node that groups multiple conditions with logical operators (AND/OR)
-
-    Examples:
-        leaf: Used for simple field comparisons like:
-            - "user.name exists"
-            - "user.age >= 18"
-            - "billing.subscription.status == 'active'"
-
-        group: Used to combine multiple conditions with logical operators:
-            - AND group: "user.age >= 18 AND user.active == true"
-            - OR group: "user.role == 'admin' OR user.verified == true"
-            - Nested groups: "(user.age >= 18 AND (user.role == 'admin' OR user.verified == true))"
-    """
-
-    leaf = "leaf"
-    group = "group"
-
-
-class ManualTaskConditionalDependency(Base):
-    """Model for storing conditional dependencies."""
+class ManualTaskConditionalDependency(ConditionalDependencyBase):
+    """Manual task conditional dependencies - single type hierarchy."""
 
     @declared_attr
     def __tablename__(cls) -> str:
-        """Overriding base class method to set the table name."""
         return "manual_task_conditional_dependency"
 
     # We need to redefine it here so that self-referential relationships
     # can properly reference the `id` column instead of the built-in Python function.
     id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
-
     # Foreign key relationships
     manual_task_id = Column(
         String, ForeignKey("manual_task.id", ondelete="CASCADE"), nullable=False
@@ -63,18 +38,6 @@ class ManualTaskConditionalDependency(Base):
         nullable=True,
     )
 
-    # Condition metadata
-    condition_type = Column(
-        EnumColumn(ManualTaskConditionalDependencyType), nullable=False
-    )  # leaf or group
-    field_address = Column(String, nullable=True)  # For leaf conditions
-    operator = Column(String, nullable=True)  # For leaf conditions
-    value = Column(JSONB, nullable=True)  # For leaf conditions
-    logical_operator = Column(String, nullable=True)  # 'and' or 'or' for groups
-
-    # Ordering
-    sort_order = Column(Integer, nullable=False, default=0)
-
     __table_args__ = (
         Index("ix_manual_task_conditional_dependency_manual_task_id", "manual_task_id"),
         Index("ix_manual_task_conditional_dependency_parent_id", "parent_id"),
@@ -97,38 +60,20 @@ class ManualTaskConditionalDependency(Base):
         foreign_keys=[parent_id],
     )
 
-    def to_condition_leaf(self) -> ConditionLeaf:
-        """Convert to ConditionLeaf if this is a leaf condition"""
-        if self.condition_type != "leaf":
-            raise ValueError("Cannot convert group condition to leaf")
-
-        return ConditionLeaf(
-            field_address=self.field_address, operator=self.operator, value=self.value
-        )
-
-    def to_condition_group(self) -> ConditionGroup:
-        """Convert to ConditionGroup if this is a group condition"""
-        if self.condition_type != "group":
-            raise ValueError("Cannot convert leaf condition to group")
-
-        # Recursively build children
-        child_conditions = []
-        children_list = [child for child in self.children]  # type: ignore[attr-defined]
-        for child in sorted(children_list, key=lambda x: x.sort_order):
-            if child.condition_type == "leaf":
-                child_conditions.append(child.to_condition_leaf())
-            else:
-                child_conditions.append(child.to_condition_group())
-
-        return ConditionGroup(
-            logical_operator=self.logical_operator, conditions=child_conditions
-        )
-
     @classmethod
     def get_root_condition(
-        cls, db: Session, manual_task_id: str
+        cls, db: Session, *args: Any, **kwargs: Any
     ) -> Optional[Union[ConditionLeaf, ConditionGroup]]:
-        """Get the root condition for a config"""
+        """Get the root condition for a manual task
+
+        Args:
+            db: Database session
+            manual_task_id: ID of the manual task (first positional arg)
+        """
+        if not args:
+            raise ValueError("manual_task_id is required as first positional argument")
+
+        manual_task_id = args[0]
         root = (
             db.query(cls)
             .filter(cls.manual_task_id == manual_task_id, cls.parent_id.is_(None))
@@ -138,7 +83,6 @@ class ManualTaskConditionalDependency(Base):
         if not root:
             return None
 
-        if root.condition_type == "leaf":
+        if root.condition_type == ConditionalDependencyType.leaf:
             return root.to_condition_leaf()
-
         return root.to_condition_group()

fides/api/models/policy.py

@@ -177,6 +177,30 @@ class Policy(Base):
             for category in node.get_data_categories()
         )
 
+    def to_safe_dict(self) -> Dict[str, Any]:
+        """
+        Returns a dictionary representation of the Policy, excluding sensitive information.
+        """
+        return {
+            "id": self.id,
+            "name": self.name,
+            "key": self.key,
+            "drp_action": self.drp_action.value if self.drp_action else None,  # type: ignore[attr-defined]
+            "execution_timeframe": self.execution_timeframe,
+            "client_id": self.client_id,
+            "rules": [
+                {
+                    "id": rule.id,
+                    "name": rule.name,
+                    "key": rule.key,
+                    "action_type": rule.action_type.value,
+                    "masking_strategy": rule.masking_strategy,
+                    "storage_destination_id": rule.storage_destination_id,
+                }
+                for rule in self.rules  # type: ignore[attr-defined]
+            ],
+        }
+
 
 def _get_ref_from_taxonomy(
     fides_key: FidesKey,

fides/api/models/privacy_notice.py

@@ -41,7 +41,7 @@ class UserConsentPreference(Enum):
     tcf = "tcf"  # Overall preference set for TCF where there are numerous preferences under the single notice
 
 
-class ConsentMechanism(Enum):
+class ConsentMechanism(str, Enum):
     """
     Enum is not formalized in the DB because it may be subject to frequent change
     """

fides/api/models/privacy_request/privacy_request.py

@@ -261,6 +261,12 @@ class PrivacyRequest(
         foreign_keys=[reviewed_by],
     )
 
+    submitter = relationship(
+        FidesUser,
+        backref=backref("submitted_privacy_requests", passive_deletes=True),
+        foreign_keys=[submitted_by],
+    )
+
     pre_approval_webhook_replies = relationship(
         PreApprovalWebhookReply,
         back_populates="privacy_request",
@@ -355,6 +361,64 @@ class PrivacyRequest(
 
         return super().create(db=db, data=data, check_name=check_name)
 
+    def to_safe_dict(self) -> Dict[str, Any]:
+        """
+        Return a dict representation of the PrivacyRequest, excluding any fields
+        that may contain sensitive information.
+        """
+        return {
+            "id": self.id,
+            "external_id": self.external_id,
+            "status": self.status.value,
+            "requested_at": (
+                self.requested_at.isoformat() if self.requested_at else None
+            ),
+            "started_processing_at": (
+                self.started_processing_at.isoformat()
+                if self.started_processing_at
+                else None
+            ),
+            "finished_processing_at": (
+                self.finished_processing_at.isoformat()
+                if self.finished_processing_at
+                else None
+            ),
+            "reviewed_at": self.reviewed_at.isoformat() if self.reviewed_at else None,
+            "reviewed_by": self.reviewed_by,
+            "finalized_at": (
+                self.finalized_at.isoformat() if self.finalized_at else None
+            ),
+            "finalized_by": self.finalized_by,
+            "submitted_by": self.submitted_by,
+            "custom_privacy_request_fields_approved_by": (
+                self.custom_privacy_request_fields_approved_by
+            ),
+            "identity_verified_at": (
+                self.identity_verified_at.isoformat()
+                if self.identity_verified_at
+                else None
+            ),
+            "custom_privacy_request_fields_approved_at": (
+                self.custom_privacy_request_fields_approved_at.isoformat()
+                if self.custom_privacy_request_fields_approved_at
+                else None
+            ),
+            "client_id": self.client_id,
+            "origin": self.origin,
+            "policy_id": self.policy_id,
+            "policy": self.policy.to_safe_dict() if self.policy else None,
+            "property_id": self.property_id,
+            "cancel_reason": self.cancel_reason,
+            "canceled_at": self.canceled_at.isoformat() if self.canceled_at else None,
+            "consent_preferences": self.consent_preferences,
+            "source": self.source.value if self.source else None,
+            "paused_at": self.paused_at.isoformat() if self.paused_at else None,
+            "due_date": self.due_date.isoformat() if self.due_date else None,
+            "days_left": self.days_left,
+            "custom_fields": self.get_persisted_custom_privacy_request_fields() if self.custom_fields else None,  # type: ignore[attr-defined]
+            "location": self.location,
+        }
+
     def clear_cached_values(self) -> None:
         """
         Clears all cached values associated with this privacy request from Redis.
@@ -903,6 +967,8 @@ class PrivacyRequest(
             callback_type=CallbackType.pre_approval,
             identity=self.get_cached_identity_data(),
             policy_action=policy_action,
+            privacy_request=self.to_safe_dict(),
+            timestamp=datetime.utcnow(),
         )
         headers = {
             "reply-to-approve": f"/privacy-request/{self.id}/pre-approve/eligible",
@@ -943,6 +1009,8 @@ class PrivacyRequest(
             callback_type=webhook.prefix,
             identity=self.get_cached_identity_data(),
             policy_action=policy_action,
+            privacy_request=self.to_safe_dict(),
+            timestamp=datetime.utcnow(),
         )
 
         headers = {}

fides/api/models/privacy_request/webhook.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import json
 from datetime import datetime
 from enum import Enum as EnumType
-from typing import Optional
+from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, ConfigDict
 
@@ -51,6 +51,8 @@ class SecondPartyRequestFormat(BaseModel):
     identity: Identity
     policy_action: Optional[ActionType] = None
     model_config = ConfigDict(use_enum_values=True)
+    privacy_request: Dict[str, Any]
+    timestamp: datetime
 
 
 def generate_request_callback_resume_jwe(webhook: PolicyPreWebhook) -> str:

fides/api/oauth/roles.py

@@ -26,6 +26,7 @@ from fides.common.api.scope_registry import (
     PRIVACY_EXPERIENCE_READ,
     PRIVACY_NOTICE_READ,
     PRIVACY_REQUEST_CALLBACK_RESUME,
+    PRIVACY_REQUEST_CREATE,
     PRIVACY_REQUEST_DELETE,
     PRIVACY_REQUEST_EMAIL_INTEGRATIONS_SEND,
     PRIVACY_REQUEST_MANUAL_STEPS_RESPOND,
@@ -88,6 +89,7 @@ approver_scopes = [
     PRIVACY_REQUEST_UPLOAD_DATA,
     PRIVACY_REQUEST_VIEW_DATA,
     PRIVACY_REQUEST_DELETE,
+    PRIVACY_REQUEST_CREATE,  # allows approvers to create new privacy requests
     USER_READ,  # allows approver to view user management table and update their own password
     PRIVACY_REQUEST_MANUAL_STEPS_REVIEW,  # allows approvers to see all manual steps
 ]

fides/api/schemas/connection_configuration/connection_oauth_config.py

@@ -0,0 +1,42 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from fides.api.schemas.base_class import NoValidationSchema
+
+
+class OAuthGrantType(str, Enum):
+    """OAuth2 grant types supported by the system"""
+
+    client_credentials = "client_credentials"
+
+
+class OAuthConfigSchema(BaseModel):
+    """Schema for OAuth2 configuration used in API requests"""
+
+    grant_type: Optional[OAuthGrantType] = None
+    token_url: Optional[str] = None
+    scope: Optional[str] = None
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = Field(json_schema_extra={"sensitive": True})
+
+    model_config = ConfigDict(
+        from_attributes=True, use_enum_values=True, extra="forbid"
+    )
+
+
+class OAuthConfigResponse(BaseModel):
+    """Schema for OAuth2 configuration used in API responses with masked sensitive fields"""
+
+    grant_type: OAuthGrantType
+    token_url: str
+    scope: Optional[str] = None
+    client_id: str
+    client_secret: str = "**********"  # Always masked in responses
+
+    model_config = ConfigDict(from_attributes=True, use_enum_values=True)
+
+
+class OAuthConfigDocsSchema(OAuthConfigSchema, NoValidationSchema):
+    """OAuth2 Config Schema for API Docs"""

fides/api/schemas/privacy_request.py

@@ -14,7 +14,7 @@ from fides.api.schemas.base_class import FidesSchema
 from fides.api.schemas.policy import ActionType, CurrentStep
 from fides.api.schemas.policy import PolicyResponse as PolicySchema
 from fides.api.schemas.redis_cache import CustomPrivacyRequestField, Identity
-from fides.api.schemas.user import PrivacyRequestReviewer
+from fides.api.schemas.user import PrivacyRequestUser
 from fides.api.util.collection_util import Row
 from fides.api.util.encryption.aes_gcm_encryption_scheme import verify_encryption_key
 from fides.api.util.enums import ColumnSort
@@ -316,7 +316,9 @@ class PrivacyRequestResponse(FidesSchema):
     started_processing_at: Optional[datetime] = None
     reviewed_at: Optional[datetime] = None
     reviewed_by: Optional[str] = None
-    reviewer: Optional[PrivacyRequestReviewer] = None
+    submitted_by: Optional[str] = None
+    reviewer: Optional[PrivacyRequestUser] = None
+    submitter: Optional[PrivacyRequestUser] = None
     finished_processing_at: Optional[datetime] = None
     identity_verified_at: Optional[datetime] = None
     paused_at: Optional[datetime] = None
@@ -340,6 +342,7 @@ class PrivacyRequestResponse(FidesSchema):
     deleted_by: Optional[str] = None
     finalized_at: Optional[datetime] = None
     finalized_by: Optional[str] = None
+
     model_config = ConfigDict(from_attributes=True, use_enum_values=True)
 
 

fides/api/schemas/user.py

@@ -10,8 +10,8 @@ from fides.api.schemas.base_class import FidesSchema
 from fides.api.schemas.oauth import AccessToken
 
 
-class PrivacyRequestReviewer(FidesSchema):
-    """Data we can expose via the PrivacyRequest.reviewer relation"""
+class PrivacyRequestUser(FidesSchema):
+    """Data we can expose via PrivacyRequest user relations (reviewer, submitter, etc.)"""
 
     id: str
     username: str