Sqlalchemy creating MySQL_ Table

python Call the third-party package frequently used by the database
Here is how to create a database

First of all, the key is declarative_base, Suppose the declarative base class .
Representation This is a class defined by myself , You can write some methods according to the requirements , After data model inheritance , Continuous development does not need to write redundant code repeatedly .
to_dict In order to replace an object with a dictionary , That is, data encapsulation

table_args Is table configuration , The engine can be configured , code , Table annotation

Refer to the official website ： https://www.osgeo.cn/sqlalchemy/orm/declarative_tables.html

from datetime import datetime, date,time

from sqlalchemy import Column, VARCHAR, BIGINT, DATETIME, func
from sqlalchemy.orm import declarative_base
from sqlalchemy import inspect

from etc.common import DATETIME_FORMAT, DATE_FORMAT, TIME_FORMAT
from etc.database import DATABASE_AUTH_CONF_ORIGIN_STR


class Representation(object):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def __repr__(self):
        return str(self.to_dict())

    def __str__(self):
        return str(self.to_dict())

    def to_dict(self) -> dict:
        """  turn Python Dictionaries  :return: Python Dictionary type database data  """
        dict_ = self.__dict__.copy()
        if '_sa_instance_state' in dict_:
            del dict_['_sa_instance_state']
        if '_updatable' in dict_:
            del dict_['_updatable']

        dict_ = self.to_format(dict_)
        return dict_

    def to_format(self, dict_: dict):
        """  Convert the time format into  :param dict_:  A dictionary for time conversion  :return:  Dictionaries  """
        for item in dict_:
            if isinstance(dict_[item], datetime):
                dict_[item] = dict_[item].strftime(DATETIME_FORMAT)
            elif isinstance(dict_[item], date):
                dict_[item] = dict_[item].strftime(DATE_FORMAT)
            elif isinstance(dict_[item], time):
                dict_[item] = dict_[item].strftime(TIME_FORMAT)

        return dict_

    @classmethod
    def get_attr(cls):
        """ :return: """
        key_values = [(k, v) for k, v in inspect(cls).c.items()]
        return [{
    "label": item[0], "prop": item[1].comment} for item in key_values]


Base = declarative_base()


class User(Base, Representation):
    __tablename__ = 'user'
    __table_args__ = {
    
        'mysql_engine': 'InnoDB',
        'mysql_charset': 'utf8mb4',
        'mysql_comment': ' Test user table '
    }

    id = Column(BIGINT, name="id", comment=" Primary key ", primary_key=True)
    name = Column(VARCHAR(32), nullable=False, name="name", comment=" full name ")
    update_time = Column(DATETIME, default=func.now(), name="update_time", comment=" Update time , Default present time ")


if __name__ == '__main__':
    from sqlalchemy import create_engine
    engine = create_engine(DATABASE_AUTH_CONF_ORIGIN_STR)
    Base.metadata.create_all(engine)