cs-models 0.0.827__py3-none-any.whl → 0.0.847__py3-none-any.whl

cs_models/resources/DeepResearchSubTask/models.py

@@ -0,0 +1,177 @@
+"""Models for Deep Research SubTasks - Individual research agents."""
+import enum
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Integer,
+    String,
+    Text,
+    Boolean,
+    ForeignKey,
+    Enum,
+    Float,
+)
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+
+
+class SubTaskStatusEnum(enum.Enum):
+    """Status enum for deep research subtasks."""
+    PENDING = "PENDING"
+    QUEUED = "QUEUED"
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    SKIPPED = "SKIPPED"
+    EXPANDED = "EXPANDED"  # Template task that has been expanded into child tasks
+
+
+class SubTaskTypeEnum(enum.Enum):
+    """Type enum for research dimensions and special task types."""
+    # Research dimensions
+    CUSTOM = "CUSTOM"
+    INVESTIGATION = "INVESTIGATION"
+    DISCOVERY = "DISCOVERY"  # Entity discovery tasks
+    SMART_GRID = "SMART_GRID"  # SmartGrid matrix research (items × dimensions)
+    AGGREGATION = "AGGREGATION"  # Aggregation of other task results
+
+
+class DeepResearchSubTaskModel(Base):
+    """
+    Model for Deep Research SubTasks.
+
+    Each subtask represents an independent research agent that executes
+    with a fresh context window. Subtasks do not communicate with each
+    other - all coordination flows through the main orchestrator.
+    """
+
+    __tablename__ = "deep_research_subtasks"
+
+    id = Column(Integer, primary_key=True)
+
+    # Parent session
+    session_id = Column(
+        Integer,
+        ForeignKey("deep_research_sessions.id"),
+        nullable=False,
+    )
+
+    # V2: Parent agentic unit (nullable for backward compatibility with v1)
+    agentic_unit_id = Column(
+        Integer,
+        ForeignKey("deep_research_agentic_units.id"),
+        nullable=True,
+    )
+
+    # Task identification
+    task_id = Column(String(100), nullable=True)  # Logical task ID (e.g., "t1", "t2_ide-cel")
+    sequence_number = Column(Integer, nullable=False, default=0)
+    task_type = Column(
+        "task_type",
+        Enum(SubTaskTypeEnum),
+        default=SubTaskTypeEnum.CUSTOM,
+        nullable=False,
+    )
+    task_label = Column(String(256), nullable=True)
+
+    # Template/Expansion tracking
+    is_template = Column(Boolean, nullable=True, default=False)  # True if this is a template task
+    parent_task_id = Column(
+        Integer,
+        ForeignKey("deep_research_subtasks.id"),
+        nullable=True,
+    )  # Links expanded tasks to their parent template
+
+    # Task specification (JSON)
+    specification = Column(Text, nullable=False)  # JSON with focus_question, entities, etc.
+    focus_question = Column(Text, nullable=True)  # Denormalized for quick access
+    entities = Column(Text, nullable=True)  # JSON array of entity objects
+    search_scope = Column(Text, nullable=True)  # JSON array: ["PUBLICATION", "CLINICAL_TRIAL"]
+    expected_output_format = Column(String(50), nullable=True)  # structured, narrative, table_row
+    time_range_start = Column(DateTime, nullable=True)
+    time_range_end = Column(DateTime, nullable=True)
+
+    # Entity discovery (for DISCOVERY tasks and for_each_entity_from pattern)
+    output_entities = Column(Boolean, nullable=True, default=False)  # True if this task outputs entities
+    entity_type = Column(String(50), nullable=True)  # Type of entities discovered (e.g., "drug", "event")
+    for_each_entity_from = Column(String(100), nullable=True)  # task_id of parent task to get entities from
+    entity_name = Column(String(256), nullable=True)  # Entity name this expanded task was created for
+    entity_data = Column(Text, nullable=True)  # JSON: Full entity info including synonyms
+    discovered_entities = Column(Text, nullable=True)  # JSON: Entities discovered by this task
+
+    # Execution status
+    status = Column(
+        "status",
+        Enum(SubTaskStatusEnum),
+        default=SubTaskStatusEnum.PENDING,
+        nullable=False,
+    )
+    lambda_request_id = Column(String(256), nullable=True)
+    started_at = Column(DateTime, nullable=True)
+    completed_at = Column(DateTime, nullable=True)
+
+    # Dependencies (for sequential tasks)
+    depends_on = Column(Text, nullable=True)  # JSON array of subtask IDs
+    priority = Column(Integer, nullable=True, default=1)
+
+    # Results
+    result_s3_key = Column(String(512), nullable=True)
+    result_summary = Column(Text, nullable=True)  # Brief summary of findings
+    citations_count = Column(Integer, nullable=True, default=0)
+    documents_analyzed = Column(Integer, nullable=True, default=0)
+
+    # SmartGrid integration (for SMART_GRID task type)
+    smart_grid_id = Column(Integer, nullable=True)  # FK to SmartGridModel (not enforced)
+    smart_grid_analysis_type = Column(String(50), nullable=True)  # "row", "column", or "both"
+
+    # Quality metrics
+    confidence_score = Column(Float, nullable=True)  # 0.0 - 1.0
+    relevance_score = Column(Float, nullable=True)  # 0.0 - 1.0
+    coverage_score = Column(Float, nullable=True)  # How well the question was answered
+
+    # Execution metrics
+    execution_time_ms = Column(Integer, nullable=True)
+    tokens_used = Column(Integer, nullable=True)
+    search_queries_count = Column(Integer, nullable=True)
+
+    # Error handling
+    error_message = Column(Text, nullable=True)
+    error_type = Column(String(100), nullable=True)
+    retry_count = Column(Integer, nullable=True, default=0)
+
+    # Soft delete and timestamps
+    is_deleted = Column(Boolean, nullable=True)
+    created_at = Column(
+        DateTime,
+        nullable=False,
+        default=lambda: datetime.utcnow(),
+    )
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+    )
+
+    # ORM Relationships
+    session = relationship(
+        "DeepResearchSessionModel",
+        back_populates="subtasks",
+    )
+
+    # Self-referential relationship for template → expanded tasks
+    parent_task = relationship(
+        "DeepResearchSubTaskModel",
+        remote_side=[id],
+        backref="expanded_tasks",
+        foreign_keys=[parent_task_id],
+    )
+
+    # V2: Relationship to parent agentic unit
+    agentic_unit = relationship(
+        "DeepResearchAgenticUnitModel",
+        back_populates="internal_tasks",
+    )

