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

cs_models/resources/ViewPublicAssistantUserQuery/models.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+    Text,
+)
+
+from ...database import Base
+
+
+class ViewPublicAssistantUserQueryModel(Base):
+    __tablename__ = "_view_public_assistant_user_queries"
+
+    id = Column(Integer, primary_key=True)
+    user_query_id = Column(
+        Integer,
+        ForeignKey('assistant_user_queries.id'),
+        nullable=False,
+    )
+    data = 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/ViewPublicAssistantUserQuery/schemas.py

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

cs_models/resources/ViewPublicWorkbook/models.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+    Text,
+)
+
+from ...database import Base
+
+
+class ViewPublicWorkbookModel(Base):
+    __tablename__ = "_view_public_workbooks"
+
+    id = Column(Integer, primary_key=True)
+    workbook_id = Column(
+        Integer,
+        ForeignKey('workbooks.id'),
+        nullable=False,
+    )
+    data = 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/ViewPublicWorkbook/schemas.py

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

cs_models/resources/ViewPublicationCondition/models.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    String,
+    ForeignKey,
+)
+
+from ...database import Base
+
+
+class ViewPublicationConditionModel(Base):
+    __tablename__ = "_view_publication_condition"
+
+    id = Column(Integer, primary_key=True)
+    condition_id = Column(
+        Integer,
+        ForeignKey('conditions.id'),
+        nullable=False,
+    )
+    date = Column(DateTime, nullable=False)
+    table_name = Column(String(50), nullable=False)
+    table_id = Column(Integer, 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/ViewPublicationCondition/schemas.py

@@ -0,0 +1,16 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class ViewPublicationConditionResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error='Field cannot be blank')
+
+    id = fields.Integer(dump_only=True)
+    condition_id = fields.Integer(required=True)
+    date = fields.DateTime(required=True)
+    table_name = fields.String(required=True)
+    table_id = fields.Integer(required=True)
+    updated_at = fields.DateTime()

cs_models/resources/WatchlistDigest/models.py

