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

cs_models/resources/SmartDefGridCellQuestion/models.py

@@ -0,0 +1,76 @@
+import enum
+from datetime import datetime
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, JSON, Boolean, Index, Text, Enum, ForeignKeyConstraint
+from sqlalchemy.orm import relationship
+from ...database import Base
+
+
+class QuestionStatus(str, enum.Enum):
+    pending = "pending"     # created, not enqueued yet
+    queued = "queued"      # sent to your queue
+    running = "running"     # worker picked it up
+    succeeded = "succeeded"   # at least one answer persisted
+    failed = "failed"      # irrecoverable error (manual retry/override)
+    cancelled = "cancelled"  # cancelled
+
+
+class ExpectedType(str, enum.Enum):
+    number = "number"
+    text = "text"
+
+
+class SmartDefGridCellQuestionModel(Base):
+    """
+    One question per cell (you may create new ones on re-ask/revision).
+    """
+    __tablename__ = "smart_def_grid_cell_questions"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)  # question_id (uuid)
+    smart_def_grid_id = Column(Integer, ForeignKey("smart_def_grids.id", ondelete="CASCADE"), nullable=False)
+    run_id = Column(Integer, ForeignKey("smart_def_grid_runs.id", ondelete="SET NULL"), nullable=True)
+    cell_id = Column(String(36), nullable=False)
+
+    question_text = Column(Text, nullable=False)
+    expected_type = Column(Enum(ExpectedType), nullable=False)
+    must_cite = Column(Boolean, nullable=False, default=True)
+
+    topic_key = Column(JSON, nullable=True)
+    retrieval_hints = Column(JSON, nullable=True)
+
+    # Answer
+    answer_text = Column(Text, nullable=True)
+    answer_info = Column(JSON, nullable=True)
+
+    # Queue & lifecycle
+    status = Column(Enum(QuestionStatus), nullable=False, default=QuestionStatus.pending)
+    priority = Column(Integer, nullable=False, default=5)     # lower = higher priority
+    attempts = Column(Integer, nullable=False, default=0)
+    last_error = Column(Text, nullable=True)
+
+    idempotency_key = Column(String(64), nullable=True)       # to avoid dup work
+    dedupe_hash = Column(String(64), nullable=True)           # e.g., hash(table_id, cell_id, question_text)
+
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+    started_at = Column(DateTime, nullable=True)
+    finished_at = Column(DateTime, nullable=True)
+
+    # relationships
+    answers = relationship("SmartDefGridCellAnswerModel", back_populates="question", cascade="all, delete-orphan")
+    run = relationship("SmartDefGridRunModel")
+
+    __table_args__ = (
+        # Useful to grab next jobs: status+priority+created
+        Index("ix_smart_def_grid_cell_questions_queue", "status", "priority", "created_at"),
+        # Quick lookup for this cell's active question(s)
+        Index("ix_smart_def_grid_cell_questions_cell", "smart_def_grid_id", "cell_id"),
+        Index("ix_sdgcq_run_status", "run_id", "status", "priority", "created_at"),
+        Index("ix_sdgcq_run_cell", "run_id", "smart_def_grid_id", "cell_id"),
+        ForeignKeyConstraint(
+            ["smart_def_grid_id", "cell_id"],
+            ["smart_def_grid_cells.smart_def_grid_id", "smart_def_grid_cells.cell_id"],
+            ondelete="CASCADE",
+        ),
+        # strong uniqueness if you want only one ACTIVE per cell; or enforce app-side
+        # UniqueConstraint("table_id", "cell_id", "status", name="uq_cell_question_cell_status"),
+    )

cs_models/resources/SmartDefGridCellQuestion/schemas.py

