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

cs_models/resources/EventLLM/models.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    ForeignKey,
+    DateTime,
+    Text,
+)
+
+from ...database import Base
+
+
+class EventLLMModel(Base):
+    __tablename__ = "events_llm"
+
+    id = Column(Integer, primary_key=True)
+    start_date = Column(DateTime, nullable=False)
+    end_date = Column(DateTime, nullable=True)
+    event_type = Column(String(128), nullable=True)
+    description = Column(Text, nullable=True)
+    tags = Column(Text, nullable=True)
+    news_id = Column(
+        Integer,
+        ForeignKey('newswires.id'),
+        nullable=True,
+    )
+    sec_filing_id = Column(
+        Integer,
+        ForeignKey('companies_sec_filings.id'),
+        nullable=True,
+    )
+    reference_text = 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/EventLLM/schemas.py

@@ -0,0 +1,39 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+    pre_load,
+    ValidationError,
+)
+
+
+class EventLLMResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    id = fields.Integer(dump_only=True)
+    start_date = fields.DateTime(required=True)
+    end_date = fields.DateTime(allow_none=True)
+    event_type = fields.String(allow_none=True)
+    description = fields.String(allow_none=True)
+    tags = fields.String(allow_none=True)
+    news_id = fields.Integer(allow_none=True)
+    sec_filing_id = fields.Integer(allow_none=True)
+    reference_text = fields.String(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)
+
+    @pre_load
+    def check_company_info(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/EventsQueue/models.py

@@ -0,0 +1,33 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    Boolean,
+    String,
+    Text,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class EventsQueueModel(Base):
+    __tablename__ = 'events_queue'
+
+    id = Column(Integer, primary_key=True)
+    artifact_id = Column(String(50), nullable=False)
+    processed = Column(
+        Boolean,
+        nullable=True,
+    )
+    attempts = Column(Integer, nullable=True)
+    error = Column(Text, nullable=True)
+    submitted = Column(Boolean, nullable=True)
+    submitted_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/EventsQueue/schemas.py

@@ -0,0 +1,18 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class EventsQueueResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    artifact_id = fields.String(required=True)
+    processed = fields.Boolean(allow_none=True)
+    attempts = fields.Integer(allow_none=True)
+    error = fields.String(allow_none=True)
+    submitted = fields.Boolean(allow_none=True)
+    submitted_date = fields.DateTime(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/ExplorerColumn/models.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    Text,
+    Boolean,
+    String,
+)
+
+from ...database import Base
+
+
+class ExplorerColumnModel(Base):
+    __tablename__ = "explorer_columns"
+
+    id = Column(Integer, primary_key=True)
+    artifact_id = Column(
+        String(50),
+        nullable=False,
+        index=True
+    )
+    prompt = Column(String(128), nullable=False, index=True)
+    answer = Column(Text, nullable=True)
+    is_completed = 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/ExplorerColumn/schemas.py

@@ -0,0 +1,16 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class ExplorerColumnResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    artifact_id = fields.String(required=True)
+    prompt = fields.String(required=True)
+    answer = fields.String(allow_none=True)
+    is_completed = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/ExternalDrive/models.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    String,
+    Text,
+)
+
+from ...database import Base
+
+
+class ExternalDriveModel(Base):
+    __tablename__ = "external_drives"
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(String(128), nullable=False)
+    org_id = Column(String(128), nullable=True)
+    provider = Column(String(50), nullable=False)
+    webhook_id = Column(String(128), nullable=False)
+    additional_info = 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/ExternalDrive/schemas.py

