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

cs_models/resources/SalesEstimateCondition/models.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+    Float,
+    Boolean,
+)
+
+from ...database import Base
+
+
+class SalesEstimateConditionModel(Base):
+    __tablename__ = "sales_estimate_conditions"
+
+    id = Column(Integer, primary_key=True)
+    sales_estimate_id = Column(
+        Integer,
+        ForeignKey('sales_estimates.id'),
+        nullable=False,
+    )
+    condition_id = Column(
+        Integer,
+        ForeignKey('conditions.id'),
+        nullable=False,
+    )
+    score = Column(
+        Float,
+        nullable=False,
+    )
+    preferred = Column(Boolean, nullable=True)
+    date = Column(DateTime, 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/SalesEstimateCondition/schemas.py

@@ -0,0 +1,17 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class SalesEstimateConditionResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    sales_estimate_id = fields.Integer(required=True)
+    condition_id = fields.Integer(required=True)
+    score = fields.Float(required=True)
+    preferred = fields.Boolean(allow_none=True)
+    date = fields.DateTime(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/SalesEstimateIntervention/models.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+    Boolean,
+    Float,
+)
+
+from ...database import Base
+
+
+class SalesEstimateInterventionModel(Base):
+    __tablename__ = "sales_estimate_interventions"
+
+    id = Column(Integer, primary_key=True)
+    sales_estimate_id = Column(
+        Integer,
+        ForeignKey('sales_estimates.id'),
+        nullable=False,
+    )
+    intervention_id = Column(
+        Integer,
+        ForeignKey('interventions.id'),
+        nullable=False,
+    )
+    score = Column(
+        Float,
+        nullable=False,
+    )
+    preferred = Column(Boolean, nullable=True)
+    date = Column(DateTime, 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/SalesEstimateIntervention/schemas.py

@@ -0,0 +1,17 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class SalesEstimateInterventionResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    sales_estimate_id = fields.Integer(required=True)
+    intervention_id = fields.Integer(required=True)
+    score = fields.Float(required=True)
+    preferred = fields.Boolean(allow_none=True)
+    date = fields.DateTime(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/SalesEstimateTarget/models.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+    Float,
+    Boolean,
+)
+
+from ...database import Base
+
+
+class SalesEstimateTargetModel(Base):
+    __tablename__ = "sales_estimate_targets"
+
+    id = Column(Integer, primary_key=True)
+    sales_estimate_id = Column(
+        Integer,
+        ForeignKey('sales_estimates.id'),
+        nullable=False,
+    )
+    target_id = Column(
+        Integer,
+        ForeignKey('targets.id'),
+        nullable=False,
+    )
+    score = Column(
+        Float,
+        nullable=False,
+    )
+    preferred = Column(Boolean, nullable=True)
+    date = Column(DateTime, 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/SalesEstimateTarget/schemas.py

@@ -0,0 +1,17 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class SalesEstimateTargetResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    sales_estimate_id = fields.Integer(required=True)
+    target_id = fields.Integer(required=True)
+    score = fields.Float(required=True)
+    preferred = fields.Boolean(allow_none=True)
+    date = fields.DateTime(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/SalesTable/models.py

@@ -0,0 +1,34 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    Text,
+    Float,
+    String,
+    Boolean,
+)
+
+from ...database import Base
+
+
+class SalesTableModel(Base):
+    __tablename__ = "sales_tables"
+
+    id = Column(Integer, primary_key=True)
+    sec_accession_number = Column(String(128), nullable=False, index=True)
+    sec_cik = Column(String(128), nullable=False)
+    sec_file_name = Column(String(128), nullable=False)
+    table_number = Column(Integer, nullable=False)
+    table_preceding_info = Column(Text, nullable=True)
+    table_html = Column(Text, nullable=True)
+    score = Column(Float, nullable=True)
+    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/SalesTable/schemas.py

@@ -0,0 +1,20 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class SalesTableResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    sec_accession_number = fields.String(required=True)
+    sec_cik = fields.String(required=True)
+    sec_file_name = fields.String(required=True)
+    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/SearchLink/models.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    Text,
+    String,
+    Boolean,
+)
+
+from ...database import Base
+
+
+class SearchLinkModel(Base):
+    __tablename__ = "search_links"
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(String(128), nullable=False)
+    type = Column(String(50), nullable=False)
+    payload = Column(Text, nullable=True)
+    is_active = 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/SearchLink/schemas.py

@@ -0,0 +1,16 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class SearchLinkResourceSchema(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)
+    type = fields.String(required=True)
+    payload = fields.String(required=True)
+    is_active = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/Signature13F/models.py

@@ -0,0 +1,15 @@
+from sqlalchemy import Column, Integer, String, Date
+from ...database import Base
+
+
+class Signature13FModel(Base):
+    __tablename__ = '13fsignature'
+
+    ACCESSION_NUMBER = Column(String(25), primary_key=True)
+    NAME = Column(String(150), nullable=False)
+    TITLE = Column(String(60), nullable=False)
+    PHONE = Column(String(20))
+    SIGNATURE = Column(String(150), nullable=False)
+    CITY = Column(String(30), nullable=False)
+    STATEORCOUNTRY = Column(String(2), nullable=False)
+    SIGNATUREDATE = Column(Date, nullable=False)

cs_models/resources/Signature13F/schemas.py

@@ -0,0 +1,13 @@
+from marshmallow import Schema, fields
+from ...utils.utils import Safe13FDate
+
+
+class Signature13FSchema(Schema):
+    ACCESSION_NUMBER = fields.String(required=True)
+    NAME = fields.String(required=True)
+    TITLE = fields.String(required=True)
+    PHONE = fields.String()
+    SIGNATURE = fields.String(required=True)
+    CITY = fields.String(required=True)
+    STATEORCOUNTRY = fields.String(required=True)
+    SIGNATUREDATE = Safe13FDate(required=True)

cs_models/resources/SmartDefGrid/models.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, JSON
+from sqlalchemy.orm import relationship
+from ...database import Base
+
+
+class SmartDefGridModel(Base):
+    """
+    One extracted BlockNote table artifact.
+    You can link to your workbook/doc via source_* fields.
+    """
+    __tablename__ = "smart_def_grids"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)  # table_id (uuid string)
+    workbook_id = Column(
+        Integer,
+        ForeignKey('workbooks.id'),
+        nullable=True,
+        primary_key=True,
+    )
+    source_block_id = Column(String(64), nullable=True)     # BlockNote block id (if any)
+
+    outline_version = Column(Integer, nullable=False, default=1)   # your normalize() version
+    outline_json = Column(JSON, nullable=False)                     # semantic outline payload
+    original_table_json = Column(JSON, nullable=False)              # raw BlockNote table node (for rebuilds)
+
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+
+    cells = relationship("SmartDefGridCellModel", back_populates="table", cascade="all, delete-orphan")

cs_models/resources/SmartDefGrid/schemas.py

@@ -0,0 +1,52 @@
+from marshmallow import Schema, fields, validate
+from ..SmartDefGridCell.schemas import SmartDefGridCellResourceSchema
+
+
+class SmartDefGridResourceSchema(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
+    workbook_id = fields.Integer(allow_none=True)  # if you link to a workbook
+    source_block_id = fields.String(allow_none=True)
+
+    outline_version = fields.Integer(allow_none=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)
+
+    # read-only expansion of cells
+    cells = fields.Nested(
+        SmartDefGridCellResourceSchema(exclude=["smart_def_grid_id"]),
+        many=True,
+        dump_only=True,
+        # if you strictly want to hide 'table_id' inside each cell in this view:
+        # exclude=("table_id",),
+    )
+
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+
+
+class SmartDefGridDetailResourceSchema(Schema):
+    id = fields.String(dump_only=True)
+    workbook_id = fields.String(allow_none=True)
+    source_block_id = fields.String(allow_none=True)
+    outline_version = fields.Integer(allow_none=True)
+    outline_json = fields.Raw(required=True)
+    original_table_json = fields.Raw(required=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+
+    cells = fields.Nested(
+        SmartDefGridCellResourceSchema(),
+        many=True,
+        dump_only=True,
+        # include answers inlined under latest_question if you like:
+        only=("table_id","cell_id","row","col","is_header","formatting_spec",
+              "latest_question","applied_value"),
+    )

cs_models/resources/SmartDefGridCell/models.py

@@ -0,0 +1,51 @@
+from datetime import datetime
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, JSON, Boolean, Index, UniqueConstraint
+from sqlalchemy.orm import relationship
+from ...database import Base
+
+
+class SmartDefGridCellModel(Base):
+    """
+    One logical 'master' cell from the outline; the cell_id is stable.
+    Header cells exist too (is_header), in case you later want header questions.
+    """
+    __tablename__ = "smart_def_grid_cells"
+
+    # Composite natural key (table_id, cell_id)
+    smart_def_grid_id = Column(Integer, ForeignKey("smart_def_grids.id", ondelete="CASCADE"), primary_key=True)
+    cell_id = Column(String(36), primary_key=True)  # stable UUID you generated
+
+    # Positional metadata + spans help future reflow/debug, not needed at runtime for writeback
+    row = Column(Integer, nullable=False)
+    col = Column(Integer, nullable=False)
+    row_span = Column(Integer, nullable=False, default=1)
+    col_span = Column(Integer, nullable=False, default=1)
+    is_header = Column(Boolean, nullable=False, default=False)
+
+    header_path_row = Column(JSON, nullable=False, default=list)  # ["Efficacy (vs PBO)", "Clinical Remission"]
+    header_path_col = Column(JSON, nullable=False, default=list)  # ["Humira"] etc.
+
+    # Formatting guidance to apply when writing display strings
+    formatting_spec = Column(JSON, nullable=True)
+
+    # Optional: cache of the latest generated question id
+    latest_question_id = Column(Integer, ForeignKey("smart_def_grid_cell_questions.id"), nullable=True)
+
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+
+    table = relationship("SmartDefGridModel", back_populates="cells")
+    latest_question = relationship("SmartDefGridCellQuestionModel", foreign_keys=[latest_question_id], uselist=False)
+
+    # Canonical applied cell value (write-back)
+    applied_value = relationship(
+        "SmartDefGridCellValueModel",
+        back_populates="cell",
+        uselist=False,
+        cascade="all, delete-orphan",
+    )
+
+    __table_args__ = (
+        UniqueConstraint("smart_def_grid_id", "row", "col", name="uq_sdg_cell_pos"),
+        Index("ix_smart_def_grid_cells_header", "smart_def_grid_id", "is_header"),
+    )

cs_models/resources/SmartDefGridCell/schemas.py

@@ -0,0 +1,39 @@
+from marshmallow import Schema, fields, validate
+from ..SmartDefGridCellQuestion.schemas import SmartDefGridCellQuestionResourceSchema
+from ..SmartDefGridCellValue.schemas import SmartDefGridCellValueResourceSchema
+
+
+class SmartDefGridCellResourceSchema(Schema):
+    """
+    One logical (master) cell from the user-defined table.
+    """
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    smart_def_grid_id = fields.Integer(required=True)
+    cell_id = fields.String(required=True)
+
+    row = fields.Integer(required=True)
+    col = fields.Integer(required=True)
+    row_span = fields.Integer(required=True, data_key="rowSpan")
+    col_span = fields.Integer(required=True, data_key="colSpan")
+    is_header = fields.Boolean(required=True)
+
+    header_path_row = fields.List(fields.String(), required=True, data_key="headerPathRow")
+    header_path_col = fields.List(fields.String(), required=True, data_key="headerPathCol")
+
+    formatting_spec = fields.Raw(allow_none=True, data_key="formattingSpec")
+
+    latest_question_id = fields.String(allow_none=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+
+    # optional, read-only projections
+    latest_question = fields.Nested(
+        SmartDefGridCellQuestionResourceSchema(),
+        dump_only=True,
+        exclude=("answers",),
+    )
+    applied_value = fields.Nested(
+        SmartDefGridCellValueResourceSchema(),
+        dump_only=True,
+    )

cs_models/resources/SmartDefGridCellAnswer/models.py

@@ -0,0 +1,45 @@
+from datetime import datetime
+from sqlalchemy import Column, DateTime, ForeignKey, Float, String, JSON, Integer, Index, Text, BigInteger, ForeignKeyConstraint
+from sqlalchemy.orm import relationship
+from ...database import Base
+
+
+class SmartDefGridCellAnswerModel(Base):
+    """
+    Answers emitted by workers. Keep multiple rows per question (retries, models).
+    """
+    __tablename__ = "smart_def_grid_cell_answers"
+
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+    question_id = Column(Integer, ForeignKey("smart_def_grid_cell_questions.id", ondelete="CASCADE"), nullable=False)
+
+    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)
+
+    # canonical payload
+    raw_value = Column(Float, nullable=True)        # numeric scalar (if any)
+    text_value = Column(Text, nullable=True)        # string/summary
+    display_text = Column(Text, nullable=True)      # preformatted; writeback may still reformat
+    citations = Column(JSON, nullable=True)         # list of {url|doi|title|snippet|...}
+    extra_payload = Column(JSON, nullable=True)     # any provider-specific structure
+
+    # provenance
+    provider = Column(String(64), nullable=True)    # e.g., "gpt-4.1"
+    provider_meta = Column(JSON, nullable=True)     # tokens, latency, etc.
+
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+
+    # convenience index to quickly get latest by created_at
+    __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",
+        ),
+        Index("ix_smart_def_grid_cell_answers_cell", "smart_def_grid_id", "cell_id", "created_at"),
+        Index("ix_sdgca_run_cell", "run_id", "smart_def_grid_id", "cell_id", "created_at"),
+    )
+
+    question = relationship("SmartDefGridCellQuestionModel", back_populates="answers")
+    run = relationship("SmartDefGridRunModel")

cs_models/resources/SmartDefGridCellAnswer/schemas.py

@@ -0,0 +1,23 @@
+from marshmallow import Schema, fields
+
+
+class SmartDefGridCellAnswerResourceSchema(Schema):
+    id = fields.String(dump_only=True)
+    question_id = fields.Integer(required=True)
+    smart_def_grid_id = fields.Integer(required=True)
+    cell_id = fields.String(required=True)
+
+    raw_value = fields.Float(allow_none=True)
+    text_value = fields.String(allow_none=True)
+    display_text = fields.String(allow_none=True)
+
+    citations = fields.Raw(allow_none=True)              # list/dict (or keep normalized rows separately)
+    extra_payload = fields.Raw(allow_none=True)          # provider-specific data
+
+    provider = fields.String(allow_none=True)
+    provider_meta = fields.Raw(allow_none=True)
+
+    created_at = fields.DateTime(dump_only=True)
+
+    # if you materialize normalized citations, expose them here:
+    # citations_rel = fields.Nested(AnswerCitationResourceSchema, many=True, dump_only=True)

cs_models/resources/SmartDefGridCellAnswerCitation/models.py

@@ -0,0 +1,21 @@
+from sqlalchemy import Column, DateTime, ForeignKey, String, JSON, Integer, Index, Text, BigInteger
+from ...database import Base
+
+
+class SmartDefGridCellAnswerCitationModel(Base):
+    __tablename__ = "smart_def_grid_cell_answer_citations"
+
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+    answer_id = Column(Integer, ForeignKey("smart_def_grid_cell_answers.id", ondelete="CASCADE"), nullable=False)
+
+    source_type = Column(String(16), nullable=True)  # 'url','doi','patent','pubmed'
+    source_id = Column(String(256), nullable=True)   # doi, pubmed id, etc.
+    url = Column(Text, nullable=True)
+    title = Column(Text, nullable=True)
+    snippet = Column(Text, nullable=True)
+    published_at = Column(DateTime, nullable=True)
+    extra = Column(JSON, nullable=True)
+
+    __table_args__ = (
+        Index("ix_smart_def_grid_cell_answer_citations_source", "source_type", "source_id"),
+    )

cs_models/resources/SmartDefGridCellAnswerCitation/schemas.py

@@ -0,0 +1,14 @@
+from marshmallow import Schema, fields, validate
+
+
+class SmartDefGridCellAnswerCitationResourceSchema(Schema):
+    id = fields.Integer(dump_only=True)
+    answer_id = fields.Integer(required=True)
+
+    source_type = fields.String(allow_none=True)
+    source_id = fields.String(allow_none=True)
+    url = fields.String(allow_none=True)
+    title = fields.String(allow_none=True)
+    snippet = fields.String(allow_none=True)
+    published_at = fields.DateTime(allow_none=True)
+    extra = fields.Raw(allow_none=True)                  # any additional normalized payload