@@ -0,0 +1,41 @@
+from marshmallow import Schema, fields, validate
+from ..SmartDefGridCellAnswer.schemas import SmartDefGridCellAnswerResourceSchema
+
+
+QUESTION_STATUS = ["pending", "queued", "running", "succeeded", "failed", "cancelled"]
+EXPECTED_TYPE = ["number", "text", "citationList", "json"]
+
+
+class SmartDefGridCellQuestionResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    id = fields.String(dump_only=True)
+    smart_def_grid_id = fields.Integer(required=True)
+    run_id = fields.Integer(allow_none=True)
+    cell_id = fields.String(required=True)
+
+    question_text = fields.String(required=True, validate=not_blank)
+    expected_type = fields.String(required=True, validate=validate.OneOf(EXPECTED_TYPE))
+    must_cite = fields.Boolean(required=True)
+
+    topic_key = fields.Raw(allow_none=True)              # e.g., {"row":[...], "col":[...]}
+    retrieval_hints = fields.Raw(allow_none=True)
+
+    answer_text = fields.String(allow_none=True)
+    answer_info = fields.Raw(allow_none=True)
+
+    status = fields.String(required=True, validate=validate.OneOf(QUESTION_STATUS))
+    priority = fields.Integer(required=True)
+    attempts = fields.Integer(required=True)
+    last_error = fields.String(allow_none=True)
+
+    idempotency_key = fields.String(allow_none=True)
+    dedupe_hash = fields.String(allow_none=True)
+
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+    started_at = fields.DateTime(dump_only=True)
+    finished_at = fields.DateTime(dump_only=True)
+
+    # light nesting of answers on read
+    answers = fields.Nested(SmartDefGridCellAnswerResourceSchema(), many=True, dump_only=True)

cs_models/resources/SmartDefGridCellValue/models.py

@@ -0,0 +1,54 @@
+from datetime import datetime
+from sqlalchemy import Column, DateTime, ForeignKey, Float, String, JSON, Boolean, Integer, Text, ForeignKeyConstraint, and_
+from sqlalchemy.orm import relationship
+from ...database import Base
+from ..SmartDefGridCell.models import SmartDefGridCellModel
+
+
+class SmartDefGridCellValueModel(Base):
+    """
+    The canonical, last-applied value for a cell in the user table (what's rendered back).
+    This is what your UI reads to show the latest state (without opening BlockNote).
+    """
+    __tablename__ = "smart_def_grid_cell_values"
+
+    smart_def_grid_id = Column(Integer, ForeignKey("smart_def_grids.id", ondelete="CASCADE"), primary_key=True)
+    applied_run_id = Column(Integer, ForeignKey("smart_def_grid_runs.id", ondelete="SET NULL"), nullable=True)
+    cell_id = Column(String(36), primary_key=True)
+
+    # applied value derived from a specific answer_id (or manual override)
+    answer_id = Column(Integer, ForeignKey("smart_def_grid_cell_answers.id", ondelete="SET NULL"), nullable=True)
+    raw_value = Column(Float, nullable=True)
+    display_text = Column(Text, nullable=True)
+    citations = Column(JSON, nullable=True)
+    formatting_used = Column(JSON, nullable=True)  # snapshot of FormattingSpec used to render
+
+    # flags
+    manual_override = Column(Boolean, nullable=False, default=False)
+    note = Column(Text, nullable=True)
+
+    applied_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["smart_def_grid_id", "cell_id"],
+            ["smart_def_grid_cells.smart_def_grid_id", "smart_def_grid_cells.cell_id"],
+            ondelete="CASCADE",
+        ),
+    )
+
+    # relationships
+    cell = relationship(
+        "SmartDefGridCellModel",
+        back_populates="applied_value",
+        uselist=False,
+        primaryjoin=lambda: and_(
+            SmartDefGridCellValueModel.smart_def_grid_id == SmartDefGridCellModel.smart_def_grid_id,
+            SmartDefGridCellValueModel.cell_id == SmartDefGridCellModel.cell_id,
+        ),
+        foreign_keys=lambda: [SmartDefGridCellValueModel.smart_def_grid_id, SmartDefGridCellValueModel.cell_id],
+    )
+
+    answer = relationship("SmartDefGridCellAnswerModel", foreign_keys=[answer_id])
+    applied_run = relationship("SmartDefGridRunModel")

cs_models/resources/SmartDefGridCellValue/schemas.py

@@ -0,0 +1,19 @@
+from marshmallow import Schema, fields
+
+
+class SmartDefGridCellValueResourceSchema(Schema):
+    smart_def_grid_id = fields.Integer(required=True)
+    applied_run_id = fields.Integer(allow_none=True)
+    cell_id = fields.String(required=True)
+
+    answer_id = fields.Integer(allow_none=True)
+    raw_value = fields.Float(allow_none=True)
+    display_text = fields.String(allow_none=True)
+    citations = fields.Raw(allow_none=True)
+    formatting_used = fields.Raw(allow_none=True)
+
+    manual_override = fields.Boolean(required=True, default=False)
+    note = fields.String(allow_none=True)
+
+    applied_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/SmartDefGridRun/models.py

