def populate_db(mysql_config: Dict[str, str], drop_exist: bool = False) -> None: db = MySQLDatabase(**mysql_config) db.bind(MODELS, bind_refs=False, bind_backrefs=False) db.connect() if drop_exist: db.drop_tables(MODELS) db.create_tables(MODELS)
def _load_tracked_guilds(self): """Charger les guilds à tracker et les channels à ignorer""" config = configparser.ConfigParser(allow_no_value=True) p = pathlib.Path(__file__).parent.parent config.read(p / "config.ini") print("Chargement des guilds trackées...") for guild_id_str in config["Tracked"]: guild_id = int(guild_id_str) new_db = MySQLDatabase( f"{guild_id}_db", host=db_host, user=db_user, password=db_password, charset="utf8mb4", autoconnect=False, ) try: new_db.connect() self.tracked_guilds[guild_id] = new_db except OperationalError: print(f"Base de données indisponible pour {guild_id}") continue finally: new_db.close() # Création tables with new_db: with new_db.bind_ctx([Message]): new_db.create_tables([Message]) print(f"Guild {guild_id} trackée") total_tracked = len(self.tracked_guilds) print(total_tracked, "guild(s) trackée(s)") # Ignorer channels print("Chargement des channels ignorés...") for section in config.sections(): try: section_int = int(section) except ValueError: continue if section_int in self.tracked_guilds: for channel_id_str in config[section]: channel_id = int(channel_id_str) self.ignored_channels.append(channel_id) print(f"{channel_id} ignoré")
class Database: TABLES = [ Schedule, ] def __init__(self, type_of_db, secret=None): global db if type_of_db == 'sqlite': self.db = SqliteDatabase('schedule.db') elif type_of_db == 'aws': secret = _get_secret(RDS_SECRET) Database._create(secret) self.db = MySQLDatabase('punch_clock', host=secret['host'], port=secret['port'], user=secret['username'], passwd=secret['password']) self.db.connect() database_proxy.initialize(self.db) self._create_tables() db = self.db def _create_tables(self): self.db.create_tables(self.TABLES) @classmethod def _create(klass, secret): # PeeWee doesn't have a way to create an actual MySQL database, # so we have to rely on another library for that. conn = pymysql.connect(host=secret['host'], user=secret['username'], password=secret['password']) try: conn.cursor().execute('CREATE DATABASE punch_clock') except Exception: # Database probably already exists. pass conn.close() def delete(self): self.db.drop_tables(self.TABLES)
password=mysqlConfig['pwd'], port=mysqlConfig['port']) class BaseModel(Model): class Meta: database = db class Movie(BaseModel): title = CharField() filename = CharField() douban_praise = FloatField() storage_nums = FloatField() storage_unit = CharField() bdid = CharField() doubanid = CharField() down_link = CharField() create_time = DateTimeField(default=datetime.datetime.now) modify_time = DateTimeField(default=datetime.datetime.now) is_down = BooleanField(default=False) class Meta: db_table = 'bdmovie' PrimaryKeyField = 'id' logging.info('mysql 初始化...') db.connect() db.create_tables([Movie])
MovieActor.create(mid=mid, cid=a.id) countries = m['countries'] if countries: for country in countries: c, _ = Country.get_or_create(name=country) MovieCountry.create(mid=mid, cid=c.id) pubdates = m['pubdates'] if pubdates: for pubdate in pubdates: p = Pubdate.create(date=pubdate) MoviePubdate.create(mid=mid, pid=p.id) except IntegrityError: continue except Exception as e: print(m['mid']) raise e # change mysql default encoding to utf8mb4 if __name__ == '__main__': db.create_tables([ Movie, Rating, Aka, Genre, Celebrity, Country, Pubdate, MovieGenre, MovieDirector, MovieWriter, MovieActor, MovieCountry, MoviePubdate ], safe=True) import_data()
return messagebox.showinfo(msg_title, 'Uspesno unet tender: %s' % fields['naziv']) form.reset_data() table.show(Tender._meta.fields, Tender.select()) def __str__(self): return '{};{};{};{};{};{};{};{};{};{};{}'.format( self.idtender, self.naziv, self.tip, self.aktivan, self.datum, self.proc_vred, self.nasa_vred, self.narucilac, self.odluka, self.status, self.napomena) db.connect() db.create_tables([Tender]) root = Tk() root.title('Tender') root.geometry('1000x1000') #root.attributes("-fullscreen", True) #root.maxsize(1000, 1000) # in root content = ttk.Frame(root, padding=(3, 3, 12, 12), width=1000, height=1000) # in content table = Table(content) insert_frame = ttk.Frame(content, borderwidth=5) #,width = 100, height = 300) # in insert button_frame = ttk.Frame(insert_frame, borderwidth=2) #, width = 100, height = 200) form_frame = ttk.Frame(insert_frame, borderwidth=2)
post = BlogPost.create(title=md_info['title'], category=cate, slug=md_info['slug'], content=md_info['content']) BlogPostLabel.add_post_label(md_info['tags'], post) def get_files(root_path): files = os.listdir(root_path) print(files) for file_name in files: _, suffix = os.path.splitext(file_name) if suffix == '.md': md_file_path = os.path.join(root_path, file_name) md_info = check_md_format(md_file_path) if md_info: print(md_info['title']) convert_md_2_post(md_info) if __name__ == '__main__': mysqldb.create_tables([BlogPostLabel, BlogPost, BlogPostCategory], safe=True) t = BlogPostLabel.delete() t.execute() t = BlogPost.delete() t.execute() t = BlogPostCategory.delete() t.execute() get_files(md_path)
def main(): database = MySQLDatabase(**settings['db']) database.create_tables([ Note, ]) database.close()
import sys from config import load_config from peewee import MySQLDatabase from models import Product config = load_config() db = MySQLDatabase(**config["DB_CONFIG"]) try: db.create_tables([Product]) except Exception as e: pass
from flask_cors import CORS from peewee import MySQLDatabase import config app = Flask(__name__) cors = CORS(app, resources={r"/*": {"origins": "*"}}) db = MySQLDatabase(database=config.DB_NAME, host=config.DB_LOCATION, port=config.DB_PORT, user=config.DB_USERNAME, passwd=config.DB_PASSWORD) from app.model.color import Color from app.model.user import User from app.model.professor import Professor from app.model.course import Course from app.model.questions import Question from app.model.answer import Answer db.create_tables([Color, User, Course, Professor, Question, Answer], safe=True) from app.controller.question import question app.register_blueprint(question) from app.controller.user import user app.register_blueprint(user) from app.controller.course import course app.register_blueprint(course)
indexes = ((('did', ), True), ) ALL_TABLES = [ Profile, Equipment, EditHistory, ComputerDetail, WorkOrder, OrderHistory, ItConfig, CaptchaMeta, EmailHistory, PatrolMeta, PatrolDetail, DepartmentContact ] if __name__ == '__main__': # MySQL_DB.drop_tables([WorkOrder, OrderHistory]) # MySQL_DB.create_tables([WorkOrder, OrderHistory]) # MySQL_DB.drop_tables([ItConfig]) # MySQL_DB.create_tables([ItConfig]) # ItConfig.insert({ItConfig.key: "sendSms", ItConfig.value: "0"}).execute() # ItConfig.insert({ItConfig.key: "sendEmail", ItConfig.value: "0"}).execute() # MySQL_DB.drop_tables([OrderHistory, WorkOrder, CaptchaMeta, EmailHistory, PatrolMeta, PatrolDetail]) # MySQL_DB.create_tables([OrderHistory, WorkOrder, CaptchaMeta, EmailHistory, PatrolMeta, PatrolDetail]) # MySQL_DB.drop_tables([PatrolMeta, PatrolDetail, EmailHistory, CaptchaMeta]) # MySQL_DB.create_tables([PatrolMeta, PatrolDetail, EmailHistory, CaptchaMeta]) # MySQL_DB.drop_tables([ComputerDetail]) # MySQL_DB.create_tables([ComputerDetail]) _tables = [ # DepartmentContact, PatrolMeta, PatrolDetail ] MySQL_DB.drop_tables(_tables) MySQL_DB.create_tables(_tables) pass
import sys from config import load_config from peewee import MySQLDatabase from models import Activity config = load_config() db = MySQLDatabase(**config["DB_CONFIG"]) try: db.create_tables([Activity]) except Exception as e: pass
Id = PrimaryKeyField(null=False) customer = ForeignKeyField(Customer, related_name='customer_id') number = IntegerField(unique=True) type = CharField(max_length=255) balance = FloatField(default=0.00) class Transactions(BaseModel): Id = PrimaryKeyField(null=False) account_details = ForeignKeyField(Account, related_name='account_id') date = DateField(default=str(date.today())) type = CharField(max_length=255) amount = FloatField() mysql_db.create_tables([Bank, Customer, Account, Transactions]) def create_lenas_bank(): bank = Bank.get_or_none(number=bank_number) if bank is None: Bank.create(name=bank_name, address=bank_address, number=bank_number) def find_customer(ssn): try: customer_by_ssn = Customer.get(Customer.ssn == ssn) except Customer.DoesNotExist: print("Customer Not Found") return None return customer_by_ssn
if config.DB_TYPE == 'sqlite': db = SqliteDatabase(config.DB_NAME) class JsonModel(Model): def jsonify(self): r = {} for k in self._data.keys(): try: r[k] = str(getattr(self, k)) except: r[k] = json.dumps(getattr(self, k)) return str(r) class User(JsonModel): class Meta: database = db name = CharField(unique = True) token = CharField() last_sync = DateTimeField() class Item(JsonModel): class Meta: database = db pocket_id = CharField(unique = True) username = CharField(index = True) url = CharField() title = CharField() time_added = DateTimeField() db.create_tables([User, Item], safe = True)
charset='utf8') class btc_values(Model): code = CharField() price = FloatField() updated_at = DateTimeField(default=dt.datetime.now) class Meta: database = db class btc_aggs(Model): data = TextField() tag = CharField() updated_at = DateTimeField(default=dt.datetime.now) class Meta: database = db if __name__ == '__main__': try: db.connect() db.create_tables([btc_values, btc_aggs], safe=True) except Exception as e: print('%s\n%s' % (e, traceback.print_exc())) finally: if db: db.close()
from peewee import MySQLDatabase, SqliteDatabase from playhouse.reflection import Introspector, print_model, print_table_sql # step 1: generate a Model class for each table found in the source SQLite database sqlite_db = SqliteDatabase("prodigy.db") introspector = Introspector.from_database(sqlite_db) models = introspector.generate_models() # print a user-friendly description of the generated models and their SQL for model in models.keys(): print_model(models[model]) print_table_sql(models[model]) # step 2: create the tables using their model classes mysql_db = MySQLDatabase( user="******", password="******", host="host name", port=3306, database="database name", ssl={"ssl": { "ssl_ca": "certificate.crt.pem" }}, ) mysql_db.connect() mysql_db.create_tables(list(models.values())) mysql_db.get_tables() mysql_db.close()
# 定义Person class Person(BaseModel): name = CharField() birthday = DateField() is_relative = BooleanField() class Meta: database = database # 创建表 # Person.create_table() # 创建表也可以这样, 可以创建多个 database.create_tables([Person]) if __name__ == '__main__': # 增 p = Person(name='ligalfogn', birthday=datetime.date(1999, 12, 20), is_relative=True) p.save() # 删除姓名为perter的数据 # Person.delete().where(Person.name == 'perter').execute() # 返回成功处理的行数 # # 已经实例化的数据, 使用delete_instance # p = Person(name='liuchungui', birthday=datetime.date(1999, 12, 20), is_relative=False) # p.id = 2 # p.save()
from peewee import MySQLDatabase from ForumApp.main_app.settings import settings from ForumApp.apps.users.models import User from ForumApp.apps.community.models import CommunityGroup, CommunityGroupMember database = MySQLDatabase(**settings["db"]) database.create_tables([User]) database.create_tables([CommunityGroup, CommunityGroupMember])
name="admin", pwd=hashlib.md5('admin').hexdigest(), ) User.create(**data) # 创建交叉表 for k in d_cata.keys(): for k1 in d_source.keys(): c = Cata.select().where(Cata.cata == k, Cata.source == k1) if not c: d_ = dict( cata=k, source=k1, ) Cata.create(**d_) def drop_table(): from model.user import User from model.url import URL from model.cata import Cata from model.mod_log import ModLog # db.drop_tables([User, URL, Cata, ModLog]) if __name__ == '__main__': # drop_table() # init_db() from model.cata import CataHistoryData db.create_tables([CataHistoryData])
import score if __name__ == '__main__': Config.load('../config/server.json') database = MySQLDatabase(Config.mysql_db, autocommit=False, **{'threadlocals': True, 'host': Config.mysql_host, 'password': Config.mysql_pwd, 'port': Config.mysql_port, 'user': Config.mysql_user}) # Connect to our database. database.begin() # Create the tables. database.create_tables([ # grade.Grade, major.Major, student_info.StudentInfo, student_behavior.StudentBehavior, student_punish.StudentPunish, student_relative.StudentRelative, student_resume.StudentResume, student_reward.StudentReward, course.Course, term.Term, score.Score ], safe=True) database.commit()
from peewee import Model, MySQLDatabase, CharField, BigIntegerField, IntegerField from config import config cfg = config['db'] db = MySQLDatabase(cfg['dbname'], host=cfg['host'], port=cfg['port'], user=cfg['user'], passwd=cfg['password']) class Order(Model): class Meta: database = db table_name = "orders" apptransid = CharField(primary_key=True) zptransid = CharField() description = CharField() amount = BigIntegerField() timestamp = BigIntegerField() channel = IntegerField() db.connect() db.create_tables([Order])
user=settings.USER, password=settings.PASSWORD) database.connect() class BaseModel(Model): class Meta: database = database class Category(BaseModel): name = TextField() class Torrent(BaseModel): category = ForeignKeyField(Category) title = TextField() size = BigIntegerField() magnet = TextField() hash = TextField() nfo = TextField() created = DateTimeField() class Removed(BaseModel): pass if __name__ == '__main__': database.create_tables([Removed])
def init_db_command(): database = MySQLDatabase('poll', **get_db()) database.create_tables([Poll, Choice, VoteCast]) click.echo("Initialized the database.")
r = {} for k in self._data.keys(): try: r[k] = str(getattr(self, k)) except: r[k] = json.dumps(getattr(self, k)) return str(r) class User(JsonModel): class Meta: database = db name = CharField(unique=True) token = CharField() last_sync = DateTimeField() class Item(JsonModel): class Meta: database = db pocket_id = CharField(unique=True) username = CharField(index=True) url = CharField() title = CharField() time_added = DateTimeField() db.create_tables([User, Item], safe=True)