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

cs_models/resources/PipelineExtractionLog/models.py

@@ -0,0 +1,55 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Text,
+    ForeignKey,
+    Enum,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class PipelineExtractionLogModel(Base):
+    __tablename__ = 'pipeline_extraction_logs'
+
+    id = Column(Integer, 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=True,
+    )
+
+    # Log details (MySQL ENUM)
+    log_level = Column(
+        Enum('debug', 'info', 'warning', 'error'),
+        nullable=False,
+        default='info',
+        index=True,
+    )
+    message = Column(Text, nullable=False)
+
+    # Context
+    extraction_method = Column(String(50), nullable=True)
+    model_name = Column(String(128), nullable=True)
+    tokens_used = Column(Integer, nullable=True)
+    api_latency_ms = Column(Integer, nullable=True)
+
+    # Error tracking
+    exception_type = Column(String(256), nullable=True)
+    exception_message = Column(Text, nullable=True)
+    stack_trace = Column(Text, nullable=True)
+
+    # Retry tracking
+    attempt_number = Column(Integer, nullable=True, default=1)
+    max_attempts = Column(Integer, nullable=True, default=3)
+
+    created_at = Column(DateTime, nullable=False, default=datetime.utcnow, index=True)

cs_models/resources/PipelineExtractionLog/schemas.py

@@ -0,0 +1,23 @@
+from marshmallow import Schema, fields
+
+
+class PipelineExtractionLogSchema(Schema):
+    id = fields.Int(dump_only=True)
+    session_id = fields.Int(required=True)
+    page_id = fields.Int(allow_none=True)
+    log_level = fields.Str(required=True)
+    message = fields.Str(required=True)
+    extraction_method = fields.Str(allow_none=True)
+    model_name = fields.Str(allow_none=True)
+    tokens_used = fields.Int(allow_none=True)
+    api_latency_ms = fields.Int(allow_none=True)
+    exception_type = fields.Str(allow_none=True)
+    exception_message = fields.Str(allow_none=True)
+    stack_trace = fields.Str(allow_none=True)
+    attempt_number = fields.Int(allow_none=True)
+    max_attempts = fields.Int(allow_none=True)
+    created_at = fields.DateTime(dump_only=True)
+
+
+class PipelineExtractionLogResourceSchema(PipelineExtractionLogSchema):
+    pass

cs_models/resources/PubmedMeetingSellSideSignal/models.py

@@ -0,0 +1,64 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    Float,
+    DateTime,
+    ForeignKey,
+    UniqueConstraint,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class PubmedMeetingSellSideSignalModel(Base):
+    __tablename__ = "pubmed_meeting_sell_side_signals"
+
+    id = Column(Integer, primary_key=True)
+
+    pubmed_id = Column(
+        Integer,
+        ForeignKey("pubmed.id"),
+        nullable=False,
+        index=True,
+    )
+    meeting_id = Column(
+        Integer,
+        ForeignKey("meetings.id"),
+        nullable=False,
+        index=True,
+    )
+    sell_side_source_id = Column(
+        Integer,
+        ForeignKey("sell_side_sources.id"),
+        nullable=False,
+        index=True,
+    )
+
+    # intensity
+    doc_count = Column(Integer, nullable=False)      # distinct notes
+    mention_count = Column(Integer, nullable=False)  # total mentions across those notes
+
+    # sentiment summary
+    avg_sentiment = Column(Float, nullable=True)
+    max_sentiment = Column(Float, nullable=True)
+
+    first_mention_at = Column(DateTime, nullable=True)
+    last_mention_at = Column(DateTime, nullable=True)
+
+    created_at = Column(DateTime, default=lambda: datetime.utcnow(), nullable=False)
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+        nullable=False,
+    )
+
+    __table_args__ = (
+        UniqueConstraint(
+            "pubmed_id",
+            "meeting_id",
+            "sell_side_source_id",
+            name="uq_pubmed_meeting_source",
+        ),
+    )

