def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement(name="total", coltype=Integer(), value=self.total_score(), comment="Total score (/{})".format( self.MAX_SCORE_MAIN)), SummaryElement(name="n_core", coltype=Integer(), value=self.n_core(), comment="Number of core symptoms"), SummaryElement(name="n_other", coltype=Integer(), value=self.n_other(), comment="Number of other symptoms"), SummaryElement(name="n_total", coltype=Integer(), value=self.n_total(), comment="Total number of symptoms"), SummaryElement(name="is_mds", coltype=Boolean(), value=self.is_mds(), comment="PHQ9 major depressive syndrome?"), SummaryElement(name="is_ods", coltype=Boolean(), value=self.is_ods(), comment="PHQ9 other depressive syndrome?"), SummaryElement(name="severity", coltype=SummaryCategoryColType, value=self.severity(req), comment="PHQ9 depression severity"), ]
class AccountDbo(EntityManager.get_base()): """ The Account Database Object """ __tablename__ = 'accounts' id = Column(Integer, primary_key=True) name = Column(String(50), unique=True) description = Column(String(250)) transactions = relationship('TransactionDbo', backref='account') color = Column(String(50)) notify = Column(Boolean()) active = Column(Boolean()) status = relationship('StatusDbo', backref='account') def __init__(self, id=None, name=None, description=None, color=None, notify=None, active=None): """Constructor""" self.id = id self.name = name self.description = description self.color = color self.notify = notify self.active = active def __repr__(self): """String representation""" return '<AccountDbo %r, %r>' % (self.id, self.name)
class TicketMessage(ModifiedMixin, PaginationMixin, DeclarativeBase): __tablename__ = 'ticket_message' id = Field(Integer(), primary_key=True) ticket_id = Field(Integer(), ForeignKey(Ticket.id)) member_id = Field(Integer(), ForeignKey('member.id')) text = Field(Unicode()) is_answer = Field(Boolean(), default=False) _attachment = Field(TicketAttachment.as_mutable(JSON), nullable=True, protected=True) ticket = relationship(Ticket, lazy='select', uselist=False, protected=True) @property def attachment(self): return self._attachment.locate() if self._attachment else None @attachment.setter def attachment(self, value): if value is not None: self._attachment = TicketAttachment.create_from(value) else: self._attachment = None def to_dict(self): result = super().to_dict() result['attachment'] = self.attachment return result
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement(name="meets_criteria", coltype=Boolean(), value=self.meets_criteria(), comment="Meets criteria for schizotypal disorder?"), ]
def default_attr(self,comp_cls, results_table = None): '''we make the default entries for a components primary table''' table_abrv = self.component_table_abrv if issubclass(comp_cls, Analysis): table_abrv = self.analysis_table_abrv name = comp_cls.__name__.lower() #TODO: Add mapping __init__ method default_attr = {'__tablename__': f'{table_abrv}{name}' , #'id': Column(Integer, primary_key=True), '__table_args__': self.default_args, '__abstract__': False, '_mapped_component': comp_cls, 'attr_store': None } if results_table is not None: tbl_name = f'{results_table}_{table_abrv}{name}' backref_name = f'db_comp_{name}' root_obj,_ = self.mapped_tables[results_table] default_attr['__tablename__'] = f'{results_table}_{table_abrv}{name}' default_attr['result_id'] = Column(Integer, ForeignKey(f'{results_table}.id') ,primary_key=True) default_attr['analysis'] = relationship(root_obj.__name__,backref = backref(backref_name,lazy='noload')) else: #its an analysis default_attr['created'] = Column(DateTime, server_default=func.now()) default_attr['active'] = Column(Boolean(), server_default = 't') default_attr['run_id'] = Column(String(36)) #corresponds to uuid set in analysis default_attr['id']: Column(Integer, primary_key=True) #default_attr['components'] = relationship(TableBase, back_populates= "analysis") return default_attr
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement(name="depression_risk", coltype=Boolean(), value=self.has_depression_risk(), comment="Has depression or at risk of depression"), ]
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement(name="n_core", coltype=Integer(), value=self.n_core(), comment="Number of core diagnostic symptoms (/3)"), SummaryElement( name="n_additional", coltype=Integer(), value=self.n_additional(), comment="Number of additional diagnostic symptoms (/7)"), SummaryElement( name="n_total", coltype=Integer(), value=self.n_total(), comment="Total number of diagnostic symptoms (/10)"), SummaryElement(name="n_somatic", coltype=Integer(), value=self.n_somatic(), comment="Number of somatic syndrome symptoms (/8)"), SummaryElement(name="category", coltype=SummaryCategoryColType, value=self.get_full_description(req), comment="Diagnostic category"), SummaryElement(name="psychosis_or_stupor", coltype=Boolean(), value=self.is_psychotic_or_stupor(), comment="Psychotic symptoms or stupor present?"), ]
class ContentType(Base): __tablename__ = "content_type" id = Column(BigInteger, primary_key=True, autoincrement=True) name = Column(String) color = Column(String(7)) active = Column(Boolean(), default=True, nullable=False) deleted = Column(Boolean(), default=False, nullable=False) @staticmethod def get_by_id(id): return ContentType.query.filter( ContentType.id == id, ContentType.deleted.is_(False)).one_or_none()
class HospitalToken(ModelsBase): __tablename__ = 'hospital_tokens' id = Column(UUID(as_uuid=True), primary_key=True,default=uuid.uuid4) hospital_id = Column(UUID(as_uuid=True),nullable=False) token = Column(String(),nullable=False) is_valid = Column(Boolean(),default=True)
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement( name="meets_general_criteria", coltype=Boolean(), value=self.has_pd(), comment="Meets general criteria for personality disorder?"), SummaryElement(name="paranoid_pd", coltype=Boolean(), value=self.has_paranoid_pd(), comment="Meets criteria for paranoid PD?"), SummaryElement(name="schizoid_pd", coltype=Boolean(), value=self.has_schizoid_pd(), comment="Meets criteria for schizoid PD?"), SummaryElement(name="dissocial_pd", coltype=Boolean(), value=self.has_dissocial_pd(), comment="Meets criteria for dissocial PD?"), SummaryElement( name="eupd_i", coltype=Boolean(), value=self.has_eupd_i(), comment="Meets criteria for EUPD (impulsive type)?"), SummaryElement( name="eupd_b", coltype=Boolean(), value=self.has_eupd_b(), comment="Meets criteria for EUPD (borderline type)?"), SummaryElement(name="histrionic_pd", coltype=Boolean(), value=self.has_histrionic_pd(), comment="Meets criteria for histrionic PD?"), SummaryElement(name="anankastic_pd", coltype=Boolean(), value=self.has_anankastic_pd(), comment="Meets criteria for anankastic PD?"), SummaryElement(name="anxious_pd", coltype=Boolean(), value=self.has_anxious_pd(), comment="Meets criteria for anxious PD?"), SummaryElement(name="dependent_pd", coltype=Boolean(), value=self.has_dependent_pd(), comment="Meets criteria for dependent PD?"), ]
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement( name="meets_criteria", coltype=Boolean(), value=self.meets_criteria(), comment="Meets criteria for a mixed affective episode?"), ]
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement( name="meets_general_criteria", coltype=Boolean(), value=self.meets_general_criteria(), comment="Meets general criteria for paranoid/hebephrenic/" "catatonic/undifferentiated schizophrenia " "(F20.0-F20.3)?"), ]
class Service(ModelsBase): __tablename__ = 'services' id = Column(UUID(as_uuid=True), primary_key=True,default=uuid.uuid4) hospital_id = Column(UUID(as_uuid=True),nullable=False) name = Column(String(),nullable=False) description = Column(String(),nullable=False) is_free = Column(Boolean(),nullable=False) cost = Column(String(),nullable=False)
class MappedItem(ReportBase): __abstract__ = True _mapped_component = None id = Column( Integer, primary_key = True) tablename = Column(String(DEFAULT_STRING_LENGTH)) attrtable = Column(String(DEFAULT_STRING_LENGTH)) classname = Column(String(DEFAULT_STRING_LENGTH)) mro_inheritance = Column(String(1200)) active = Column(Boolean(), default=True ) def __init__(self,tablerep, mapped_class): self.classname = mapped_class.__name__ self.tablename = tablerep.__tablename__ if issubclass(mapped_class,Analysis): self.attrtable = f'anly_attr_{tablerep.__tablename__}' else: self.attrtable = tablerep.__tablename__.replace('tbl','attr') self._mapped_component = mapped_class distinct =mapped_class.mro() if mapped_class in distinct: distinct.remove(mapped_class) comp_inx = distinct.index(Component) self.mro_inheritance = '.'.join([cls.__name__ for cls in distinct[0:comp_inx+1]]) @classmethod def db_columns(cls): if '__table__' in cls.__dict__ and cls.__table__ is not None: return set(list(cls.__table__.c.keys())) @classmethod def all_fields(cls): all_table_fields = set([ attr.lower() for attr in cls._mapped_component.cls_all_property_labels() ]) all_attr_fields = set([ attr.lower() for attr in cls._mapped_component.cls_all_attrs_fields().keys() ]) all_fields = set.union(all_table_fields,all_attr_fields) return set(list(all_fields)) @classmethod def dynamic_columns(cls): if cls._mapped_component is None: return [] return set.difference(cls.all_fields(), cls.db_columns()) @classmethod def tablenames(cls,db): #rr = ResultsRegistry() with db.session_scope() as sesh: results = list( sesh.query(cls.tablename).all()) return flatten(results)
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement(name="category", coltype=SummaryCategoryColType, value=self.get_description(req), comment="Diagnostic category"), SummaryElement(name="psychotic_symptoms", coltype=Boolean(), value=self.psychosis_present(), comment="Psychotic symptoms present?"), ]
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement(name="total", coltype=Integer(), value=self.total_score(), comment="Total score (/{})".format(self.MAX_SCORE)), SummaryElement(name="positive", coltype=Boolean(), value=self.is_positive(), comment="FAST positive?"), ]
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement(name="total", coltype=Integer(), value=self.total_score(), comment="Total score (/{})".format(self.MAX_SCORE)), SummaryElement( name="exceeds_threshold", coltype=Boolean(), value=self.exceeds_ross_threshold(), comment="Exceeds Ross threshold (total score >= {})".format( self.ROSS_THRESHOLD)), ]
def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: return self.standard_task_summary_fields() + [ SummaryElement( name="total", coltype=Integer(), value=self.total_score(), comment=f"Total score ({self.MIN_SCORE}-{self.MAX_SCORE})", ), SummaryElement( name="num_symptomatic", coltype=Integer(), value=self.num_symptomatic(), comment="Total number of symptoms considered symptomatic " "(meaning scoring 2 or more)", ), SummaryElement( name="num_symptomatic_B", coltype=Integer(), value=self.num_symptomatic_b(), comment="Number of group B symptoms considered symptomatic " "(meaning scoring 2 or more)", ), SummaryElement( name="num_symptomatic_C", coltype=Integer(), value=self.num_symptomatic_c(), comment="Number of group C symptoms considered symptomatic " "(meaning scoring 2 or more)", ), SummaryElement( name="num_symptomatic_D", coltype=Integer(), value=self.num_symptomatic_d(), comment="Number of group D symptoms considered symptomatic " "(meaning scoring 2 or more)", ), SummaryElement( name="num_symptomatic_E", coltype=Integer(), value=self.num_symptomatic_e(), comment="Number of group D symptoms considered symptomatic " "(meaning scoring 2 or more)", ), SummaryElement( name="ptsd", coltype=Boolean(), value=self.ptsd(), comment="Provisionally meets DSM-5 criteria for PTSD", ), ]
def test_to_yaml_type(self): """Tests the utils.to_yaml_type function""" from sqlalchemy.sql.sqltypes import Boolean, Integer, Float, String, \ Date, Time, DateTime, _Binary self.assertEqual('str', utils.to_yaml_type(None)) self.assertEqual('bool', utils.to_yaml_type(Boolean())) self.assertEqual('int', utils.to_yaml_type(Integer())) self.assertEqual('float', utils.to_yaml_type(Float())) self.assertEqual('str', utils.to_yaml_type(String())) self.assertEqual('str', utils.to_yaml_type(Date())) self.assertEqual('str', utils.to_yaml_type(Time())) self.assertEqual('str', utils.to_yaml_type(DateTime())) self.assertEqual('binary', utils.to_yaml_type(_Binary()))
class User(db.Model): __tablename__ = "users" id = Column(Integer, primary_key=True, autoincrement=True) username = Column(String(128), nullable=False) email = Column(String(128), nullable=False) password = Column(String(255), nullable=False) active = Column(Boolean(), default=True, nullable=False) created_date = Column(DateTime, default=func.now(), nullable=False) def __init__(self, username="", email="", password=""): self.username = username self.email = email self.password = bcrypt.generate_password_hash( password, current_app.config["BCRYPT_LOG_ROUNDS"] ).decode() def to_json(self): return { "id": self.id, "username": self.username, "email": self.email, "active": self.active, } def encode_token(self, user_id, token_type): if token_type == "access": seconds = current_app.config.get("ACCESS_TOKEN_EXPIRATION") else: seconds = current_app.config.get("REFRESH_TOKEN_EXPIRATION") # expiration, issued at, subject payload = { "exp": datetime.datetime.utcnow() + datetime.timedelta(days=0, seconds=seconds), "iat": datetime.datetime.utcnow(), "sub": user_id, } return jwt.encode( payload, current_app.config.get("SECRET_KEY"), algorithm="HS256" ) @staticmethod def decode_token(token): payload = jwt.decode(token, current_app.config.get("SECRET_KEY")) return payload.get("sub")
class BankingId(TimestampMixin, DeclarativeBase): __tablename__ = 'banking_id' id = Field(Integer(), primary_key=True) client_id = Field(Integer(), ForeignKey('client.id')) is_verified = Field(Boolean(), default=False) error = Field(Unicode(), nullable=True) client = relationship('Client', lazy='select', protected=True) type = Field(Enum('bank_account', 'bank_card', name='banking_id_type')) __mapper_args__ = { 'polymorphic_identity': __tablename__, 'polymorphic_on': type }
def factory( *, string_types: Strategy[TypeEngine] = strings_factory(), binary_string_types: Strategy[TypeEngine] = binary_strings_factory(), enum_types: Strategy[TypeEngine] = enums_factory(), primary_keys_types: Strategy[TypeEngine] = primary_keys_factory() ) -> Strategy[TypeEngine]: extra_types = [ Float(asdecimal=True), Boolean(), Date(), DateTime(), Interval(), Time() ] return strategies.one_of(string_types, binary_string_types, enum_types, primary_keys_types, strategies.sampled_from(extra_types))
class Worker(Base): __tablename__ = "worker" id = Column(BigInteger, primary_key=True, autoincrement=True) ean13 = Column(BigInteger, unique=True, nullable=False) login = Column(String, unique=True) password = Column(String, nullable=False) name = Column(String) surname = Column(String) middle_name = Column(String) type = Column(EnumField(WorkerType), nullable=False) deleted = Column(Boolean(), default=False, nullable=False) @staticmethod def get_by_code(code): return Worker.query.filter(Worker.ean13 == code, Worker.deleted.is_(False)).one_or_none() def is_password_valid(self, password): return str(password) == str(self.password) @staticmethod def get_by_code_or_not_found(code): worker = Worker.get_by_code(code) if worker is None: raise HTTPNotFound( description={ "error_code": 201, "error_message": "Рабочий с таким кодом не найден" }) return worker @staticmethod def generate_worker_password(): prefix = '299' body = randint(000000000, 999999999) code = prefix + str(body) checksum = calculate_checksum(code) return code + str(checksum)
class Tweet(Base): """[define tweet data table] Args: Base ([class]): [base class] """ __tablename__ = "tweet_data" id = Column(Integer, primary_key=True, autoincrement=True) user_name = Column(String(64)) user_id = Column(String(64)) following = Column(Integer(), default=0) followers = Column(Integer(), default=0) date = Column(String(64)) content = Column(Text) reply = Column(Integer(), default=0) retweet = Column(Integer(), default=0) like = Column(Integer(), default=0) modify_tag = Column(Boolean(), default=False) def __init__(self, user_name, user_id, date, content, reply=0, retweet=0, like=0, following=0, followers=0, modify_tag=False): self.user_name = user_name self.user_id = user_id self.following = following self.followers = followers self.date = date self.content = content self.reply = reply self.retweet = retweet self.like = like self.modify_tag = modify_tag
metadata = MetaData() userinfo = Table( 'userinfo', metadata, Column('user_id', String, primary_key=True), Column('character_id', Integer, ForeignKey('character_id')), Column('fullname', String(50)), Column('nickname', String(16)), Column('email', String(50)), ) characterinfo = Table('characterinfo', metadata, Column('user_id', String, ForeignKey('user_id')), Column('character_id', Integer, primary_key=True), Column('is_in_roda', Boolean(1)), Column('is_conscious', Boolean(1)), Column('is_alive', Boolean(1)), Column('char_name', String(25)), Column('exp_total', Integer(7)), Column('exp_current ', Integer(7)), Column('gender_ident', String(15)), Column('size_c', Integer(3)), Column('mestre', String(25)), Column('capoeira_school', String(25)), Column('corda', Integer(2)), Column('predction_ponts', Integer(3)), Column('malicia', Integer(3)), Column('spirit', Integer(3)), Column('swag', Integer(3)), Column('intelegence', Integer(3)), Column('strength', Integer(3)),