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)