cs_models/resources/PubmedMeetingSellSideSignal/schemas.py

@@ -0,0 +1,21 @@
+from marshmallow import Schema, fields, validate
+
+
+class PubmedMeetingSellSideSignalResourceSchema(Schema):
+    id = fields.Integer(dump_only=True)
+
+    pubmed_id = fields.Integer(required=True)
+    meeting_id = fields.Integer(required=True)
+    sell_side_source_id = fields.Integer(required=True)
+
+    doc_count = fields.Integer(required=True)
+    mention_count = fields.Integer(required=True)
+
+    avg_sentiment = fields.Float(allow_none=True)
+    max_sentiment = fields.Float(allow_none=True)
+
+    first_mention_at = fields.DateTime(allow_none=True)
+    last_mention_at = fields.DateTime(allow_none=True)
+
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/PubmedMeetingUserDocument/models.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Text,
+    Integer,
+    DateTime,
+    ForeignKey,
+)
+
+from ...database import Base
+
+
+class PubmedMeetingUserDocumentModel(Base):
+    __tablename__ = "pubmed_meeting_user_documents"
+
+    id = Column(Integer, primary_key=True)
+    pubmed_id = Column(
+        Integer,
+        ForeignKey('pubmed.id'),
+        nullable=False,
+    )
+    meeting_id = Column(
+        Integer,
+        ForeignKey('meetings.id'),
+        nullable=False,
+    )
+    user_document_id = Column(
+        Integer,
+        ForeignKey('user_documents.id'),
+        nullable=False,
+    )
+    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/PubmedMeetingUserDocument/schemas.py

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

cs_models/resources/SellSideAbstractMention/models.py

@@ -0,0 +1,57 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Float,
+    Text,
+    DateTime,
+    ForeignKey,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class SellSideAbstractMentionModel(Base):
+    __tablename__ = "sell_side_abstract_mentions"
+
+    id = Column(Integer, primary_key=True)
+
+    # which PDF / note
+    user_document_id = Column(
+        Integer,
+        ForeignKey("user_documents.id"),
+        nullable=False,
+        index=True,
+    )
+
+    # which conference
+    meeting_id = Column(
+        Integer,
+        ForeignKey("meetings.id"),
+        nullable=False,
+        index=True,
+    )
+
+    # optional locator
+    page_number = Column(Integer, nullable=True)
+
+    # raw LLM fields
+    title = Column(Text, nullable=True)
+    url = Column(Text, nullable=True)
+    abstract_number = Column(String(64), nullable=True)
+    abstract_search_query = Column(Text, nullable=True)
+    context = Column(Text, nullable=True)
+    sentiment = Column(Text, nullable=True)
+    llm_confidence = Column(Float, nullable=True)
+
+    raw_json = Column(Text, nullable=True)
+
+    created_at = Column(DateTime, default=lambda: datetime.utcnow(), nullable=False)
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+        nullable=False,
+    )
+

cs_models/resources/SellSideAbstractMention/schemas.py

@@ -0,0 +1,28 @@
+from marshmallow import Schema, fields
+
+
+class SellSideAbstractMentionResourceSchema(Schema):
+    id = fields.Integer(dump_only=True)
+
+    # which PDF / note
+    user_document_id = fields.Integer(required=True)
+    # which conference
+    meeting_id = fields.Integer(required=True)
+
+    page_number = fields.Integer(allow_none=True)
+    char_start = fields.Integer(allow_none=True)
+    char_end = fields.Integer(allow_none=True)
+
+    title = fields.String(allow_none=True)
+    url = fields.String(allow_none=True)
+    abstract_number = fields.String(allow_none=True)
+    abstract_search_query = fields.String(allow_none=True)
+    context = fields.String(allow_none=True)
+    sentiment = fields.String(allow_none=True)
+
+    llm_confidence = fields.Float(allow_none=True)
+
+    raw_json = fields.String(allow_none=True)
+
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/SellSideAbstractMentionLink/models.py

