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

cs_models/resources/TranscriptIntervention/schemas.py

@@ -0,0 +1,17 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class TranscriptInterventionResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    transcript_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/TranscriptItem/models.py

@@ -0,0 +1,35 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Text,
+    ForeignKey,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class TranscriptItemModel(Base):
+    __tablename__ = 'transcript_items'
+
+    id = Column(Integer, primary_key=True)
+    transcript_item_id = Column(Integer, nullable=False, index=True)
+    transcript_id = Column(
+        Integer,
+        ForeignKey('transcripts.id'),
+        nullable=False,
+    )
+    transcript = Column(Text, nullable=True)
+    timestamp = Column(DateTime, nullable=True)
+    speaker_id = Column(Integer, nullable=True)
+    speaker_name = Column(String(128), nullable=True)
+    speaker_title = Column(String(128), nullable=True)
+    audio_url = Column(String(191), nullable=True)
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+    )

cs_models/resources/TranscriptItem/schemas.py

@@ -0,0 +1,20 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class TranscriptItemResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    transcript_item_id = fields.Integer(required=True)
+    transcript_id = fields.Integer(required=True)
+    transcript = fields.String(allow_none=True)
+    timestamp = fields.DateTime(allow_none=True)
+    speaker_id = fields.Integer(allow_none=True)
+    speaker_name = fields.String(allow_none=True)
+    speaker_title = fields.String(allow_none=True)
+    audio_url = fields.String(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/TranscriptTarget/models.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+    Float,
+    Boolean,
+)
+
+from ...database import Base
+
+
+class TranscriptTargetModel(Base):
+    __tablename__ = "transcript_targets"
+
+    id = Column(Integer, primary_key=True)
+    transcript_id = Column(
+        Integer,
+        ForeignKey('transcripts.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/TranscriptTarget/schemas.py

@@ -0,0 +1,17 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class TranscriptTargetResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    transcript_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/UserAutomatedDigest/models.py

@@ -0,0 +1,35 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    ForeignKey,
+    Boolean,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class UserAutomatedDigestModel(Base):
+    __tablename__ = 'user_automated_digests'
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(String(128), nullable=False)
+    type = Column(String(50), nullable=False)
+    type_id = Column(String(50), nullable=False)
+    digest_name = Column(String(128), nullable=False)
+    created_at = Column(DateTime, nullable=False)
+    assistant_user_query_id = Column(
+        Integer,
+        ForeignKey('assistant_user_queries.id'),
+        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(),
+    )

cs_models/resources/UserAutomatedDigest/schemas.py

@@ -0,0 +1,19 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class UserAutomatedDigestResourceSchema(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)
+    type_id = fields.String(required=True)
+    digest_name = fields.String(required=True)
+    created_at = fields.DateTime(required=True)
+    assistant_user_query_id = fields.Integer(required=True)
+    is_deleted = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/UserDocument/models.py

@@ -6,6 +6,7 @@ from sqlalchemy import (
     ForeignKey,
     Boolean,
     Float,
+    Text,
 )
 from datetime import datetime
 
@@ -29,8 +30,16 @@ class UserDocumentModel(Base):
     is_deleted = Column(Boolean, nullable=True)
     upload_date = Column(DateTime, nullable=False)
     category = Column(String(128), nullable=True)
+    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

@@ -17,7 +17,10 @@ class UserDocumentResourceSchema(Schema):
     type_score = fields.Float(allow_none=True)
     is_deleted = fields.Boolean(allow_none=True)
     upload_date = fields.DateTime(required=True)
+    metadata_info = fields.String(allow_none=True)
     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

@@ -0,0 +1,35 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Boolean,
+    ForeignKey,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class UserDocumentAccessModel(Base):
+    __tablename__ = 'user_document_access'
+
+    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)
+    is_deleted = Column(Boolean, default=False)
+    synced_at = Column(DateTime, nullable=False)
+    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/UserDocumentAccess/schemas.py

@@ -0,0 +1,19 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class UserDocumentAccessResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    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)
+    is_deleted = fields.Boolean(allow_none=True)
+    synced_at = fields.DateTime(required=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/UserDocumentChunk/models.py

@@ -0,0 +1,35 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    ForeignKey,
+    Text,
+    Boolean,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class UserDocumentChunkModel(Base):
+    __tablename__ = 'user_document_chunks'
+
+    id = Column(Integer, primary_key=True)
+    user_document_id = Column(
+        Integer,
+        ForeignKey('user_documents.id'),
+        nullable=False,
+    )
+    chunk_cui = Column(String(50), nullable=False)
+    chunk_text = Column(Text, nullable=False)
+    chunk_embedding = Column(Text, nullable=False)
+    embedding_source = Column(String(50), 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(),
+    )

cs_models/resources/UserDocumentChunk/schemas.py

@@ -0,0 +1,18 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class UserDocumentChunkResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    user_document_id = fields.Integer(required=True)
+    chunk_cui = fields.String(required=True)
+    chunk_text = fields.String(required=True)
+    chunk_embedding = fields.String(required=True)
+    embedding_source = fields.String(required=True)
+    is_deleted = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/UserDocumentHierarchy/models.py

@@ -0,0 +1,51 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    ForeignKey,
+    Boolean,
+)
+from sqlalchemy.orm import relationship
+from datetime import datetime
+
+from ...database import Base
+
+
+class UserDocumentHierarchyModel(Base):
+    __tablename__ = 'user_documents_hierarchy'
+
+    id = Column(Integer, primary_key=True)
+    provider_id = Column(String(128), nullable=False, index=True)
+    user_id = Column(String(128), nullable=False, index=True)
+    type = Column(String(50), nullable=False)
+    document_name = Column(String(255), nullable=True)
+    parent_id = Column(
+        Integer,
+        ForeignKey('user_documents_hierarchy.id'),
+        nullable=True
+    )
+    is_folder = Column(Boolean, nullable=True)
+    user_document_id = Column(
+        Integer,
+        ForeignKey('user_documents.id'),
+        nullable=True,
+    )
+    workbook_id = Column(
+        Integer,
+        ForeignKey('workbooks.id'),
+        nullable=True,
+    )
+    sha1 = Column(String(40), nullable=True)
+    is_deleted = Column(Boolean, nullable=True)
+    is_trashed = Column(Boolean, nullable=True)
+    is_locked = 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(),
+    )
+
+    children = relationship("UserDocumentHierarchyModel", backref='parent', remote_side=[id])