@@ -0,0 +1,60 @@
+from enum import Enum
+from datetime import datetime
+from sqlalchemy import Enum as SAEnum
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, JSON, Text, Index
+from sqlalchemy.orm import relationship
+from ...database import Base
+
+
+class SmartDefGridRunStatus(str, Enum):
+    created = "created"
+    dispatched = "dispatched"
+    running = "running"
+    succeeded = "succeeded"
+    failed = "failed"
+    cancelled = "cancelled"
+    partial = "partial"   # finished with some failed cells
+
+
+class SmartDefGridRunScope(str, Enum):
+    all = "all"
+    empty_only = "empty_only"
+
+
+class SmartDefGridRunModel(Base):
+    __tablename__ = "smart_def_grid_runs"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)  # run_id
+    smart_def_grid_id = Column(Integer, ForeignKey("smart_def_grids.id", ondelete="CASCADE"), nullable=False)
+
+    scope_mode = Column(SAEnum(SmartDefGridRunScope), nullable=False, default=SmartDefGridRunScope.all)
+
+    # optional snapshotting to make runs reproducible/debuggable
+    outline_json = Column(JSON, nullable=False)  # new outline created for this run
+    original_table_json = Column(JSON, nullable=False)    # stamped block at run start
+    targets_json = Column(JSON, nullable=True)
+
+    # execution metadata
+    status = Column(
+        SAEnum(
+            SmartDefGridRunStatus,
+            validate_strings=True,  # allow assigning "created" etc. as strings too
+        ),
+        nullable=False,
+        default=SmartDefGridRunStatus.created,
+    )
+
+    started_by_user_id = Column(String(64), nullable=False)
+    notes = Column(Text, nullable=True)
+    # optional idempotency token if you want “re-run latest”
+    client_token = Column(String(128), nullable=True, index=True)
+
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    started_at = Column(DateTime, nullable=True)
+    finished_at = Column(DateTime, nullable=True)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+
+    grid = relationship("SmartDefGridModel", backref="runs")
+    __table_args__ = (
+        Index("ix_sdgr_runs_grid_created", "smart_def_grid_id", "created_at"),
+    )

cs_models/resources/SmartDefGridRun/schemas.py