@@ -0,0 +1,60 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Float,
+    Boolean,
+    DateTime,
+    ForeignKey,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class SellSideAbstractMentionLinkModel(Base):
+    __tablename__ = "sell_side_abstract_mention_links"
+
+    id = Column(Integer, primary_key=True)
+
+    mention_id = Column(
+        Integer,
+        ForeignKey("sell_side_abstract_mentions.id"),
+        nullable=False,
+        index=True,
+    )
+    pubmed_id = Column(
+        Integer,
+        ForeignKey("pubmed.id"),
+        nullable=False,
+        index=True,
+    )
+
+    # where did this candidate come from?
+    match_source = Column(
+        String(64),
+        nullable=False,
+    )  # e.g. "grid_cited", "abstract_number", "url", "title_fuzzy", "context_llm"
+
+    # overall score + feature-level scores
+    match_score = Column(Float, nullable=False)
+    number_score = Column(Float, nullable=True)
+    url_score = Column(Float, nullable=True)
+    title_score = Column(Float, nullable=True)
+    context_score = Column(Float, nullable=True)
+    llm_score = Column(Float, nullable=True)
+
+    is_primary = Column(Boolean, nullable=False, default=False)
+
+    created_at = Column(DateTime, default=lambda: datetime.utcnow(), nullable=False)
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+        nullable=False,
+    )
+
+    __table_args__ = (
+        # you can keep multiple rows per pair (for debugging) or enforce uniqueness:
+        # UniqueConstraint("mention_id", "pubmed_id", name="uq_mention_pubmed"),
+    )

cs_models/resources/SellSideAbstractMentionLink/schemas.py

@@ -0,0 +1,24 @@
+from marshmallow import Schema, fields, validate
+
+
+class SellSideAbstractMentionLinkResourceSchema(Schema):
+    id = fields.Integer(dump_only=True)
+
+    mention_id = fields.Integer(required=True)
+    pubmed_id = fields.Integer(required=True)
+
+    # e.g. "grid_cited", "abstract_number", "url", "title_fuzzy", "context_llm"
+    match_source = fields.String(required=True, validate=validate.Length(min=1))
+
+    match_score = fields.Float(required=True)
+
+    number_score = fields.Float(allow_none=True)
+    url_score = fields.Float(allow_none=True)
+    title_score = fields.Float(allow_none=True)
+    context_score = fields.Float(allow_none=True)
+    llm_score = fields.Float(allow_none=True)
+
+    is_primary = fields.Boolean(required=True)
+
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/SellSideSource/models.py

@@ -0,0 +1,25 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class SellSideSourceModel(Base):
+    __tablename__ = "sell_side_sources"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String(255), nullable=False, unique=True)  # "Morgan Stanley"
+    code = Column(String(64), nullable=False, unique=True)    # "MS", "JPM"
+
+    created_at = Column(DateTime, default=lambda: datetime.utcnow(), nullable=False)
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+        nullable=False,
+    )

cs_models/resources/SellSideSource/schemas.py

@@ -0,0 +1,13 @@
+from marshmallow import Schema, fields, validate
+
+
+class SellSideSourceResourceSchema(Schema):
+    id = fields.Integer(dump_only=True)
+
+    # e.g. "Morgan Stanley"
+    name = fields.String(required=True, validate=validate.Length(min=1))
+    # e.g. "MS", "JPM"
+    code = fields.String(allow_none=True)
+
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/UserDocument/models.py

@@ -33,6 +33,13 @@ class UserDocumentModel(Base):
     metadata_info = Column(Text, nullable=True)
     status = Column(String(128), nullable=True)
     page_count = Column(Integer, nullable=True)