@@ -0,0 +1,36 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Boolean,
+    ForeignKey,
+)
+from datetime import datetime
+
+from ...database import Base
+
+
+class WatchlistDigestModel(Base):
+    __tablename__ = 'watchlist_digests'
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(String(128), nullable=False, index=True)
+    watchlist_id = Column(
+        Integer,
+        ForeignKey('user_watchlists.id'),
+        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/WatchlistDigest/schemas.py

@@ -0,0 +1,16 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+
+
+class WatchlistDigestResourceSchema(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)
+    watchlist_id = fields.Integer(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/Workbook/models.py

@@ -0,0 +1,37 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Boolean,
+)
+from datetime import datetime
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+from ..WorkbookBlock.models import WorkbookBlockModel
+
+
+class WorkbookModel(Base):
+    __tablename__ = 'workbooks'
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(String(128), nullable=False)
+    workbook_name = Column(String(128), nullable=False)
+    is_deleted = Column(Boolean, nullable=True)
+    is_public = Column(Boolean, nullable=True)
+    is_help_center = Column(Boolean, nullable=True)
+    created_at = Column(DateTime, nullable=False)
+    updated_at = Column(
+        DateTime,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+    )
+
+    blocks = relationship(
+        "WorkbookBlockModel",
+        primaryjoin="and_(WorkbookModel.id==WorkbookBlockModel.workbook_id, "
+                    "or_(WorkbookBlockModel.is_deleted==False, WorkbookBlockModel.is_deleted==None))",
+        order_by=WorkbookBlockModel.sequence_number,
+        back_populates="workbook",
+    )

cs_models/resources/Workbook/schemas.py

@@ -0,0 +1,26 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+from ..WorkbookBlock.schemas import (
+    WorkbookBlockResourceSchema,
+)
+
+
+class WorkbookResourceSchema(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)
+    workbook_name = fields.String(required=True)
+    blocks = fields.Nested(
+        WorkbookBlockResourceSchema(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)
+    created_at = fields.DateTime(required=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/WorkbookBlock/models.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, Boolean, ForeignKey, Integer, Text, String, UniqueConstraint
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+from ..WorkbookBlockComment.models import WorkbookBlockCommentModel
+
+
+class WorkbookBlockModel(Base):
+    __tablename__ = "workbook_blocks"
+
+    id = Column(Integer, primary_key=True)
+    workbook_id = Column(
+        Integer,
+        ForeignKey("workbooks.id"),
+        nullable=False,
+    )
+    block_uid = Column(String(64), nullable=False)
+    sequence_number = Column(Integer, nullable=False)
+    type = Column(String(50), nullable=False)
+    data = Column(Text, nullable=True)
+    is_deleted = Column(Boolean, nullable=True)
+    created_at = Column(DateTime, nullable=False, default=lambda: datetime.utcnow())
+    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(),
+    )
+
+    # These are ORM fields. Don't need to be added in the corresponding migration.
+    # https://docs.sqlalchemy.org/en/14/orm/tutorial.html#building-a-relationship
+    workbook = relationship(
+        "WorkbookModel",
+        back_populates="blocks",
+    )
+
+    comments = relationship(
+        "WorkbookBlockCommentModel",
+        primaryjoin="and_(WorkbookBlockModel.id==WorkbookBlockCommentModel.block_id, "
+                    "or_(WorkbookBlockCommentModel.is_deleted==False, WorkbookBlockCommentModel.is_deleted==None))",
+        order_by=WorkbookBlockCommentModel.sequence_number,
+        back_populates="workbook_block",
+    )
+
+    __table_args__ = (
+        UniqueConstraint('workbook_id', 'block_uid', name='uq_workbook_block_uid'),
+    )

cs_models/resources/WorkbookBlock/schemas.py

@@ -0,0 +1,63 @@
+"""Marshmallow Schema for AssistantCommand."""
+import json
+from marshmallow import Schema, fields
+from ..WorkbookBlockComment.schemas import (
+    WorkbookBlockCommentResourceSchema,
+)
+
+
+class WorkbookBlockDataField(fields.Field):
+    """Field that stores result for the Assistant command."""
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        """
+        In the DB, the `result` field is a text field. We persist
+        data by performing the following:
+
+        AssistantCommandModel(
+            ...
+            result=json.dumps({...}),
+        )
+
+        So here we need to perform the inverse operation (i.e `json.loads(..)`)
+        """
+        if value is None:
+            return None
+        return json.loads(value)
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        """
+        In the DB, the `result` field is a text field. We persist
+        data by performing the following:
+
+
+
+        AssistantCommandModel(
+            ***AssistantCommandResourceSchema().load({
+                ...
+                "result": [{"some_key": 1}, {"some_key": 2}],
+            }),
+        )
+        """
+        if value is None:
+            return None
+        return json.dumps(value)
+
+
+class WorkbookBlockResourceSchema(Schema):
+    """Class for AssistantCommandResource schema"""
+
+    id = fields.Integer(dump_only=True)
+    workbook_id = fields.Integer(required=True)
+    block_uid = fields.String(required=True)
+    sequence_number = fields.Integer(required=True)
+    type = fields.String(required=True)
+    data = WorkbookBlockDataField(required=True, allow_none=True)
+    comments = fields.Nested(
+        WorkbookBlockCommentResourceSchema(exclude=("block_id",)),
+        many=True,
+        dump_only=True,
+    )
+    is_deleted = fields.Boolean(allow_none=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/WorkbookBlockComment/models.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, Boolean, ForeignKey, Integer, Text, String
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+
+
+class WorkbookBlockCommentModel(Base):
+    __tablename__ = "workbook_block_comments"
+
+    id = Column(Integer, primary_key=True)
+    block_id = Column(
+        Integer,
+        ForeignKey("workbook_blocks.id"),
+        nullable=False,
+    )
+    user_id = Column(String(128), nullable=False)
+    sequence_number = Column(Integer, nullable=False)
+    comment = Column(Text, nullable=True)
+    is_deleted = Column(Boolean, nullable=True)
+    created_at = Column(DateTime, nullable=False, default=lambda: datetime.utcnow())
+    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(),
+    )
+
+    # These are ORM fields. Don't need to be added in the corresponding migration.
+    # https://docs.sqlalchemy.org/en/14/orm/tutorial.html#building-a-relationship
+    workbook_block = relationship(
+        "WorkbookBlockModel",
+        back_populates="comments",
+    )

cs_models/resources/WorkbookBlockComment/schemas.py

@@ -0,0 +1,15 @@
+"""Marshmallow Schema for AssistantCommand."""
+from marshmallow import Schema, fields
+
+
+class WorkbookBlockCommentResourceSchema(Schema):
+    """Class for AssistantCommandResource schema"""
+
+    id = fields.Integer(dump_only=True)
+    block_id = fields.Integer(required=True)
+    user_id = fields.String(required=True)
+    sequence_number = fields.Integer(required=True)
+    comment = fields.String(allow_none=True)
+    is_deleted = fields.Boolean(allow_none=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/WorkbookMeta/models.py

@@ -0,0 +1,14 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    ForeignKey,
+)
+from datetime import datetime
+from ...database import Base
+
+
+class WorkbookMetaModel(Base):
+    __tablename__ = 'workbook_meta'
+    workbook_id = Column(Integer, ForeignKey("workbooks.id"), primary_key=True)
+    version = Column(Integer, nullable=False, default=0)

cs_models/resources/WorkbookMeta/schemas.py

@@ -0,0 +1,9 @@
+from marshmallow import (
+    Schema,
+    fields,
+)
+
+
+class WorkbookMetaResourceSchema(Schema):
+    workbook_id = fields.Integer(required=True)
+    version = fields.Integer(required=True)

cs_models/resources/WorkbookWorkflow/models.py

@@ -0,0 +1,39 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    DateTime,
+    Boolean,
+    String,
+    ForeignKey,
+)
+from datetime import datetime
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+from ..WorkbookWorkflowBlock.models import WorkbookWorkflowBlockModel
+
+
+class WorkbookWorkflowModel(Base):
+    __tablename__ = 'workbook_workflows'
+
+    id = Column(Integer, primary_key=True)
+    workbook_id = Column(
+        Integer,
+        ForeignKey("workbooks.id"),
+        nullable=False,
+    )
+    status = Column(String(50), nullable=False)
+    is_completed = Column(Boolean, nullable=True)
+    is_deleted = Column(Boolean, nullable=True)
+    updated_at = Column(
+        DateTime,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+    )
+
+    workflow_blocks = relationship(
+        "WorkbookWorkflowBlockModel",
+        primaryjoin="WorkbookWorkflowModel.id==WorkbookWorkflowBlockModel.workflow_id",
+        order_by=WorkbookWorkflowBlockModel.sequence_number,
+        back_populates="workbook_workflow",
+    )

cs_models/resources/WorkbookWorkflow/schemas.py

@@ -0,0 +1,24 @@
+from marshmallow import (
+    Schema,
+    fields,
+    validate,
+)
+from ..WorkbookWorkflowBlock.schemas import (
+    WorkbookWorkflowBlockResourceSchema,
+)
+
+
+class WorkbookWorkflowResourceSchema(Schema):
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    id = fields.Integer(dump_only=True)
+    workbook_id = fields.Integer(required=True)
+    status = fields.String(required=True)
+    is_completed = fields.Boolean(allow_none=True)
+    is_deleted = fields.Boolean(allow_none=True)
+    workflow_blocks = fields.Nested(
+        WorkbookWorkflowBlockResourceSchema(exclude=("workflow_id",)),
+        many=True,
+        dump_only=True,
+    )
+    updated_at = fields.DateTime(dump_only=True)

cs_models/resources/WorkbookWorkflowBlock/models.py

@@ -0,0 +1,37 @@
+from datetime import datetime
+from sqlalchemy import Column, DateTime, Boolean, ForeignKey, Integer, Text, String
+from sqlalchemy.orm import relationship
+from ...database import Base
+
+
+class WorkbookWorkflowBlockModel(Base):
+    __tablename__ = "workbook_workflow_blocks"
+
+    id = Column(Integer, primary_key=True)
+    workflow_id = Column(
+        Integer,
+        ForeignKey("workbook_workflows.id"),
+        nullable=False,
+    )
+    sequence_number = Column(Integer, nullable=False)
+    block_type = Column(String(50), nullable=False)
+    data = Column(Text, nullable=True)
+    status = Column(String(50), nullable=False)
+    rendered = Column(Boolean, nullable=True)
+    is_completed = Column(Boolean, nullable=True)
+    is_deleted = Column(Boolean, nullable=True)
+    created_at = Column(DateTime, nullable=False, default=lambda: datetime.utcnow())
+    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(),
+    )
+
+    # These are ORM fields. Don't need to be added in the corresponding migration.
+    # https://docs.sqlalchemy.org/en/14/orm/tutorial.html#building-a-relationship
+    workbook_workflow = relationship(
+        "WorkbookWorkflowModel",
+        back_populates="workflow_blocks",
+    )

