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

cs_models/resources/SalesEstimate/models.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    String,
+    DECIMAL,
+    Float,
+)
+
+from ...database import Base
+
+
+class SalesEstimateModel(Base):
+    __tablename__ = "sales_estimates"
+
+    id = Column(Integer, primary_key=True)
+    fiscal_year = Column(Integer, nullable=True)
+    request_id = Column(String(20), nullable=True)
+    metric = Column(String(50), nullable=True)
+    drug_name = Column(String(128), nullable=False, index=True)
+    company_name = Column(String(128), nullable=True, index=True)
+    currency = Column(String(20), nullable=True)
+    fiscal_end_date = Column(DateTime, nullable=True)
+    estimate_date = Column(DateTime, nullable=True)
+    estimate_count = Column(Integer, nullable=True)
+    mean = Column(DECIMAL(13, 2), nullable=True)
+    median = Column(DECIMAL(13, 2), nullable=True)
+    sd = Column(Float, nullable=True)
+    high = Column(DECIMAL(13, 2), nullable=True)
+    low = Column(DECIMAL(13, 2), 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/SalesEstimate/schemas.py

@@ -0,0 +1,26 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class SalesEstimateResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    fiscal_year = fields.Integer(allow_none=True)
+    request_id = fields.String(allow_none=True)
+    metric = fields.String(allow_none=True)
+    drug_name = fields.String(required=True)
+    company_name = fields.String(allow_none=True)
+    currency = fields.String(allow_none=True)
+    fiscal_end_date = fields.DateTime(allow_none=True)
+    estimate_date = fields.DateTime(allow_none=True)
+    estimate_count = fields.Integer(allow_none=True)
+    mean = fields.Decimal(allow_none=True)
+    median = fields.Decimal(allow_none=True)
+    sd = fields.Float(allow_none=True)
+    high = fields.Decimal(allow_none=True)
+    low = fields.Decimal(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/SalesEstimateCompany/models.py

@@ -0,0 +1,38 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class SalesEstimateCompanyModel(Base):
+    __tablename__ = 'sales_estimate_companies'
+
+    id = Column(Integer, primary_key=True)
+    company_sec_id = Column(
+        Integer,
+        ForeignKey('companies_sec.id'),
+        nullable=True,
+    )
+    company_ous_id = Column(
+        Integer,
+        ForeignKey('companies_ous.id'),
+        nullable=True,
+    )
+    sales_estimate_id = Column(
+        Integer,
+        ForeignKey('sales_estimates.id'),
+        nullable=False,
+    )
+    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/SalesEstimateCompany/schemas.py

@@ -0,0 +1,35 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+    pre_load,
+    ValidationError,
+)
+
+
+class SalesEstimateCompanyResourceSchema(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)
+    company_sec_id = fields.Integer(allow_none=True)
+    company_ous_id = fields.Integer(allow_none=True)
+    date = fields.DateTime(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)
+
+    @pre_load
+    def check_company_ids(self, in_data, **kwargs):
+        if self._get_number_of_company_fields(in_data) > 1:
+            raise ValidationError('Provide either company_sec_id or '
+                                  'company_ous_id, not both')
+        return in_data
+
+    def _get_number_of_company_fields(self, in_data, **kwargs):
+        result = 0
+        if 'company_sec_id' in in_data:
+            if in_data['company_sec_id'] is not None:
+                result += 1
+        if 'company_ous_id' in in_data:
+            if in_data['company_ous_id'] is not None:
+                result += 1
+        return result

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,
+    )