cs_models/resources/UserDocumentHierarchy/schemas.py

@@ -0,0 +1,24 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class UserDocumentHierarchyResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    provider_id = fields.String(required=True)
+    user_id = fields.String(required=True)
+    type = fields.String(required=True)
+    document_name = fields.String(allow_none=True)
+    parent_id = fields.Integer(allow_none=True)
+    is_folder = fields.Boolean(allow_none=True)
+    user_document_id = fields.Integer(allow_none=True)
+    workbook_id = fields.Integer(allow_none=True)
+    sha1 = fields.String(allow_none=True)
+    is_deleted = fields.Boolean(allow_none=True)
+    is_trashed = fields.Boolean(allow_none=True)
+    is_locked = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/UserDocumentMeeting/models.py

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

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

cs_models/resources/UserDocumentTag/models.py

@@ -0,0 +1,31 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    ForeignKey,
+    Float,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class UserDocumentTagModel(Base):
+    __tablename__ = 'user_document_tags'
+
+    id = Column(Integer, primary_key=True)
+    user_document_id = Column(
+        Integer,
+        ForeignKey('user_documents.id'),
+        nullable=False,
+    )
+    tag = Column(String(50), nullable=False, index=True)
+    score = Column(Float, 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/UserDocumentTag/schemas.py

@@ -0,0 +1,15 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class UserDocumentTagResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    user_document_id = fields.Integer(required=True)
+    tag = fields.String(required=True, validate=not_blank)
+    score = fields.Float(allow_none=True)
+    updated_at = fields.DateTime()

cs_models/resources/UserExplorerColumn/models.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    Text,
+    Boolean,
+    String,
+)
+
+from ...database import Base
+
+
+class UserExplorerColumnModel(Base):
+    __tablename__ = "user_explorer_columns"
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(String(128), nullable=False, index=True)
+    artifact_ids = Column(Text, nullable=False)
+    prompt = Column(String(128), nullable=False)
+    result = 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/UserExplorerColumn/schemas.py

@@ -0,0 +1,14 @@
+from marshmallow import (
+    Schema,
+    fields,
+)
+
+
+class UserExplorerColumnResourceSchema(Schema):
+    id = fields.Integer(dump_only=True)
+    user_id = fields.String(required=True)
+    artifact_ids = fields.String(required=True)
+    prompt = fields.String(required=True)
+    result = fields.String(required=True)
+    is_completed = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/UserInternalDocWorkflow/models.py

@@ -0,0 +1,28 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    Text,
+    String,
+    DateTime,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class UserInternalDocWorkflowModel(Base):
+    __tablename__ = 'user_internal_doc_workflow'
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(String(128), nullable=False, index=True)
+    internal_doc_workflow = Column(
+        Text,
+        nullable=False,
+    )
+    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/UserInternalDocWorkflow/schemas.py

@@ -0,0 +1,11 @@
+from marshmallow import (
+    Schema,
+    fields,
+)
+
+
+class UserInternalDocWorkflowResourceSchema(Schema):
+    id = fields.Integer(dump_only=True)
+    user_id = fields.String(required=True)
+    internal_doc_workflow = fields.String(required=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/UserMeeting/models.py

@@ -0,0 +1,31 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    ForeignKey,
+    Boolean,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class UserMeetingModel(Base):
+    __tablename__ = 'user_meetings'
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(String(128), nullable=False)
+    meeting_id = Column(
+        Integer,
+        ForeignKey('meetings.id'),
+        nullable=False,
+    )
+    notification_status = 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/UserMeeting/schemas.py

@@ -0,0 +1,12 @@
+from marshmallow import (
+    Schema,
+    fields,
+)
+
+
+class UserMeetingResourceSchema(Schema):
+    id = fields.Integer(dump_only=True)
+    user_id = fields.String(required=True)
+    meeting_id = fields.Integer(required=True)
+    notification_status = fields.Boolean(allow_none=True)
+    updated_at = fields.DateTime(dump_only=True)