cs_models/resources/WorkbookWorkflowBlock/schemas.py

@@ -0,0 +1,60 @@
+"""Marshmallow Schema for AssistantCommand."""
+import json
+from marshmallow import Schema, fields
+from ..WorkbookBlockComment.schemas import (
+    WorkbookBlockCommentResourceSchema,
+)
+
+
+class WorkbookWorkflowBlockDataField(fields.Field):
+    """Field that stores result for the Assistant command."""
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        """
+        In the DB, the `result` field is a text field. We persist
+        data by performing the following:
+
+        AssistantCommandModel(
+            ...
+            result=json.dumps({...}),
+        )
+
+        So here we need to perform the inverse operation (i.e `json.loads(..)`)
+        """
+        if value is None:
+            return None
+        return json.loads(value)
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        """
+        In the DB, the `result` field is a text field. We persist
+        data by performing the following:
+
+
+
+        AssistantCommandModel(
+            ***AssistantCommandResourceSchema().load({
+                ...
+                "result": [{"some_key": 1}, {"some_key": 2}],
+            }),
+        )
+        """
+        if value is None:
+            return None
+        return json.dumps(value)
+
+
+class WorkbookWorkflowBlockResourceSchema(Schema):
+    """Class for AssistantCommandResource schema"""
+
+    id = fields.Integer(dump_only=True)
+    workflow_id = fields.Integer(required=True)
+    sequence_number = fields.Integer(required=True)
+    block_type = fields.String(required=True)
+    data = WorkbookWorkflowBlockDataField(required=True, allow_none=True)
+    status = fields.String(required=True)
+    rendered = fields.Boolean(allow_none=True)
+    is_completed = fields.Boolean(allow_none=True)
+    is_deleted = fields.Boolean(allow_none=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)