cs_models/resources/DeepResearchSubTask/schemas.py

@@ -0,0 +1,105 @@
+"""Schemas for Deep Research SubTasks."""
+from marshmallow import Schema, fields, validate
+
+from .models import SubTaskStatusEnum, SubTaskTypeEnum
+
+
+class DeepResearchSubTaskResourceSchema(Schema):
+    """Schema for DeepResearchSubTaskModel."""
+
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    id = fields.Integer(dump_only=True)
+    session_id = fields.Integer(required=True)
+
+    # Task identification
+    task_id = fields.String(allow_none=True)  # Logical task ID (e.g., "t1", "t2_ide-cel")
+    sequence_number = fields.Integer(required=True)
+    task_type = fields.Enum(SubTaskTypeEnum, by_value=True)
+    task_label = fields.String(allow_none=True)
+
+    # Template/Expansion tracking
+    is_template = fields.Boolean(allow_none=True)
+    parent_task_id = fields.Integer(allow_none=True)
+
+    # Task specification
+    specification = fields.String(required=True)
+    focus_question = fields.String(allow_none=True)
+    entities = fields.String(allow_none=True)
+    search_scope = fields.String(allow_none=True)
+    expected_output_format = fields.String(allow_none=True)
+    time_range_start = fields.DateTime(allow_none=True)
+    time_range_end = fields.DateTime(allow_none=True)
+
+    # Entity discovery fields
+    output_entities = fields.Boolean(allow_none=True)
+    entity_type = fields.String(allow_none=True)
+    for_each_entity_from = fields.String(allow_none=True)
+    entity_name = fields.String(allow_none=True)
+    entity_data = fields.String(allow_none=True)
+    discovered_entities = fields.String(allow_none=True)
+
+    # Execution status
+    status = fields.Enum(SubTaskStatusEnum, by_value=True)
+    lambda_request_id = fields.String(allow_none=True)
+    started_at = fields.DateTime(allow_none=True)
+    completed_at = fields.DateTime(allow_none=True)
+
+    # Dependencies
+    depends_on = fields.String(allow_none=True)
+    priority = fields.Integer(allow_none=True)
+
+    # Results
+    result_s3_key = fields.String(allow_none=True)
+    result_summary = fields.String(allow_none=True)
+    citations_count = fields.Integer(allow_none=True)
+    documents_analyzed = fields.Integer(allow_none=True)
+
+    # Smart Grid
+    smart_grid_id = fields.Integer(allow_none=True)
+    smart_grid_analysis_type = fields.String(allow_none=True)
+
+    # Quality metrics
+    confidence_score = fields.Float(allow_none=True)
+    relevance_score = fields.Float(allow_none=True)
+    coverage_score = fields.Float(allow_none=True)
+
+    # Execution metrics
+    execution_time_ms = fields.Integer(allow_none=True)
+    tokens_used = fields.Integer(allow_none=True)
+    search_queries_count = fields.Integer(allow_none=True)
+
+    # Error handling
+    error_message = fields.String(allow_none=True)
+    error_type = fields.String(allow_none=True)
+    retry_count = fields.Integer(allow_none=True)
+
+    # Timestamps
+    is_deleted = fields.Boolean(allow_none=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+
+
+class DeepResearchSubTaskSpecSchema(Schema):
+    """Schema for subtask specification object."""
+
+    focus_question = fields.String(required=True)
+    entities = fields.List(fields.Dict(), allow_none=True)
+    search_scope = fields.List(fields.String(), allow_none=True)
+    output_format = fields.String(allow_none=True)
+    expected_fields = fields.List(fields.String(), allow_none=True)
+    max_documents = fields.Integer(allow_none=True)
+    time_range = fields.List(fields.String(), allow_none=True)
+    retrieval_hints = fields.Dict(allow_none=True)
+
+
+class DeepResearchSubTaskCreateSchema(Schema):
+    """Schema for creating a subtask."""
+
+    session_id = fields.Integer(required=True)
+    sequence_number = fields.Integer(required=True)
+    task_type = fields.Enum(SubTaskTypeEnum, by_value=True, required=True)
+    task_label = fields.String(allow_none=True)
+    specification = fields.Nested(DeepResearchSubTaskSpecSchema, required=True)
+    depends_on = fields.List(fields.Integer(), allow_none=True)
+    priority = fields.Integer(allow_none=True)

cs_models/resources/MeetingUserDocument/models.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Text,
+    Integer,
+    String,
+    Boolean,
+    DateTime,
+    ForeignKey,
+)
+
+from ...database import Base
+
+
+class MeetingUserDocumentModel(Base):
+    __tablename__ = "meeting_user_documents"
+
+    id = Column(Integer, primary_key=True)
+    meeting_id = Column(
+        Integer,
+        ForeignKey('meetings.id'),
+        nullable=False,
+    )
+    user_document_id = Column(
+        Integer,
+        ForeignKey('user_documents.id'),
+        nullable=False,
+    )
+    status = Column(String(50), nullable=False)
+    is_active = Column(Boolean, nullable=True)
+    details = Column(Text, nullable=True)
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        # https://stackoverflow.com/questions/58776476/why-doesnt-freezegun-work-with-sqlalchemy-default-values
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+    )