@@ -0,0 +1,14 @@
+from marshmallow import (
+    Schema,
+    fields,
+)
+
+
+class ExternalDriveResourceSchema(Schema):
+    id = fields.Integer(dump_only=True)
+    user_id = fields.String(required=True)
+    org_id = fields.String(allow_none=True)
+    webhook_id = fields.String(required=True)
+    provider = fields.String(required=True)
+    additional_info = fields.String(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/FDADrugReview/models.py

@@ -0,0 +1,29 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class FDADrugReviewModel(Base):
+    __tablename__ = 'fda_drug_reviews'
+
+    id = Column(Integer, primary_key=True)
+    application_docs_id = Column(String(128), nullable=False)
+    application_docs_type_id = Column(Integer, nullable=False)
+    appl_no = Column(String(50), nullable=False)
+    submission_type = Column(String(50), nullable=True)
+    submission_no = Column(String(50), nullable=True)
+    application_doc_url = Column(String(255), nullable=True)
+    application_doc_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/FDADrugReview/schemas.py

@@ -0,0 +1,19 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class FDADrugReviewResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    application_docs_id = fields.String(required=True)
+    application_docs_type_id = fields.Integer(required=True)
+    appl_no = fields.String(required=True)
+    submission_type = fields.String(allow_none=True)
+    submission_no = fields.String(allow_none=True)
+    application_doc_url = fields.String(allow_none=True)
+    application_doc_date = fields.DateTime(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/FDADrugReviewFile/models.py

@@ -0,0 +1,43 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    ForeignKey,
+    Boolean,
+    Float,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class FDADrugReviewFileModel(Base):
+    __tablename__ = 'fda_drug_review_files'
+
+    id = Column(Integer, primary_key=True)
+    fda_drug_review_id = Column(
+        Integer,
+        ForeignKey('fda_drug_reviews.id'),
+        nullable=False,
+    )
+    file_id = Column(
+        Integer,
+        ForeignKey('files.id'),
+        nullable=False,
+    )
+    date = Column(DateTime, nullable=True)
+    title = Column(String(255), nullable=True)
+    page_count = Column(Integer, nullable=True)
+    type = Column(String(255), nullable=True)
+    orig_file_url = Column(String(255), nullable=True)
+    is_deleted = Column(Boolean, nullable=True)
+    unprocessed = Column(Boolean, nullable=True)
+    reviewed = 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/FDADrugReviewFile/schemas.py

@@ -0,0 +1,22 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class FDADrugReviewFileResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    fda_drug_review_id = fields.Integer(required=True)
+    file_id = fields.Integer(required=True)
+    date = fields.DateTime(allow_none=True)
+    title = fields.String(allow_none=True)
+    page_count = fields.Integer(allow_none=True)
+    type = fields.String(allow_none=True)
+    orig_file_url = fields.String(allow_none=True)
+    is_deleted = fields.Boolean(allow_none=True)
+    unprocessed = fields.Boolean(allow_none=True)
+    reviewed = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/FDADrugReviewFileCondition/models.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+    Float,
+    Boolean,
+)
+
+from ...database import Base
+
+
+class FDADrugReviewFileConditionModel(Base):
+    __tablename__ = "fda_drug_review_files_conditions"
+
+    id = Column(Integer, primary_key=True)
+    fda_drug_review_file_id = Column(
+        Integer,
+        ForeignKey('fda_drug_review_files.id'),
+        nullable=False,
+    )
+    condition_id = Column(
+        Integer,
+        ForeignKey('conditions.id'),
+        nullable=False,
+    )
+    score = Column(
+        Float,
+        nullable=False,
+    )
+    preferred = Column(Boolean, nullable=True)
+    data_readout = 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/FDADrugReviewFileCondition/schemas.py

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

cs_models/resources/FDADrugReviewFileIntervention/models.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+    Float,
+    Boolean,
+)
+
+from ...database import Base
+
+
+class FDADrugReviewFileInterventionModel(Base):
+    __tablename__ = "fda_drug_review_files_interventions"
+
+    id = Column(Integer, primary_key=True)
+    fda_drug_review_file_id = Column(
+        Integer,
+        ForeignKey('fda_drug_review_files.id'),
+        nullable=False,
+    )
+    intervention_id = Column(
+        Integer,
+        ForeignKey('interventions.id'),
+        nullable=False,
+    )
+    score = Column(
+        Float,
+        nullable=False,
+    )
+    preferred = Column(Boolean, nullable=True)
+    data_readout = 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/FDADrugReviewFileIntervention/schemas.py

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