+    sell_side_source_id = Column(
+        Integer,
+        ForeignKey("sell_side_sources.id"),
+        nullable=True,
+        index=True,
+    )
+    sell_side_note_type = Column(String(64), nullable=True)
     updated_at = Column(
         DateTime,
         nullable=False,

cs_models/resources/UserDocument/schemas.py

@@ -21,4 +21,6 @@ class UserDocumentResourceSchema(Schema):
     category = fields.String(allow_none=True)
     status = fields.String(allow_none=True)
     page_count = fields.Integer(allow_none=True)
+    sell_side_source_id = fields.Integer(allow_none=True)
+    sell_side_note_type = fields.String(allow_none=True)
     updated_at = fields.DateTime(dump_only=True)

cs_models/resources/UserDocumentAccess/models.py

@@ -4,6 +4,7 @@ from sqlalchemy import (
     String,
     DateTime,
     Boolean,
+    ForeignKey,
 )
 from datetime import datetime
 
@@ -15,6 +16,11 @@ class UserDocumentAccessModel(Base):
 
     id = Column(Integer, primary_key=True)
     user_id = Column(String(128), nullable=False, index=True)
+    user_document_id = Column(
+        Integer,
+        ForeignKey('user_documents.id'),
+        nullable=False,
+    )
     provider_permission_id = Column(String(255), nullable=True)
     is_inherited = Column(Boolean, default=False)
     source_provider = Column(String(32), nullable=True)

cs_models/resources/UserDocumentAccess/schemas.py

@@ -10,6 +10,7 @@ class UserDocumentAccessResourceSchema(Schema):
 
     id = fields.Integer(dump_only=True)
     user_id = fields.String(required=True)
+    user_document_id = fields.Integer(required=True)
     provider_permission_id = fields.String(allow_none=True)
     is_inherited = fields.Boolean(allow_none=True)
     source_provider = fields.String(allow_none=True)

cs_models/resources/Workbook/models.py

@@ -10,6 +10,7 @@ from sqlalchemy.orm import relationship
 
 from ...database import Base
 from ..WorkbookBlock.models import WorkbookBlockModel
+from ..WorkbookCommentThread.models import WorkbookCommentThreadModel
 
 
 class WorkbookModel(Base):
@@ -35,3 +36,11 @@ class WorkbookModel(Base):
         order_by=WorkbookBlockModel.sequence_number,
         back_populates="workbook",
     )
+
+    comment_threads = relationship(
+        "WorkbookCommentThreadModel",
+        primaryjoin="and_(WorkbookModel.id==WorkbookCommentThreadModel.workbook_id, "
+                    "or_(WorkbookCommentThreadModel.is_deleted==False, WorkbookCommentThreadModel.is_deleted==None))",
+        order_by=WorkbookCommentThreadModel.updated_at.desc(),
+        back_populates="workbook",
+    )

cs_models/resources/Workbook/schemas.py

@@ -6,6 +6,7 @@ from marshmallow import (
 from ..WorkbookBlock.schemas import (
     WorkbookBlockResourceSchema,
 )
+from ..WorkbookCommentThread.schemas import WorkbookCommentThreadResourceSchema
 
 
 class WorkbookResourceSchema(Schema):
@@ -19,6 +20,11 @@ class WorkbookResourceSchema(Schema):
         many=True,
         dump_only=True,
     )
+    comment_threads = fields.Nested(
+        WorkbookCommentThreadResourceSchema(exclude=("workbook_id",)),
+        many=True,
+        dump_only=True,
+    )
     is_deleted = fields.Boolean(allow_none=True)
     is_public = fields.Boolean(allow_none=True)
     is_help_center = fields.Boolean(allow_none=True)