cs_models/resources/MeetingUserDocument/schemas.py

@@ -0,0 +1,17 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class MeetingUserDocumentResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    meeting_id = fields.Integer(required=True)
+    user_document_id = fields.Integer(required=True)
+    status = fields.String(required=True)
+    is_active = fields.Boolean(allow_none=True)
+    details = fields.String(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/PipelineCrawlSession/models.py

@@ -0,0 +1,67 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Float,
+    Text,
+    ForeignKey,
+    Enum,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class PipelineCrawlSessionModel(Base):
+    __tablename__ = 'pipeline_crawl_sessions'
+
+    id = Column(Integer, primary_key=True)
+    company_sec_id = Column(
+        Integer,
+        ForeignKey('companies_sec.id'),
+        nullable=True,
+        index=True,
+    )
+    company_ous_id = Column(
+        Integer,
+        ForeignKey('companies_ous.id'),
+        nullable=True,
+        index=True,
+    )
+
+    # Session tracking
+    session_uuid = Column(String(36), nullable=False, unique=True, index=True)
+    crawl_date = Column(DateTime, nullable=False, default=datetime.utcnow, index=True)
+
+    # Timing metrics
+    crawl_duration_seconds = Column(Float, nullable=True)
+    page_discovery_time_seconds = Column(Float, nullable=True)
+    extraction_time_seconds = Column(Float, nullable=True)
+
+    # Status tracking (MySQL ENUM)
+    status = Column(
+        Enum('started', 'discovering_pages', 'extracting_data', 'completed', 'failed', 'timeout'),
+        nullable=False,
+        default='started',
+        index=True,
+    )
+    error_message = Column(Text, nullable=True)
+
+    # Crawl statistics
+    total_pages_discovered = Column(Integer, nullable=True, default=0)
+    total_pages_crawled = Column(Integer, nullable=True, default=0)
+    total_screenshots_captured = Column(Integer, nullable=True, default=0)
+    total_drugs_extracted = Column(Integer, nullable=True, default=0)
+
+    # Crawl configuration
+    crawl_method = Column(String(50), nullable=True)
+    max_depth = Column(Integer, nullable=True, default=2)
+
+    created_at = Column(DateTime, nullable=False, default=datetime.utcnow)
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+    )