@@ -0,0 +1,31 @@
+from marshmallow import Schema, fields, validate
+
+
+class SmartDefGridRunResourceSchema(Schema):
+    """
+        The user-defined table artifact (aka 'SmartDefGrid' resource).
+        - id is your table_id (UUID string or int—your choice).
+        - outline_json/original_table_json can be dicts (preferred) or JSON strings if you’d rather store serialized blobs.
+        """
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    id = fields.String(dump_only=True)  # table_id
+    smart_def_grid_id = fields.Integer(allow_none=True)  # if you link to a workbook
+
+    scope_mode = fields.String(required=True)
+
+    # prefer dicts; switch to fields.String if you store JSON-serialized strings
+    outline_json = fields.Raw(required=True)
+    original_table_json = fields.Raw(required=True)
+    targets_json = fields.Raw(allow_none=True)
+
+    status = fields.String(required=True)
+    started_by_user_id = fields.String(required=True)
+
+    notes = fields.String(allow_none=True)
+    client_token = fields.String(allow_none=True)
+
+    created_at = fields.DateTime(dump_only=True)
+    started_at = fields.DateTime(allow_none=True)
+    finished_at = fields.DateTime(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/SmartGrid/models.py

@@ -0,0 +1,34 @@
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, Boolean, ForeignKey, Integer, Text, String
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+from ..SmartGridCell.models import SmartGridCellModel
+
+
+class SmartGridModel(Base):
+    __tablename__ = "smart_grids"
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(String(128), nullable=False)
+    workbook_id = Column(
+        Integer,
+        ForeignKey('workbooks.id'),
+        nullable=True,
+    )
+    table_info = Column(Text, nullable=True)
+    is_deleted = Column(Boolean, 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(),
+    )
+
+    cells = relationship(
+        "SmartGridCellModel",
+        order_by=SmartGridCellModel.row,
+        back_populates="smart_grid",
+    )

cs_models/resources/SmartGrid/schemas.py

@@ -0,0 +1,18 @@
+from marshmallow import Schema, fields, validate
+from ..SmartGridCell.schemas import SmartGridCellResourceSchema
+
+
+class SmartGridResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    id = fields.Integer(dump_only=True)
+    user_id = fields.String(required=True, validate=not_blank)
+    workbook_id = fields.Integer(allow_none=True)
+    table_info = fields.String(allow_none=True)
+    is_deleted = fields.Boolean(allow_none=True)
+    cells = fields.Nested(
+        SmartGridCellResourceSchema(exclude=("smart_grid_id",)),
+        many=True,
+        dump_only=True,
+    )
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/SmartGridCell/models.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, Boolean, ForeignKey, Integer, Text, String
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+
+
+class SmartGridCellModel(Base):
+    __tablename__ = "smart_grid_cells"
+
+    id = Column(Integer, primary_key=True)
+    smart_grid_id = Column(
+        Integer,
+        ForeignKey("smart_grids.id"),
+        nullable=False,
+    )
+    row = Column(Integer, nullable=False)
+    col = Column(Integer, nullable=False)
+    type = Column(String(20), nullable=False)
+    data = Column(Text, nullable=True)
+    user_query_id = Column(
+        Integer,
+        ForeignKey("assistant_user_queries.id"),
+        nullable=True,
+    )
+    reformulated_question = Column(String(Text), nullable=False)
+    is_deleted = Column(Boolean, 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(),
+    )
+
+    user_query = relationship(
+        "AssistantUserQueryModel",
+    )
+
+    smart_grid = relationship(
+        "SmartGridModel",
+        back_populates="cells",
+    )

cs_models/resources/SmartGridCell/schemas.py

@@ -0,0 +1,22 @@
+"""Marshmallow Schema for AssistantCommand."""
+from marshmallow import Schema, fields
+from ..AssistantUserQuery.schemas import AssistantUserQueryResourceSchema
+
+
+class SmartGridCellResourceSchema(Schema):
+    """Class for AssistantCommandResource schema"""
+
+    id = fields.Integer(dump_only=True)
+    smart_grid_id = fields.Integer(required=True)
+    row = fields.Integer(required=True)
+    col = fields.Integer(required=True)
+    type = fields.String(required=True)
+    data = fields.String(allow_none=True)
+    user_query_id = fields.Integer(allow_none=True)
+    user_query = fields.Nested(
+        AssistantUserQueryResourceSchema(),
+        dump_only=True,
+    )
+    reformulated_question = fields.String(allow_none=True)
+    is_deleted = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/Submission13F/models.py

@@ -0,0 +1,12 @@
+from sqlalchemy import Column, Integer, String, Date
+from ...database import Base
+
+
+class Submission13FModel(Base):
+    __tablename__ = '13fsubmission'
+
+    ACCESSION_NUMBER = Column(String(25), primary_key=True)
+    FILING_DATE = Column(Date, nullable=False)
+    SUBMISSIONTYPE = Column(String(10), nullable=False)
+    CIK = Column(String(10), nullable=False)
+    PERIODOFREPORT = Column(Date, nullable=False)

cs_models/resources/Submission13F/schemas.py

@@ -0,0 +1,10 @@
+from marshmallow import Schema, fields
+from ...utils.utils import Safe13FDate
+
+
+class Submission13FSchema(Schema):
+    ACCESSION_NUMBER = fields.String(required=True)
+    FILING_DATE = Safe13FDate(required=True)
+    SUBMISSIONTYPE = fields.String(required=True)
+    CIK = fields.String(required=True)
+    PERIODOFREPORT = Safe13FDate(required=True)

cs_models/resources/SummaryPage13F/models.py

@@ -0,0 +1,12 @@
+from sqlalchemy import Column, Integer, String, Date
+from ...database import Base
+
+
+class Summarypage13FModel(Base):
+    __tablename__ = '13fsummarypage'
+
+    ACCESSION_NUMBER = Column(String(25), primary_key=True)
+    OTHERINCLUDEDMANAGERSCOUNT = Column(Integer)
+    TABLEENTRYTOTAL = Column(Integer)
+    TABLEVALUETOTAL = Column(Integer)
+    ISCONFIDENTIALOMITTED = Column(String(1))

cs_models/resources/SummaryPage13F/schemas.py

@@ -0,0 +1,9 @@
+from marshmallow import Schema, fields
+
+
+class Summarypage13FSchema(Schema):
+    ACCESSION_NUMBER = fields.String(required=True)
+    OTHERINCLUDEDMANAGERSCOUNT = fields.Integer()
+    TABLEENTRYTOTAL = fields.Integer()
+    TABLEVALUETOTAL = fields.Integer()
+    ISCONFIDENTIALOMITTED = fields.String()

cs_models/resources/TableFigure/models.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    String,
+    Text,
+    Boolean,
+    ForeignKey,
+)
+
+from ...database import Base
+
+
+class TableFigureModel(Base):
+    __tablename__ = "table_figures"
+
+    id = Column(Integer, primary_key=True)
+    file_id = Column(
+        Integer,
+        ForeignKey('files.id'),
+        nullable=True,
+    )
+    source_type = Column(String(50), nullable=False)
+    source_id = Column(Integer, nullable=False)
+    type = Column(String(50), nullable=False)
+    label = Column(String(50), nullable=True)
+    caption = Column(Text, nullable=True)
+    description = Column(Text, nullable=True)
+    content = Column(Text, nullable=True)
+    link = Column(String(255), nullable=True)
+    llm_processed = Column(Boolean, 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/TableFigure/schemas.py

@@ -0,0 +1,61 @@
+import json
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class TableFigureCaptionField(fields.Field):
+    """Field that stores result for the Assistant command."""
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        """
+        In the DB, the `result` field is a text field. We persist
+        data by performing the following:
+
+        AssistantCommandModel(
+            ...
+            result=json.dumps({...}),
+        )
+
+        So here we need to perform the inverse operation (i.e `json.loads(..)`)
+        """
+        if value is None:
+            return None
+        return json.loads(value)
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        """
+        In the DB, the `result` field is a text field. We persist
+        data by performing the following:
+
+
+
+        AssistantCommandModel(
+            ***AssistantCommandResourceSchema().load({
+                ...
+                "result": [{"some_key": 1}, {"some_key": 2}],
+            }),
+        )
+        """
+        if value is None:
+            return None
+        return json.dumps(value)
+
+
+class TableFigureResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    file_id = fields.Integer(required=True)
+    source_type = fields.String(required=True)
+    source_id = fields.Integer(required=True)
+    type = fields.String(required=True)
+    label = fields.String(allow_none=True)
+    caption = TableFigureCaptionField(required=True, allow_none=True)
+    description = fields.String(allow_none=True)
+    content = fields.String(allow_none=True)
+    link = fields.String(allow_none=True)
+    llm_processed = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/TableOutbox/models.py

@@ -3,6 +3,8 @@ from datetime import datetime
 from sqlalchemy import (
     Column,
     Integer,
+    Float,
+    Boolean,
     DateTime,
     Text,
 )
@@ -18,6 +20,8 @@ class TableOutboxModel(Base):
     table_html = Column(Text, nullable=False)
     table_number = Column(Integer, nullable=False)
     table_preceding_info = Column(Text, nullable=False)
+    score = Column(Float, nullable=True)
+    processed = Column(Boolean, nullable=True)
     updated_at = Column(
         DateTime,
         nullable=False,

cs_models/resources/TableOutbox/schemas.py

@@ -13,4 +13,6 @@ class TableOutboxResourceSchema(Schema):
     table_number = fields.Integer(required=True)
     table_html = fields.String(required=True)
     table_preceding_info = fields.String(required=True)
+    score = fields.Float(allow_none=True)
+    processed = fields.Boolean(allow_none=True)
     updated_at = fields.DateTime()

cs_models/resources/TargetSyn/models.py

@@ -2,6 +2,7 @@ from sqlalchemy import (
     Column,
     Integer,
     String,
+    Boolean,
     DateTime,
     ForeignKey,
 )
@@ -20,6 +21,9 @@ class TargetSynModel(Base):
         ForeignKey('targets.id'),
         nullable=True,
     )
+    source = Column(String(50), nullable=True)
+    obsolete = Column(Boolean, nullable=True)
+    synonym_type = Column(String(50), nullable=True)
     updated_at = Column(
         DateTime,
         nullable=False,

cs_models/resources/TargetSyn/schemas.py

@@ -11,4 +11,7 @@ class TargetSynResourceSchema(Schema):
     id = fields.Integer(dump_only=True)
     synonym = fields.String(required=True)
     target_id = fields.Integer(required=True)
+    source = fields.String(allow_none=True)
+    obsolete = fields.Boolean(allow_none=True)
+    synonym_type = fields.String(allow_none=True)
     updated_at = fields.DateTime()

cs_models/resources/Transcript/models.py

@@ -0,0 +1,31 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Boolean,
+    Text,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class TranscriptModel(Base):
+    __tablename__ = 'transcripts'
+
+    id = Column(Integer, primary_key=True)
+    event_id = Column(Integer, nullable=False, index=True)
+    date = Column(DateTime, nullable=False)
+    title = Column(String(191), nullable=False)
+    event_type = Column(String(50), nullable=True)
+    event_tags = Column(Text, nullable=True)
+    human_verified = Column(Boolean, nullable=True)
+    transcription_status = Column(String(50), nullable=True)
+    audio_url = Column(String(191), nullable=True)
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+    )