cs_models/resources/WorkbookCommentThread/models.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, Boolean, ForeignKey, Integer, Text, String
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+from ..WorkbookThreadComment.models import WorkbookThreadCommentModel
+
+
+class WorkbookCommentThreadModel(Base):
+    """
+    Represents a comment thread tied to a text selection in a workbook block.
+    """
+    __tablename__ = "workbook_comment_threads"
+
+    id = Column(Integer, primary_key=True)
+    workbook_id = Column(
+        Integer,
+        ForeignKey("workbooks.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    block_uid = Column(String(64), nullable=False)  # Root parent block UID
+
+    # Selection context
+    selected_text = Column(Text, nullable=False)  # The highlighted text
+
+    # Thread status
+    is_resolved = Column(Boolean, default=False, nullable=False)
+    resolved_by = Column(String(128), nullable=True)  # user_id who resolved
+    resolved_at = Column(DateTime, nullable=True)
+
+    # Soft delete
+    is_deleted = Column(Boolean, default=False, nullable=True)
+
+    # Timestamps
+    created_at = Column(DateTime, nullable=False, default=lambda: datetime.utcnow())
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+    )
+    created_by = Column(String(128), nullable=False)  # user_id who created thread
+
+    # Smart Grid Cells
+    cell_session_id = Column(Integer, nullable=True)
+    cell_user_query_id = Column(Integer, nullable=True)
+
+    # Relationships
+    workbook = relationship("WorkbookModel", back_populates="comment_threads")
+
+    comments = relationship(
+        "WorkbookThreadCommentModel",
+        primaryjoin="and_(WorkbookCommentThreadModel.id==WorkbookThreadCommentModel.thread_id, "
+                    "or_(WorkbookThreadCommentModel.is_deleted==False, WorkbookThreadCommentModel.is_deleted==None))",
+        order_by=WorkbookThreadCommentModel.sequence_number,
+        back_populates="thread",
+        lazy="joined",  # Eager load comments when loading thread
+    )

cs_models/resources/WorkbookCommentThread/schemas.py

@@ -0,0 +1,35 @@
+from marshmallow import Schema, fields, EXCLUDE
+from ..WorkbookThreadComment.schemas import (
+    WorkbookThreadCommentSchema,
+)
+
+
+class WorkbookCommentThreadResourceSchema(Schema):
+    """Class for AssistantCommandResource schema"""
+    class Meta:
+        unknown = EXCLUDE
+
+    id = fields.Integer(dump_only=True, data_key="thread_id")
+    workbook_id = fields.Integer(required=True)
+    block_uid = fields.String(required=True)
+    selected_text = fields.String(required=True)
+
+    # Thread status
+    is_resolved = fields.Boolean(allow_none=True)
+    resolved_by = fields.String(allow_none=True)
+    resolved_at = fields.DateTime(allow_none=True)
+
+    # Soft delete
+    is_deleted = fields.Boolean(allow_none=True)
+
+    # Timestamps
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+    created_by = fields.String(required=True)
+
+    # Smart Grid Cells
+    cell_session_id = fields.Integer(allow_none=True)
+    cell_user_query_id = fields.Integer(allow_none=True)
+
+    # Nested comments
+    comments = fields.Nested(WorkbookThreadCommentSchema(exclude=("thread_id",)), many=True, dump_only=True)

cs_models/resources/WorkbookThreadComment/models.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, Boolean, ForeignKey, Integer, Text, String
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+
+
+class WorkbookThreadCommentModel(Base):
+    """
+    Represents an individual comment within a thread.
+    """
+    __tablename__ = "workbook_thread_comments"
+
+    id = Column(Integer, primary_key=True)
+    thread_id = Column(
+        Integer,
+        ForeignKey("workbook_comment_threads.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    user_id = Column(String(128), nullable=False)
+    sequence_number = Column(Integer, nullable=False)  # 1 = initial comment
+    comment = Column(Text, nullable=False)
+
+    # Soft delete
+    is_deleted = Column(Boolean, default=False, nullable=True)
+
+    # Timestamps
+    created_at = Column(DateTime, nullable=False, default=lambda: datetime.utcnow())
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+    )
+
+    # Relationships
+    thread = relationship("WorkbookCommentThreadModel", back_populates="comments")