cs_models/resources/PipelineCrawlSession/schemas.py

@@ -0,0 +1,22 @@
+from marshmallow import Schema, fields
+
+
+class PipelineCrawlSessionSchema(Schema):
+    id = fields.Int(dump_only=True)
+    company_sec_id = fields.Int(allow_none=True)
+    company_ous_id = fields.Int(allow_none=True)
+    session_uuid = fields.Str(required=True)
+    crawl_date = fields.DateTime(required=True)
+    crawl_duration_seconds = fields.Float(allow_none=True)
+    page_discovery_time_seconds = fields.Float(allow_none=True)
+    extraction_time_seconds = fields.Float(allow_none=True)
+    status = fields.Str(required=True)
+    error_message = fields.Str(allow_none=True)
+    total_pages_discovered = fields.Int(allow_none=True)
+    total_pages_crawled = fields.Int(allow_none=True)
+    total_screenshots_captured = fields.Int(allow_none=True)
+    total_drugs_extracted = fields.Int(allow_none=True)
+    crawl_method = fields.Str(allow_none=True)
+    max_depth = fields.Int(allow_none=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/PipelineCrawledPage/models.py

@@ -0,0 +1,80 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Float,
+    Boolean,
+    ForeignKey,
+    Enum,
+    Index,
+    UniqueConstraint,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class PipelineCrawledPageModel(Base):
+    __tablename__ = 'pipeline_crawled_pages'
+
+    id = Column(Integer, primary_key=True)
+    session_id = Column(
+        Integer,
+        ForeignKey('pipeline_crawl_sessions.id'),
+        nullable=False,
+        index=True,
+    )
+
+    # URL information
+    url = Column(String(1024), nullable=False)
+    url_hash = Column(String(64), nullable=False, index=True)
+    page_title = Column(String(512), nullable=True)
+
+    # Page content storage (S3)
+    html_content_s3_key = Column(String(512), nullable=True)
+    html_content_hash = Column(String(64), nullable=True)
+    html_content_length = Column(Integer, nullable=True)
+
+    # Screenshot storage (S3)
+    screenshot_s3_key = Column(String(512), nullable=True)
+    screenshot_hash = Column(String(64), nullable=True)
+    screenshot_width = Column(Integer, nullable=True)
+    screenshot_height = Column(Integer, nullable=True)
+    screenshot_file_size = Column(Integer, nullable=True)
+
+    # Page classification (MySQL ENUM)
+    page_type = Column(
+        Enum('pipeline', 'science', 'rd', 'products', 'clinical_trials', 'other'),
+        nullable=True,
+    )
+    relevance_score = Column(Float, nullable=True)
+
+    # Extraction metadata
+    has_drug_data = Column(Boolean, nullable=True, default=False)
+    extraction_method = Column(String(50), nullable=True)
+
+    # Crawl metadata
+    crawl_depth = Column(Integer, nullable=True, default=0)
+    parent_page_id = Column(Integer, ForeignKey('pipeline_crawled_pages.id'), nullable=True)
+    discovered_from_url = Column(String(1024), nullable=True)
+
+    # Technical metadata
+    http_status_code = Column(Integer, nullable=True)
+    content_type = Column(String(128), nullable=True)
+    response_time_ms = Column(Integer, nullable=True)
+
+    # Timestamps
+    crawled_at = Column(DateTime, nullable=False, default=datetime.utcnow)
+    created_at = Column(DateTime, nullable=False, default=datetime.utcnow)
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+    )
+
+    __table_args__ = (
+        Index('idx_session_url_hash', 'session_id', 'url_hash'),
+        UniqueConstraint('session_id', 'url_hash', name='uq_session_url'),
+    )

