def prepare_db():
from playhouse.sqliteq import SqliteQueueDatabase
from cozy.db.artwork_cache import ArtworkCache
from cozy.db.book import Book
from cozy.db.offline_cache import OfflineCache
from cozy.db.settings import Settings
from cozy.db.storage import Storage
from cozy.db.storage_blacklist import StorageBlackList
from cozy.db.track import Track
models = [
Track, Book, Settings, ArtworkCache, Storage, StorageBlackList,
OfflineCache
]
print("Setup database...")
db_path = '/tmp/cozy_test.db'
test_db = SqliteQueueDatabase(db_path, pragmas=[('journal_mode', 'wal')])
test_db.bind(models, bind_refs=False, bind_backrefs=False)
test_db.connect()
test_db.create_tables(models)
test_db.stop()
test_db.start()
return db_path, models, test_db
def create_model(file_path, file_name):
db = SqliteQueueDatabase(file_path + file_name + '.db')
class BaseModel(Model):
class Meta:
database = db
class Message(BaseModel):
message_id = IntegerField()
message_text = TextField()
modified_text = TextField(null=True)
posted = BooleanField(default=False)
message_type = TextField()
file_name = CharField(null=True)
file_size = IntegerField(null=True)
db.connect()
db.create_tables([Message])
return Message
# so if we want to change anything on the fly
# we don't have to edit like 7 programs.
# this is from: with help from: cordain99 etc
# status = 0: name entered 1: name placed 2:gcode ready 3: burnt to board
from peewee import *
from playhouse.sqliteq import SqliteQueueDatabase
from bts import settings
dbFile = settings.dataBaseFile
db = SqliteQueueDatabase(dbFile)
entered = settings.nameEntered
#db.atomic('IMMEDIATE')
class Sub(Model):
status = IntegerField(default=entered)
userName = CharField()
fontSize = IntegerField(default=0)
positionX = IntegerField(default=0)
positionY = IntegerField(default=0)
gCode = CharField(default="")
entryTime = DateTimeField()
class Meta:
database = db
db.create_tables([Sub])
description=chat.description)
return chat_db
class Reminder(BaseModel):
date_time = DateTimeField(default=DT.datetime.now)
message_id = IntegerField()
command = TextField()
finish_time = DateTimeField(default=DT.datetime.now)
is_sent = BooleanField(default=False)
user = ForeignKeyField(User, backref='reminders')
chat = ForeignKeyField(Chat, backref='reminders')
db.connect()
db.create_tables([User, Chat, Reminder])
if __name__ == '__main__':
print('Total users:', User.select().count())
print('Total chats:', Chat.select().count())
assert User.get_from(None) is None
assert Chat.get_from(None) is None
print()
first_user = User.select().first()
print('First user:'******'First chat:', first_chat)
game_by_genres[k] = sorted(set(v))
return game_by_genres
class Meta:
indexes = ((("name", "site"), True), )
def __repr__(self):
return f'Dump(name={self.name!r}, site={self.site!r}, genres={self.genres})'
def __str__(self):
return repr(self)
db.connect()
db.create_tables([Dump])
if __name__ == '__main__':
print('Total:', Dump.select().count())
genres = Dump.get_all_genres()
print(f'Genres ({len(genres)}): {genres}')
games = Dump.get_all_games()
print(f'Games ({len(games)}): {games}')
sites = Dump.get_all_sites()
print(f'Sites ({len(sites)}): {sites}')
print()
@classmethod
def add(cls, user_id: int, chat_id: int, book_id: str, from_page: str,
page: str) -> 'VisitedPage':
page = join_page(from_page, page)
return cls.create(
user_id=user_id,
chat_id=chat_id,
book_id=book_id,
page=page,
)
db.connect()
db.create_tables([VisitedPage])
if __name__ == '__main__':
test_user_id = -1
test_chat_id = -1
test_book_id = '123'
test_page = '999'
ok = VisitedPage.has(test_user_id, test_chat_id, test_book_id, test_page)
print(ok)
assert ok is False
visited_page = VisitedPage.add(test_user_id, test_chat_id, test_book_id,
test_page)
ok = VisitedPage.has(test_user_id, test_chat_id, test_book_id, test_page)
order_by: Field = None,
) -> List['User']:
if not order_by:
order_by = cls.date_time.desc()
return cls.paginating(page=page,
items_per_page=items_per_page,
order_by=order_by)
def get_short_title(self) -> str:
date_time_str = get_date_time_str(self.date_time)
return f'[{date_time_str}, {self.func_name}, {self.exception_class}] {self.error_text!r}'
db.connect()
db.create_tables([User, Chat, Quote, Comics, Request, Settings])
db_error.connect()
db_error.create_tables([Error])
if __name__ == '__main__':
BaseModel.print_count_of_tables()
print()
from config import ADMIN_USERNAME
admin: User = User.get(User.username == ADMIN_USERNAME[1:])
print('Admin:', admin)
# print(*Quote.get_user_unique_random(admin, limit=5), sep='\n')
# print(*Quote.get_user_unique_random(admin, years=[2004], limit=5), sep='\n')
# print(Quote.get_number_of_unique_quotes(admin))
# print(admin.get_years_of_quotes())
("journal_mode", "wal"),
("ignore_check_constraints", 0),
("synchronous", "normal"),
],
)
class Users(peewee.Model):
id = peewee.IntegerField(primary_key=True,
constraints=[peewee.Check(constraint="id > 0")])
first_name = peewee.CharField(max_length=255)
last_name = peewee.CharField(max_length=255, default=None, null=True)
username = peewee.CharField(max_length=32, default=None, null=True)
timestamp = peewee.DateTimeField(default=datetime.datetime.utcnow,
null=False)
# prevent forwards to master
is_blocked = peewee.BooleanField(
default=False,
null=False,
constraints=[peewee.Check(constraint="is_blocked BETWEEN 0 AND 1")],
)
class Meta:
database = DB
DB.create_tables(models=[Users], safe=True)
DB.close()
DB.connect()