cs_models/resources/FDADrugReviewFileTarget/models.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+    Float,
+    Boolean,
+)
+
+from ...database import Base
+
+
+class FDADrugReviewFileTargetModel(Base):
+    __tablename__ = "fda_drug_review_files_targets"
+
+    id = Column(Integer, primary_key=True)
+    fda_drug_review_file_id = Column(
+        Integer,
+        ForeignKey('fda_drug_review_files.id'),
+        nullable=False,
+    )
+    target_id = Column(
+        Integer,
+        ForeignKey('targets.id'),
+        nullable=False,
+    )
+    score = Column(
+        Float,
+        nullable=False,
+    )
+    preferred = Column(Boolean, nullable=True)
+    data_readout = 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/FDADrugReviewFileTarget/schemas.py

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

cs_models/resources/FDALabel/models.py

@@ -5,6 +5,7 @@ from sqlalchemy import (
     DateTime,
     ForeignKey,
     Text,
+    Boolean,
 )
 from datetime import datetime
 from ...database import Base
@@ -31,6 +32,8 @@ class FDALabelModel(Base):
         nullable=False,
     )
     section_text = Column(Text, nullable=True)
+    is_active = Column(Boolean, nullable=True)
+    vector_active = Column(Boolean, nullable=True)
     updated_at = Column(
         DateTime,
         nullable=False,

cs_models/resources/FDALabel/schemas.py

@@ -18,4 +18,6 @@ class FDALabelResourceSchema(Schema):
     section_type = fields.String(required=True)
     section_html_file_id = fields.Integer(allow_none=True)
     label_html_file_id = fields.Integer(required=True)
+    is_active = fields.Boolean(allow_none=True)
+    vector_active = fields.Boolean(allow_none=True)
     updated_at = fields.DateTime(dump_only=True)

cs_models/resources/FDAMeetingFiling/models.py

@@ -28,6 +28,7 @@ class FDAMeetingFilingModel(Base):
     )
     date = Column(DateTime, nullable=True)
     title = Column(String(255), nullable=True)
+    page_count = Column(Integer, nullable=True)
     old_type = Column(String(255), nullable=True)
     type = Column(String(255), nullable=True)
     type_score = Column(Float, nullable=True)

cs_models/resources/FDAMeetingFiling/schemas.py

@@ -13,6 +13,7 @@ class FDAMeetingFilingResourceSchema(Schema):
     file_id = fields.Integer(required=True)
     date = fields.DateTime(allow_none=True)
     title = fields.String(allow_none=True)
+    page_count = fields.Integer(allow_none=True)
     type = fields.String(allow_none=True)
     old_type = fields.String(allow_none=True)
     type_score = fields.Float(allow_none=True)

cs_models/resources/FinancingDealType/models.py

@@ -0,0 +1,28 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    String,
+)
+
+from ...database import Base
+
+
+class FinancingDealTypeModel(Base):
+    __tablename__ = "financing_deal_types"
+
+    id = Column(Integer, primary_key=True)
+    deal_type = Column(
+        String(128),
+        nullable=False,
+        index=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/FinancingDealType/schemas.py

@@ -0,0 +1,13 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class FinancingDealTypeResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    deal_type = fields.String(required=True)
+    updated_at = fields.DateTime()

cs_models/resources/InfoTable13F/models.py

@@ -0,0 +1,26 @@
+from sqlalchemy import Column, Integer, String, PrimaryKeyConstraint
+from ...database import Base
+
+
+class Infotable13FModel(Base):
+    __tablename__ = '13finfotable'
+
+    ACCESSION_NUMBER = Column(String(25))
+    INFOTABLE_SK = Column(Integer)
+    NAMEOFISSUER = Column(String(200), nullable=False)
+    TITLEOFCLASS = Column(String(150), nullable=False)
+    CUSIP = Column(String(9), nullable=False)
+    FIGI = Column(String(12))
+    VALUE = Column(Integer, nullable=False)
+    SSHPRNAMT = Column(Integer, nullable=False)
+    SSHPRNAMTTYPE = Column(String(10), nullable=False)
+    PUTCALL = Column(String(10))
+    INVESTMENTDISCRETION = Column(String(10), nullable=False)
+    OTHERMANAGER = Column(String(100))
+    VOTING_AUTH_SOLE = Column(Integer, nullable=False)
+    VOTING_AUTH_SHARED = Column(Integer, nullable=False)
+    VOTING_AUTH_NONE = Column(Integer, nullable=False)
+
+    __table_args__ = (
+        PrimaryKeyConstraint('ACCESSION_NUMBER', 'INFOTABLE_SK'),
+    )