cs_models/resources/PipelineCrawledPage/schemas.py

@@ -0,0 +1,34 @@
+from marshmallow import Schema, fields
+
+
+class PipelineCrawledPageSchema(Schema):
+    id = fields.Int(dump_only=True)
+    session_id = fields.Int(required=True)
+    url = fields.Str(required=True)
+    url_hash = fields.Str(required=True)
+    page_title = fields.Str(allow_none=True)
+    html_content_s3_key = fields.Str(allow_none=True)
+    html_content_hash = fields.Str(allow_none=True)
+    html_content_length = fields.Int(allow_none=True)
+    screenshot_s3_key = fields.Str(allow_none=True)
+    screenshot_hash = fields.Str(allow_none=True)
+    screenshot_width = fields.Int(allow_none=True)
+    screenshot_height = fields.Int(allow_none=True)
+    screenshot_file_size = fields.Int(allow_none=True)
+    page_type = fields.Str(allow_none=True)
+    relevance_score = fields.Float(allow_none=True)
+    has_drug_data = fields.Bool(allow_none=True)
+    extraction_method = fields.Str(allow_none=True)
+    crawl_depth = fields.Int(allow_none=True)
+    parent_page_id = fields.Int(allow_none=True)
+    discovered_from_url = fields.Str(allow_none=True)
+    http_status_code = fields.Int(allow_none=True)
+    content_type = fields.Str(allow_none=True)
+    response_time_ms = fields.Int(allow_none=True)
+    crawled_at = fields.DateTime(required=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+
+
+class PipelineCrawledPageResourceSchema(PipelineCrawledPageSchema):
+    pass

cs_models/resources/PipelineDrugPortfolio/models.py

@@ -0,0 +1,92 @@
+from sqlalchemy import (
+    Column,
+    BIGINT,
+    Integer,
+    String,
+    DateTime,
+    Float,
+    Text,
+    Boolean,
+    ForeignKey,
+    Enum,
+    Index,
+    JSON,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class PipelineDrugPortfolioModel(Base):
+    __tablename__ = 'pipeline_drug_portfolio'
+
+    id = Column(BIGINT, primary_key=True)
+    session_id = Column(
+        Integer,
+        ForeignKey('pipeline_crawl_sessions.id'),
+        nullable=False,
+        index=True,
+    )
+    page_id = Column(
+        Integer,
+        ForeignKey('pipeline_crawled_pages.id'),
+        nullable=False,
+        index=True,
+    )
+
+    company_sec_id = Column(
+        Integer,
+        ForeignKey('companies_sec.id'),
+        nullable=True,
+        index=True,
+    )
+    company_ous_id = Column(
+        Integer,
+        ForeignKey('companies_ous.id'),
+        nullable=True,
+        index=True,
+    )
+
+    # Core drug information
+    drug_name = Column(String(512), nullable=False, index=True)
+    drug_name_normalized = Column(String(512), nullable=True, index=True)
+    synonyms = Column(JSON, nullable=True)
+
+    modality = Column(String(256), nullable=True)
+    targets = Column(JSON, nullable=True)
+    mechanism_of_action = Column(Text, nullable=True)
+
+    # Indications (JSON)
+    indications = Column(JSON, nullable=False)
+
+    # Additional information (JSON)
+    additional_info = Column(JSON, nullable=True)
+
+    # Extraction metadata (MySQL ENUM)
+    extraction_method = Column(
+        Enum('html_parsing', 'vision_model', 'hybrid', 'manual'),
+        nullable=False,
+    )
+    extraction_confidence = Column(Float, nullable=True)
+    raw_extraction_text = Column(Text, nullable=True)
+
+    # Data quality flags
+    is_verified = Column(Boolean, nullable=True, default=False)
+    is_duplicate = Column(Boolean, nullable=True, default=False, index=True)
+    needs_review = Column(Boolean, nullable=True, default=False, index=True)
+    review_notes = Column(Text, nullable=True)
+
+    # Timestamps
+    extracted_at = Column(DateTime, nullable=False, default=datetime.utcnow)
+    created_at = Column(DateTime, nullable=False, default=datetime.utcnow)
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+    )
+
+    __table_args__ = (
+        Index('idx_company_drug_name', 'company_sec_id', 'drug_name_normalized'),
+        Index('idx_session_drug', 'session_id', 'drug_name_normalized'),
+    )

cs_models/resources/PipelineDrugPortfolio/schemas.py

@@ -0,0 +1,31 @@
+from marshmallow import Schema, fields
+
+
+class PipelineDrugPortfolioSchema(Schema):
+    id = fields.Int(dump_only=True)
+    session_id = fields.Int(required=True)
+    page_id = fields.Int(required=True)
+    company_sec_id = fields.Int(allow_none=True)
+    company_ous_id = fields.Int(allow_none=True)
+    drug_name = fields.Str(required=True)
+    drug_name_normalized = fields.Str(allow_none=True)
+    synonyms = fields.Raw(allow_none=True)  # JSON array
+    modality = fields.Str(allow_none=True)
+    targets = fields.Raw(allow_none=True)  # JSON array
+    mechanism_of_action = fields.Str(allow_none=True)
+    indications = fields.Raw(required=True)  # JSON array
+    additional_info = fields.Raw(allow_none=True)  # JSON object
+    extraction_method = fields.Str(required=True)
+    extraction_confidence = fields.Float(allow_none=True)
+    raw_extraction_text = fields.Str(allow_none=True)
+    is_verified = fields.Bool(allow_none=True)
+    is_duplicate = fields.Bool(allow_none=True)
+    needs_review = fields.Bool(allow_none=True)
+    review_notes = fields.Str(allow_none=True)
+    extracted_at = fields.DateTime(required=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+
+
+class PipelineDrugPortfolioResourceSchema(PipelineDrugPortfolioSchema):
+    pass