class PWDatabase: __proxy = None @staticmethod def DBProxy(): if not PWDatabase.__proxy: PWDatabase.__proxy = Proxy() return PWDatabase.__proxy _db = None def __init__(self, path): try: self._db = SqliteDatabase(path, check_same_thread=False) PWDatabase.DBProxy().initialize(self._db) self.startup() except Exception as e: logger.error("database file does not exist, or incorrect permissions") def close(self): self._db.close() self._db = None def startup(self): self._db.connect() @property def DB(self): return self._db
def wrapper(*args, **kwargs): language = kwargs.get("language", "en") path = kwargs.pop("database_path", None) if not path: path = CONTENT_DATABASE_PATH.format( channel=kwargs.get("channel", CHANNEL), language=language ) db = SqliteDatabase(path, pragmas=settings.CONTENT_DB_SQLITE_PRAGMAS) kwargs["db"] = db db.connect() # This should contain all models in the database to make them available to the wrapped function with Using(db, [Item, AssessmentItem]): try: output = function(*args, **kwargs) except DoesNotExist: output = None except OperationalError: logging.error("No content database file found") raise db.close() return output
def create_relations(): # запоминаем все используемые в бд модели models = [User, RunSettings] # чистим базу данных print('чистим базу данных') db = SqliteDatabase('data.db') try: db.drop_tables(models) except OperationalError: pass # создаем таблицы в бд print('\nсоздаем модели в бд:') for i in models: print(i) i.create_table() # добавляем пользователя print('\nдобавляем пользователя') admin_user = User(mail="*****@*****.**", password=get_hash('1'), port=56001) admin_user.save() test_user = User(mail="*****@*****.**", password=get_hash('1'), port=9701) test_user.save()
def init(dbname="blender-models.db"): db = SqliteDatabase(path.join(MORSEWEB_ROOT, dbname)) db.connect() if not BlenderModel.table_exists(): db.create_table(BlenderModel) for pathname in RESOURCES: populate(pathname)
def OnInit(self): wx.InitAllImageHandlers() F = wx.SplashScreen( wx.Bitmap("../icons/splash.bmp"), wx.SPLASH_TIMEOUT | wx.SPLASH_CENTER_ON_SCREEN, 2000, None, -1 ) frame_EcranPrincipal = MainFrame(None, title=u"Usine à GASE", droits=1) self.SetTopWindow(frame_EcranPrincipal) frame_EcranPrincipal.Show() try: database = SqliteDatabase("usineagase.sqlite", **{}) tables_base = database.get_tables() except: msg = u"Erreur de connection à la base de données" dlg = wx.MessageDialog(None, msg, "ERREUR", wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return 0 tables_obligatoires = [ u"achats", u"adherents", u"adhesion_types", u"adhesions", u"cotisations", u"categories", u"credits", u"commandes", u"exercices", u"fournisseurs", u"lignes_achat", u"lignes_commande", u"parametres", u"produits", u"referents", u"tvas", ] if set(tables_obligatoires) - set(tables_base): msg = u"Erreur : la base de données n'est pas accessible ou n'est pas conforme." dlg = wx.MessageDialog(None, msg, "ERREUR", wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return 0 else: # query = session.query(model.Exercice).filter(model.Exercice.DateDebut<datetime.today()).filter(model.Exercice.DateFin>datetime.today()) # Exercice.select().where(date_debut<datetime.today()) # if query.count() == 1: # EXERCICE_EN_COURS = query.first() return 1
def bundle_language_pack(dest, nodes, frontend_catalog, backend_catalog, metadata, assessment_items, assessment_files, subtitles, html_exercise_path): # make sure dest's parent directories exist pathlib.Path(dest).parent.mkdir(parents=True, exist_ok=True) with zipfile.ZipFile(dest, "w") as zf, tempfile.NamedTemporaryFile() as dbf: db = SqliteDatabase(dbf.name) db.connect() nodes = convert_dicts_to_models(nodes) nodes = mark_exercises_as_available(nodes) nodes = list(save_models(nodes, db)) # we have to make sure to force # the evaluation of each # save_models call, in order to # avoid nesting them. nodes = list(populate_parent_foreign_keys(nodes)) list(save_models(nodes, db)) nodes = recurse_availability_up_tree(nodes, db) list(save_models(nodes, db)) assessment_items = convert_dicts_to_assessment_items(assessment_items) list(save_assessment_items(assessment_items, db)) db.close() dbf.flush() save_catalog(frontend_catalog, zf, "frontend.mo") save_catalog(backend_catalog, zf, "backend.mo") # save_subtitles(subtitle_path, zf) try: # sometimes we have no html exercises save_html_exercises(html_exercise_path, zf) except FileNotFoundError: logging.warning("No html exercises found; skipping.") save_db(db, zf) save_metadata(zf, metadata) for file_path in assessment_files: save_assessment_file(file_path, zf) write_assessment_version(metadata, zf) for subtitle_path in subtitles: save_subtitle(subtitle_path, zf) return dest
def init(): path = os.path.expanduser('~/.config/aesop/database.db') global database database = SqliteDatabase(path) database_proxy.initialize(database) database.connect() for model in BaseModel.__subclasses__(): try: database.create_table(model) except Exception: pass else: if model == Config: Config.create_default()
def test_database_generation_without_args(runner, tmp_context): result = runner.invoke(pokediadb, ["generate", "-v"]) assert result.exit_code == 0 # Check existence of the database and the csv and sprites folders db_file = tmp_context.join("pokediadb.sql") assert db_file.check(file=1) assert tmp_context.join("csv").check(dir=1) assert tmp_context.join("sprites").check(dir=1) # Check type tables db = SqliteDatabase(db_file.strpath) db.connect() assert len(Type.select()) == 18 assert len(TypeEfficacy.select()) == 324 assert len(TypeTranslation.select()) == 36
def populate_database(self): self.db = SqliteDatabase('peewee.db') self.db.connect() self.db.create_tables(model.ALL_MODELS, safe=True) for m in model.ALL_MODELS: m.delete().execute() self.db.close() # Config release = model.Config.create(app_api_key=APP_API_KEY, messaging_api_key=MESSAGING_API_KEY) admin_user = model.User.create_user(name='Administrator', description='Administrator', email='*****@*****.**', username=TEST_USER, password=TEST_PASSWORD) # Groups admin = model.Group.create(name=TEST_USER, owner=admin_user) user = model.Group.create(name='user', owner=admin_user) guest = model.Group.create(name='guest', owner=admin_user) admin.add_user(admin_user) # Users model.Device.create(user=admin, name='d2', resource='work', type='computer', dev_id='a') chloe = model.User.create_user(name='Chloe', username='******', password=TEST_PASSWORD) d = chloe.create_device(name='d2', resource='work', type='computer', dev_id='a') chloe.create_device(name='d0', resource='home', type='phone', dev_id='b') chloe.create_device(name='d3', resource='home', type='laptop', dev_id='c') chloe.create_device(name='d1', resource='work', type='phone', dev_id='d') model.UserToGroup.create(user=chloe, group=guest) sunshine = model.User.create_user(name='Sunshine', username='******', password=TEST_PASSWORD) sunshine.create_device(name='d5', resource='work', type='phone', dev_id='e') model.UserToGroup.create(user=sunshine, group=user) model.UserToGroup.create(user=sunshine, group=guest) p = model.Publication.create(user=sunshine, topic='Life and Times of Sunshine', description='', publish_group=guest, subscribe_group=guest) model.Message.create(user=sunshine, to_publication=p, subject='First post!') model.Message.create(user=sunshine, to_publication=p, subject='Eating breakfast') model.Message.create(user=sunshine, to_publication=p, subject='Time for a nap') guinness = model.User.create_user(name='Guinness', username='******', password=TEST_PASSWORD) guinness.create_device(name='d7', resource='work', type='phone', dev_id='g') model.UserToGroup.create(user=guinness, group=guest) felix = model.User.create_user(name='Felix', username='******', password=TEST_PASSWORD) felix.create_device(name='d6', resource='work', type='phone', dev_id='f') model.UserToGroup.create(user=felix, group=guest) model.Subscription.create(user=felix, publication=p) model.Message.create(user=felix, to_publication=p, subject='boring...') model.Message.create(user=felix, to_user=sunshine, subject='hi sunshine') model.Message.create(user=felix, to_device=d, subject='hi chloe') model.Message.create(user=felix, to_user=chloe, subject='hi chloe again') ducky = model.User.create_user(name='Ducky', username='******', password=TEST_PASSWORD) ducky.create_device(name='d8', resource='work', type='phone', dev_id='h') model.UserToGroup.create(user=ducky, group=admin) model.UserToGroup.create(user=ducky, group=user) model.UserToGroup.create(user=ducky, group=guest)
def __init__(self, path): try: self._db = SqliteDatabase(path, check_same_thread=False) PWDatabase.DBProxy().initialize(self._db) self.startup() except Exception as e: logger.error("database file does not exist, or incorrect permissions")
def setUp(self): self.db = SqliteDatabase('peewee.db') self.db.connect() self.db.create_tables([Device, Group, User, UserToGroup, Publication], safe=True) Device.delete().execute() Group.delete().execute() User.delete().execute() UserToGroup.delete().execute() Publication.delete().execute() self.user0 = User.create_user(name='user0name', username='******', password='******') self.user0.create_device(name='device0name', resource='device0resource', type='device0type', dev_id='device0id', reg_id='device0regid') self.user1 = User.create_user(name='user1name', username='******', password='******') self.user1.create_device(name='device1name', resource='device1resource', type='device1type', dev_id='device1id') self.group0 = Group.create(name='group0name', description='group0description', owner=self.user0) self.group0.add_user(user=self.user0) self.group0.add_user(user=self.user1) self.group1 = Group.create(name='group1name', description='group1description', owner=self.user0) self.group1.add_user(user=self.user0) self.group2 = Group.create(name='group2name', description='group2description', owner=self.user1) self.group2.add_user(user=self.user1) self.pub0 = Publication.create(user=self.user0, topic='pub0topic', description='pub0description', publish_group=self.group1, subscribe_group=self.group0)
def build_features_tree(self): from peewee import SqliteDatabase, Model, IntegerField, CharField, BooleanField # built or connect database sqlite_path = { "memory" : ":memory:", "disk" : self.sqlite3db_path(), }[self.link_to_detdup.storage_type] sqlite_database = SqliteDatabase(sqlite_path, check_same_thread=False) class BaseFeaturesTree(Model): uniq_chars__len = IntegerField(default=0) sqrt_chars__len = IntegerField(default=0) sorted_freq_chars = CharField() # TODO support item_id as int or str type item_id = CharField() class Meta: database = sqlite_database self.features_tree = BaseFeaturesTree tablename = "_".join(self.custom_features).capitalize() or "DefaultFeaturesTree" # If customize more features if self.custom_features: self.features_tree = type(tablename, (BaseFeaturesTree,), dict()) for feature_k1 in self.custom_features: # http://stackoverflow.com/questions/22358489/dynamically-define-fields-in-a-peewee-model feature_v1 = self.custom_features[feature_k1] # Compact with (int) instance if type(feature_v1) is int: feature_v1 = int field1 = {int: IntegerField, str: CharField}[feature_v1]() field1.add_to_class(self.features_tree, feature_k1) self.features_tree._meta.db_table = tablename # create table and indexes if not self.features_tree.table_exists(): self.features_tree.create_table() sqlite_database.create_index(self.features_tree, "item_id".split(" ")) # TODO 让大str在前面,加快索引搜索速度 index_columns = self.default_features.keys() + self.custom_features.keys() sqlite_database.create_index(self.features_tree, index_columns) print "[build_features_tree]", self.features_tree, "self.default_features :", self.default_features, "self.custom_features :", self.custom_features print
def __init__(self, db): """ Initialize the manager for agent locations and outpost resource storage. db - absolute path to database file (sqlite) """ self.db = SqliteDatabase(db) zone_book_proxy.initialize(self.db) self.db.create_tables([OutpostZone, AgentZone], True)
def __init__(self, db): """ Initialize the manager for deferred messages and serialized information. db - absolute path to database file (sqlite) """ self.db = SqliteDatabase(db) agent_book_proxy.initialize(self.db) self.db.create_tables([AgentInfo, AgentMessage], True)
def crapTheData(config): db = SqliteDatabase(config['database_name']+'.db') db.connect() for name,url in config['urls'].iteritems(): print name, 'craping '+url maxnum = generateTable(url, config['params'][name], name, db) print 'we need to crap',maxnum,' rows data' # db.create_tables([Table],safe=True) datalist = [] for i in range(maxnum): params = config['params'][name] params['page'] = i res = requests.get(url, params ,headers=headers) print i, len(datalist) data = res.json().get('tngou') if data: datalist.append(data[0]) storeData(config['database_name']+name+'.pic', datalist)
def _get_db(self): """ Get a database connection, initialize it if not done so yet :return: SqliteDatabase instance """ if not self.db: self.db = SqliteDatabase(self.settings.DATABASE_PATH) self.db.connect() return self.db
def test_writes_db_to_archive(self): with tempfile.NamedTemporaryFile() as zffobj: zf = zipfile.ZipFile(zffobj, "w") with tempfile.NamedTemporaryFile() as dbfobj: db = SqliteDatabase(dbfobj.name) db.connect() with Using(db, [Item]): Item.create_table() item = Item(id="test", title="test", description="test", available=False, slug="srug", kind=NodeType.video, path="/test/test") item.save() db.close() save_db(db, zf) zf.close() # reopen the db from the zip, see if our object was saved with tempfile.NamedTemporaryFile() as f: # we should only have one file in the zipfile, the db. Assume # that the first file is the db. zf = zipfile.ZipFile(zffobj.name) dbfobj = zf.open(zf.infolist()[0]) f.write(dbfobj.read()) f.seek(0) db = SqliteDatabase(f.name) with Using(db, [Item]): Item.get(title="test")
def __init__(self, data_model): self.data_model = data_model self.data_model.fake_item_ids_store = self assert self.data_model.cache_dir, "FakeItemIds need cache_dir from data_model!" sqlite_path = os.path.join(self.data_model.cache_dir, "fake_item_ids_store.db") sqlite_database = SqliteDatabase(sqlite_path, check_same_thread=False) class FakeItemIdsStore(Model): is_deleted = BooleanField(default=False) # mark processed or duplicated items item_id = CharField() item_content_json = TextField() created_at = TimeField(default=datetime.datetime.now) class Meta: database = sqlite_database self.storage = FakeItemIdsStore if not self.storage.table_exists(): self.storage.create_table() sqlite_database.create_index(self.storage, "is_deleted item_id".split(" "))
def bundle_language_pack(dest, nodes, frontend_catalog, backend_catalog, metadata, assessment_items, assessment_files, subtitles): with zipfile.ZipFile(dest, "w") as zf, tempfile.NamedTemporaryFile() as dbf: db = SqliteDatabase(dbf.name) db.connect() nodes = convert_dicts_to_models(nodes) nodes = mark_exercises_as_available(nodes) nodes = list(save_models(nodes, db)) # we have to make sure to force # the evaluation of each # save_models call, in order to # avoid nesting them. nodes = list(populate_parent_foreign_keys(nodes)) list(save_models(nodes, db)) nodes = recurse_availability_up_tree(nodes, db) list(save_models(nodes, db)) assessment_items = convert_dicts_to_assessment_items(assessment_items) list(save_assessment_items(assessment_items, db)) db.close() dbf.flush() save_catalog(frontend_catalog, zf, "frontend.mo") save_catalog(backend_catalog, zf, "backend.mo") # save_subtitles(subtitle_path, zf) save_db(db, zf) save_metadata(zf, metadata) for file_path in assessment_files: save_assessment_file(file_path, zf) for subtitle_path in subtitles: save_subtitle(subtitle_path, zf) return dest
def empty(self, *args, **options): """ Creates an empty content database for the Khan channel. This ensures that an empty content database exists in the default distribution and for tests. Especially useful for creating an *EMPTY TEMPLATE* retrievecontentpack empty en --template """ lang = args[1] if not options.get('template', False): content_db_path = topic_settings.CONTENT_DATABASE_PATH.format( channel=topic_settings.CHANNEL, language=lang, ) else: content_db_path = topic_settings.CONTENT_DATABASE_TEMPLATE_PATH.format( channel=topic_settings.CHANNEL, language=lang, ) if os.path.exists(content_db_path): if options.get("force", False): os.unlink(content_db_path) else: raise CommandError( "Content database already exists: {}".format( content_db_path ) ) db = SqliteDatabase( content_db_path ) db.connect() db.create_table(Item, safe=True) db.create_table(AssessmentItem, safe=True) db.close() self.complete( _("Saved empty content database in {}.").format( content_db_path ) )
class TestManage(unittest.TestCase): def setUp(self): self.db = SqliteDatabase('peewee.db') self.db.connect() def tearDown(self): self.db.close() def testCreate(self): self.db.create_tables(ALL_MODELS, safe=True)
def init_models(app): if app.config['TESTING']: database = SqliteDatabase(':memory:') else: database = SqliteDatabase('local.db') database_proxy.initialize(database) database.connect() database.create_tables([ TodoItem, ], safe=True)
def initialize(self): """Initialize configuration, database and starts worker threads.""" os.makedirs(DATA_DIR, exist_ok=True) database_path = os.path.join(DATA_DIR, "pomito.db") if self._database is None: self._database = SqliteDatabase(None) self._database.init(database_path) self._database.connect() # Initialize the plugins self.ui_plugin.initialize() self.task_plugin.initialize() # Initialize the hooks for hook in self._hooks: hook.initialize() return
def test_deferred_database(self): deferred_db = SqliteDatabase(None) self.assertTrue(deferred_db.deferred) class DeferredModel(Model): class Meta: database = deferred_db self.assertRaises(Exception, deferred_db.connect) sq = DeferredModel.select() self.assertRaises(Exception, sq.execute) deferred_db.init(':memory:') self.assertFalse(deferred_db.deferred) # connecting works conn = deferred_db.connect() DeferredModel.create_table() sq = DeferredModel.select() self.assertEqual(list(sq), []) deferred_db.init(None) self.assertTrue(deferred_db.deferred)
# app.py import os from flask import Flask from peewee import SqliteDatabase APP_ROOT = os.path.dirname(os.path.realpath(__file__)) DATABASE = os.path.join(APP_ROOT, './database/database.db') class CustomFlask(Flask): jinja_options = Flask.jinja_options.copy() jinja_options.update(dict( block_start_string='(%', block_end_string='%)', variable_start_string='((', variable_end_string='))', comment_start_string='(#', comment_end_string='#)', )) app = CustomFlask(__name__) app.config.from_object(__name__) db = SqliteDatabase(app.config['DATABASE'], pragmas=[('journal_mode', 'wal')]) app.config['UPLOAD_FOLDER'] = './tempuploads' try: os.mkdir(app.config['UPLOAD_FOLDER']) except: print("Cannot Create", app.config['UPLOAD_FOLDER'])
from peewee import (SqliteDatabase, Model, CharField, IntegerField, TextField) db = SqliteDatabase('matches.db') class Match(Model): # each match create with this first block of data # data is in player matchlist platformId = CharField() gameId = IntegerField(unique=True) champion = IntegerField() queue = IntegerField() season = IntegerField() timestamp = IntegerField() role = CharField() lane = CharField() # this is only accesible when searched by gameid # add only if needed # this may need: default = None gameCreation = IntegerField(null=True) gameDuration = IntegerField(null=True) queueId = IntegerField(null=True) mapId = IntegerField(null=True) seasonId = IntegerField(null=True) gameVersion = CharField(null=True) gameMode = CharField(null=True) gameType = CharField(null=True) teams = TextField(null=True) participants = TextField(null=True) participantIdentities = TextField(null=True)
# See the License for the specific language governing permissions and # limitations under the License. import pickle import zlib import argon2 import datetime from typing import List, Union, Any from pytz import utc from peewee import DateTimeField, BlobField, Model, CharField from cape_userdb.cape_userdb_settings import DB_PATH from peewee import SqliteDatabase DB = SqliteDatabase(DB_PATH) _COMPRESSION_LEVEL = 9 _PROTOCOL_LEVEL = pickle.HIGHEST_PROTOCOL _PASSWORD_HASHER = argon2.PasswordHasher() _PASSWORD_HASHER_PREFIX = '$argon2i' class CompressedPickleField(BlobField): def __init__(self, *args, **kwargs): self.compression_level = _COMPRESSION_LEVEL self.pickle_protocol = _PROTOCOL_LEVEL super(CompressedPickleField, self).__init__(*args, **kwargs) def db_value(self, value): if value is not None:
""" db.py Export database """ import os from peewee import SqliteDatabase db = SqliteDatabase(os.environ["DATABASE_PATH"])
import sqlite3 from peewee import SqliteDatabase, Model, CharField, TextField db = SqliteDatabase('crm.db') class Contact(Model): first_name = CharField() last_name = CharField() email = CharField() note = TextField() class Meta: database = db def full_name(self): """Returns the full (first and last) name of the contact""" return f'{self.first_name} {self.last_name}' def __str__(self): return f'{self.first_name} {self.last_name}' db.connect() db.create_tables([Contact])
from ehforwarderbot import Message as EFBMessage from ehforwarderbot import utils, Channel, coordinator, MsgType from ehforwarderbot.message import Substitutions, MessageCommands, MessageAttribute from ehforwarderbot.types import ModuleID, ChatID, MessageID, ReactionName from .chat_object_cache import ChatObjectCacheManager from .message import ETMMsg from .msg_type import TGMsgType from .utils import TelegramChatID, EFBChannelChatIDStr, TgChatMsgIDStr, message_id_to_str, \ chat_id_to_str, OldMsgID, chat_id_str_to_id if TYPE_CHECKING: from . import TelegramChannel from .chat import ETMChatMember, ETMChatType database = SqliteDatabase(None) PickledDict = TypedDict( 'PickledDict', { "target": EFBChannelChatIDStr, "is_system": bool, "attributes": MessageAttribute, "commands": MessageCommands, "substitutions": Dict[Tuple[int, int], EFBChannelChatIDStr], "reactions": Dict[ReactionName, Collection[EFBChannelChatIDStr]] }, total=False) """ Dict entries for ``pickle`` field of ``msglog`` log. - ``target``: ``master_msg_id`` of the target message
from datetime import datetime from base64 import b64encode import threading from .utils import get_pokemon_name, get_args from playhouse.db_url import connect args = get_args() if args.db != 'sqlite': db = connect(args.db) else: db = SqliteDatabase('pogom.db', pragmas=( ('journal_mode', 'WAL'), ('cache_size', 10000), ('mmap_size', 1024 * 1024 * 32), )) log = logging.getLogger(__name__) lock = threading.Lock() class BaseModel(Model): class Meta: database = db @classmethod def get_all(cls): return [m for m in cls.select().dicts()]
import sqlite3 from peewee import Model, SqliteDatabase, CharField, IntegerField, TextField, ForeignKeyField, BooleanField DB = SqliteDatabase('btd.db') DB.connect() class Metronome(Model): name = CharField() bpm = IntegerField() class Meta: database = DB class Lyrics(Model): title_text = CharField() text = TextField() class Meta: database = DB class Tabs(Model): name = CharField() link = CharField()
def init_sqlite(settings: dict): database = settings["database"] path = str(get_file_path(database)) db = SqliteDatabase(path) return db
IntegerField) # pragma: no cover import datetime import os import re ''' Instructions: Create a command line application that will allow employees to enter their name, time worked, task worked on, and general notes about the task into a database. There should be a way to add a new entry, list all entries for a particular employee, and list all entries that match a date or search term. Print a report of this information to the screen, including the date, title of task, time spent, employee, and general notes. ''' if __name__ == "__main__": # pragma: no cover DATABASE = SqliteDatabase('web_log_2.db') else: DATABASE = SqliteDatabase('TESTING_web_log_2.db') # variable for mocking user input by tests.py TEST_MOCK_INPUT = [] # function for clearing the terminal console def clear_screen(): os.system("clear") # function for mocking user input def test_or_input(input_prompt): # if the script is running as __main__,
from werkzeug.security import check_password_hash, generate_password_hash from lms.lmsweb import webapp class RoleOptions(enum.Enum): STUDENT = 'Student' STAFF = 'Staff' ADMINISTRATOR = 'Administrator' def __str__(self): return self.value if webapp.debug: database = SqliteDatabase('db.sqlite') elif webapp.env == 'production': db_config = { 'database': webapp.config['DB_NAME'], 'user': webapp.config['DB_USER'], 'port': webapp.config['DB_PORT'], 'host': webapp.config['DB_HOST_IP'], 'password': webapp.config['DB_PASSWORD'], 'autorollback': webapp.config['DB_AUTOROLLBACK'], } database = PostgresqlDatabase(**db_config) class BaseModel(Model): class Meta: database = database
from peewee import (AutoField, CharField, Database, FloatField, DateTimeField, Model, SqliteDatabase) from vnpy.trader.constant import Interval, Exchange # 使用vn.py运行时目录的SQLite数据库 from vnpy.trader.utility import get_file_path from vnpy.trader.setting import SETTINGS path = get_file_path(SETTINGS["database.database"]) # 或者可以手动指定数据库位置 # path = "C:\\users\\administrator\\.vntrader\\database.db" # 创建数据库对象 db = SqliteDatabase(path) # 创建数据ORM的类 class DbBarData(Model): """ Candlestick bar data for database storage. Index is defined unique with datetime, interval, symbol """ id = AutoField() symbol: str = CharField() exchange: str = CharField() datetime: datetime = DateTimeField() interval: str = CharField()
# coding: utf-8 import logging import time import datetime from redis import Redis from peewee import SqliteDatabase, Model, DateTimeField, FloatField db = SqliteDatabase('/home/pi/work/pi_server/src/pi_server/data.db') class BaseModel(Model): class Meta: database = db class Temperature(BaseModel): date_time = DateTimeField(default=datetime.datetime.now) value = FloatField() class Humidity(BaseModel): date_time = DateTimeField(default=datetime.datetime.now) value = FloatField() def main(): try: logging.root.addHandler(logging.StreamHandler()) logging.root.setLevel(logging.INFO) delay = 5 * 60
from peewee import SqliteDatabase from peewee import Model from peewee import TextField, CharField from peewee import IntegerField, FloatField from peewee import DateTimeField from peewee import ForeignKeyField from datetime import datetime import json #set sane default log levels import logging logging.getLogger('peewee').setLevel(logging.INFO) logging.getLogger("peewee.pool").setLevel(logging.DEBUG) database = SqliteDatabase('ruby.db') class JSONField(TextField): def db_value(self, value): if value is not None: return json.dumps(value) return None def python_value(self, value): if value is not None: return json.loads(value) class BaseModel(Model):
import os import sys import shortuuid sys.path.insert(0, os.path.join(os.pardir, 'trellostats')) from peewee import SqliteDatabase from trellostats.models import Snapshot, db_proxy # Initilise in memory database and some data points db_proxy.initialize(SqliteDatabase(':memory:')) Snapshot.create_table() for x in range(100): Snapshot.create(**dict( board_id=shortuuid.uuid(), cycle_time=x * 10, done_id=shortuuid.uuid()))
STARTING_MONEY = 6900 DATABASE_FILE = "test.sqlite" DISCORD_TOKEN = "THE OLD TOKEN HAS BEEN REVOKED" COMMAND_PREFIX = "!b " # Bet type enumeration BET_TYPE_NULL = 0 BET_TYPE_STAT = 1 BET_TYPE_TEXT = 2 # Establish database settings db = SqliteDatabase( DATABASE_FILE, pragmas={ 'journal_mode': 'wal', 'cache_size': -1 * 64000, # 64MB 'foreign_keys': 1, 'ignore_check_constraints': 0, 'synchronous': 0 }) # =============== # Database models # =============== class BaseModel(Model): class Meta: database = db class User(BaseModel):
# -*- coding: utf-8 -*- # quiz-orm/app.py import os from flask import Flask, g from peewee import SqliteDatabase app = Flask(__name__) # konfiguracja aplikacji app.config.update(dict( SECRET_KEY='bardzosekretnawartosc', TYTUL='Quiz ORM Peewee', DATABASE=os.path.join(app.root_path, 'quiz.db'), )) # tworzymy instancję bazy używanej przez modele baza = SqliteDatabase(app.config['DATABASE']) @app.before_request def before_request(): g.db = baza g.db.connect() @app.after_request def after_request(response): g.db.close() return response
# encoding: utf-8 import sys import os import csv from collections import defaultdict from pprint import pprint as pp import math import flask from peewee import Model, CharField, DecimalField, SqliteDatabase from path import path import geojson import flatkit.datatables from utils import html_unescape db = SqliteDatabase(None, autocommit=False, threadlocals=True) refdata = path(__file__).parent / 'refdata' EPSG_31700_CRS = { "type": "name", "properties": { "name": "urn:ogc:def:crs:EPSG::31700", }, } class Record(Model): name = CharField() code = CharField() town = CharField() total = DecimalField()
class Migrations(object): """ Migrations Handle all migrations during application start. """ logger = None database = None def __init__(self, config): unmanic_logging = unlogger.UnmanicLogger.__call__() self.logger = unmanic_logging.get_logger(__class__.__name__) # Based on configuration, select database to connect to. if config['TYPE'] == 'SQLITE': # Create SQLite directory if not exists db_file_directory = os.path.dirname(config['FILE']) if not os.path.exists(db_file_directory): os.makedirs(db_file_directory) self.database = SqliteDatabase(config['FILE']) self.router = Router(database=self.database, migrate_table='migratehistory_{}'.format( config.get('MIGRATIONS_HISTORY_VERSION')), migrate_dir=config.get('MIGRATIONS_DIR'), logger=self.logger) def __log(self, message, level='info'): if self.logger: getattr(self.logger, level)(message) else: print(message) def __run_all_migrations(self): """ Run all new migrations. Migrations that have already been run will be ignored. :return: """ self.router.run() def update_schema(self): """ Updates the Unmanic database schema. Newly added tables/models and columns/fields will be automatically generated by this function. This way we do not need to create a migration script unless we: - rename a column/field - delete a column/field - delete a table/model :return: """ # Fetch all model classes all_models = [] all_base_models = [] for model in list_all_models(): imported_model = getattr( importlib.import_module("unmanic.libs.unmodels"), model) if inspect.isclass(imported_model) and issubclass( imported_model, BaseModel): # Add this model to both the 'all_models' list and our list of base models all_models.append(imported_model) all_base_models.append(imported_model) elif inspect.isclass(imported_model) and issubclass( imported_model, Model): # If the model is not one of the base models, it is an in-build model from peewee. # For, this list of models we will not run a migration, but we will still ensure that the # table is created in the DB all_models.append(imported_model) pass # Start by creating all models self.__log("Initialising database tables") try: with self.database.transaction(): for model in all_models: self.router.migrator.create_table(model) self.router.migrator.run() except Exception: self.database.rollback() self.__log("Initialising tables failed", level='exception') raise # Migrations will only be used for removing obsolete columns self.__run_all_migrations() # Newly added fields can be auto added with this function... no need for a migration script # Ensure all files are also present for each of the model classes self.__log("Updating database fields") for model in all_base_models: # Fetch all peewee fields for the model class # https://stackoverflow.com/questions/22573558/peewee-determining-meta-data-about-model-at-run-time fields = model._meta.fields # loop over the fields and ensure each on exists in the table field_keys = [f for f in fields] for fk in field_keys: field = fields.get(fk) if isinstance(field, Field): if not any(f for f in self.database.get_columns( model._meta.name) if f.name == field.name): # Field does not exist in DB table self.__log("Adding missing column") try: with self.database.transaction(): self.router.migrator.add_columns( model, **{field.name: field}) self.router.migrator.run() except Exception: self.database.rollback() self.__log("Update failed", level='exception') raise
import os from peewee import SqliteDatabase from autofin import settings database = SqliteDatabase(os.path.join(settings.STORAGE_PATH, "autofin.db"))
""" Simple database example with Peewee ORM, sqlite and Python Here we define the schema Use logging for messages so they can be turned off """ from peewee import Model, CharField, BooleanField, DecimalField, SqliteDatabase import logging database = SqliteDatabase('customer.db') database.connect() database.execute_sql('PRAGMA foreign_keys = ON;') # needed for sqlite only class BaseModel(Model): class Meta: database = database class Customer(BaseModel): """ This class defines Customer, which maintains the details of a customer at HP Norton """ id = CharField(primary_key = True, max_length = 5) firstname = CharField(max_length = 30) lastname = CharField(max_length = 30) address = CharField(max_length = 30) phone = CharField(max_length = 12) # Format is XXX-XXX-XXXX email = CharField(max_length = 30) status = BooleanField() credit_limit = DecimalField(max_digits = 7, decimal_places = 2)
field=BUPTUser.latest_xisu_checkin_response_time), ) print(f'{__file__} migrated') def rollback(self): with self._database.atomic(): migrate( self._migrator.drop_column( table='buptuser', column_name='latest_xisu_checkin_data'), self._migrator.drop_column( table='buptuser', column_name='latest_xisu_checkin_response_data'), self._migrator.drop_column( table='buptuser', column_name='latest_xisu_checkin_response_time'), ) print(f'{__file__} rolled back') if __name__ == '__main__': os.chdir(os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')) database = SqliteDatabase(SQLITE_DB_FILE_PATH) migrator = SqliteMigrator(database) migration = AddXisuCheckinAbstractMigration(database=database, migrator=migrator) migration.migrate() # migration.rollback()
def _create_database(self): return SqliteDatabase(self.database_path, pragmas={ "foreign_keys": 1, "secure_delete": 1 })
from unittest import TestCase from datetime import datetime from peewee import SqliteDatabase from pychaperone.db_setup import QueueCheck from pychaperone.chaperone import chaperone import dill as pickle import os db = SqliteDatabase(':memory:') db.connect() db.create_tables([QueueCheck]) db.close() class TestChaperoneIntegration(TestCase): def f1(self, x): return [x] def f2(self, x): return datetime.today() def f3(self, x): return ValueError def f4(self, x): return None def f5(self, x): return [[x]] items = [1, 2, 3, 4]
from flask import Flask, g from peewee import * # noqa from peewee import SqliteDatabase app = Flask(__name__) app.config.from_object('settings') database = SqliteDatabase(app.config['DATABASE'], threadlocals=True) from mhvdb2.admin import admin # noqa app.register_blueprint(admin, url_prefix='/admin') @app.before_request def before_request(): g.db = database g.db.connect() @app.after_request def after_request(response): g.db.close() return response import mhvdb2.routes # noqa from mhvdb2.models import Entity, User # noqa database.connect() if not Entity.table_exists():
from unittest import TestCase from playhouse.test_utils import test_database from teabot_endpoints.models import State, PotMaker from peewee import SqliteDatabase from datetime import datetime, timedelta test_db = SqliteDatabase(':memory:') class TestModels(TestCase): def run(self, result=None): with test_database(test_db, [State, PotMaker]): super(TestModels, self).run(result) def test_get_latest_state_none(self): result = State.get_newest_state() self.assertIsNone(result) def test_get_latest_state(self): State.create( state="TEAPOT_FULL", timestamp=datetime.now().isoformat(), num_of_cups=3 ) State.create( state="TEAPOT_EMPTY", timestamp=datetime.now() - timedelta(weeks=1), num_of_cups=0 ) result = State.get_newest_state()
from flask import Flask from os.path import isfile from peewee import Model, CharField, IntegerField, SqliteDatabase from flask_potion.backends.peewee import PeeweeManager from flask_potion import Api, ModelResource, fields app = Flask(__name__) app.debug = True pw = SqliteDatabase('peewee-simple.db') class Book(Model): title = CharField(null=True, unique=True) year_published = IntegerField() class Meta: database = pw class BookResource(ModelResource): class Meta: name = 'book' model = Book class Schema: year_published = fields.Integer(minimum=1400) api = Api(app, default_manager=PeeweeManager) api.add_resource(BookResource)
from datetime import datetime from hashlib import sha256 import os from peewee import SqliteDatabase, Model, BooleanField, CharField, ForeignKeyField, IntegrityError, \ TextField from utils import Regex __author__ = 'João Neto' # Database # To configure database check peewee documentation # http://docs.peewee-orm.com/en/latest/peewee/database.html db = SqliteDatabase('database.sqlite') # Print all queries of peewee to stderr. # import logging # logger = logging.getLogger('peewee') # logger.setLevel(logging.DEBUG) # logger.addHandler(logging.StreamHandler()) class BaseModel(Model): active = BooleanField(default=False, verbose_name='Registro ativo', help_text='Indica se registro está ativo') created_date = CharField(default=datetime.now().strftime('%d/%m/%Y %H:%M:%S'), verbose_name='Data criação',
"""""" from peewee import SqliteDatabase, Model, CharField, DateTimeField, FloatField from .constant import Exchange, Interval from .object import BarData, TickData from .utility import get_file_path DB_NAME = "database.db" DB = SqliteDatabase(str(get_file_path(DB_NAME))) class DbBarData(Model): """ Candlestick bar data for database storage. Index is defined unique with vt_symbol, interval and datetime. """ symbol = CharField() exchange = CharField() datetime = DateTimeField() interval = CharField() volume = FloatField() open_price = FloatField() high_price = FloatField() low_price = FloatField() close_price = FloatField() vt_symbol = CharField()
""" Define the Customer DB model """ # Russell Felts # Assignment 4 - DB Model # pylint: disable=too-few-public-methods import logging from peewee import SqliteDatabase, CharField, \ BooleanField, DecimalField, Model, AutoField logging.basicConfig(level=logging.INFO) LOGGER = logging.getLogger(__name__) LOGGER.info("Create and connect to the DB.") DATABASE = SqliteDatabase('customers.db') DATABASE.connect() DATABASE.execute_sql('PRAGMA foreign_keys = ON') class BaseModel(Model): """ Define the DB to be used """ class Meta: """ Peewee interpreter class """ database = DATABASE class Customer(BaseModel): """ Defines the customer table of the DB """ LOGGER.info("Specify the fields and their attributes.")
OperationalError) from playhouse.migrate import SqliteMigrator from playhouse.migrate import migrate as run_migrate from tmc.errors import NoCourseSelected, NoExerciseSelected target_file = os.environ.get("TMC_DATABASEFILE", os.path.join(os.path.expanduser("~"), ".config", "tmc.db")) # SqliteDatabase will fail if the parent directory isn't there. if not os.path.isdir(os.path.dirname(target_file)): os.mkdir(os.path.dirname(target_file), 0o700) sqlite = SqliteDatabase(target_file) sqlite.connect() class BaseModel(Model): class Meta: database = sqlite class SchemaVersion(BaseModel): version = IntegerField() class Course(BaseModel): tid = IntegerField(unique=True)
class PumpValveControllerTest(unittest.TestCase): @classmethod def setUpClass(cls): fakesleep.monkey_patch() SetTestMode() Logs.setup_logger(log_level=logging.DEBUG) @classmethod def tearDownClass(cls): fakesleep.monkey_restore() def setUp(self): self.test_db = SqliteDatabase(':memory:') self.test_db.bind(MODELS) self.test_db.connect() self.test_db.create_tables(MODELS) def tearDown(self): self.test_db.drop_tables(MODELS) self.test_db.close() def test_open_valves(self): Valve.create(number=1, name='valve 1', delay=30, output=Output.create(number=1)) Valve.create(number=2, name='valve 2', delay=30, output=Output.create(number=2)) Valve.create(number=3, name='valve 3', delay=30, output=Output.create(number=3)) SetUpTestInjections(output_controller=mock.Mock(OutputController)) controller = PumpValveController() controller.refresh_from_db() self.assertIn(1, controller._valve_drivers) valve_driver_1 = controller.get_valve_driver(1) self.assertIn(2, controller._valve_drivers) valve_driver_2 = controller.get_valve_driver(2) self.assertIn(3, controller._valve_drivers) valve_driver_3 = controller.get_valve_driver(3) for percentage, mode, results in [(100, 'equal', [100, 100]), (50, 'equal', [50, 50]), (0, 'equal', [0, 0]), (100, 'cascade', [100, 100]), (75, 'cascade', [100, 50]), (50, 'cascade', [100, 0]), (0, 'cascade', [0, 0])]: controller.set_valves(percentage, [1, 2], mode) self.assertEqual(results[0], valve_driver_1._desired_percentage) self.assertEqual(results[1], valve_driver_2._desired_percentage) self.assertEqual(0, valve_driver_3._desired_percentage) def test_transitions(self): pump_1 = Pump.create(number=1, name='pump 1', output=Output.create(number=1)) pump_2 = Pump.create(number=2, name='pump 2', output=Output.create(number=2)) valve_1 = Valve.create(number=1, name='valve 1', delay=30, output=Output.create(number=11)) valve_2 = Valve.create(number=2, name='valve 2', delay=15, output=Output.create(number=12)) valve_3 = Valve.create(number=3, name='valve 3', delay=15, output=Output.create(number=13)) PumpToValve.create(pump=pump_1, valve=valve_1) PumpToValve.create(pump=pump_1, valve=valve_2) PumpToValve.create(pump=pump_2, valve=valve_3) SetUpTestInjections(output_controller=mock.Mock(OutputController)) controller = PumpValveController() controller.refresh_from_db() valve_driver_1 = controller.get_valve_driver(1) valve_driver_2 = controller.get_valve_driver(2) valve_driver_3 = controller.get_valve_driver(3) pump_driver_1 = controller._pump_drivers[1] pump_driver_2 = controller._pump_drivers[2] # Initial state, everything is off self.assertFalse(pump_driver_1.state) self.assertEqual(0, valve_driver_1.percentage) self.assertEqual(0, valve_driver_2.percentage) self.assertFalse(pump_driver_2.state) self.assertEqual(0, valve_driver_3.percentage) # Set the second valve to 50% # The pump should only be turned on after 15s valve_driver_2.set(50) controller.steer() self.assertFalse(pump_driver_1.state) self.assertEqual(0, valve_driver_1.percentage) self.assertEqual(50, valve_driver_2.percentage) self.assertFalse(pump_driver_2.state) self.assertEqual(0, valve_driver_3.percentage) # Pump still off after 10s time.sleep(10) controller.steer() self.assertFalse(pump_driver_1.state) self.assertEqual(0, valve_driver_1.percentage) self.assertEqual(50, valve_driver_2.percentage) self.assertFalse(pump_driver_2.state) self.assertEqual(0, valve_driver_3.percentage) # Pump is on after 10s time.sleep(10) controller.steer() self.assertTrue(pump_driver_1.state) self.assertEqual(0, valve_driver_1.percentage) self.assertEqual(50, valve_driver_2.percentage) self.assertFalse(pump_driver_2.state) self.assertEqual(0, valve_driver_3.percentage) # Other valves are also opened valve_driver_1.set(100) valve_driver_3.set(100) controller.steer() self.assertTrue(pump_driver_1.state) self.assertEqual(100, valve_driver_1.percentage) self.assertEqual(50, valve_driver_2.percentage) self.assertFalse(pump_driver_2.state) self.assertEqual(100, valve_driver_3.percentage) # After a time, both valves are fully open time.sleep(40) controller.steer() self.assertTrue(pump_driver_1.state) self.assertEqual(100, valve_driver_1.percentage) self.assertEqual(50, valve_driver_2.percentage) self.assertTrue(pump_driver_2.state) self.assertEqual(100, valve_driver_3.percentage) # Two valves are closed again # When valves are closed, the pumps are stopped immediately valve_driver_2.set(0) valve_driver_3.set(0) time.sleep(10) controller.steer() self.assertTrue(pump_driver_1.state) self.assertEqual(100, valve_driver_1.percentage) self.assertEqual(0, valve_driver_2.percentage) self.assertFalse(pump_driver_2.state) self.assertEqual(0, valve_driver_3.percentage)
# -*- coding:utf-8 -*- import sqlite3 from peewee import BaseModel, CharField, Model, SqliteDatabase try: import config # TODO: Fix relative import config is in ../config/config.py # and/or move config file DATABASE_LOCATION = config.DATABASE_LOCATION except ImportError: DATABASE_LOCATION = 'lite.db' database = SqliteDatabase(DATABASE_LOCATION) database.connect() class BaseModel(Model): '''Base class for the models''' class Meta: database = database class Tweet(BaseModel): '''Model for Tweet table, stores all the information that is gathered using the module Pattern's search function''' # TODO: Add primary key and index(es) # TODO: Move model(s) to separate file profile = CharField() language = CharField()
# for more details. #Modelo base del cual derivan todos los modelos del sistema __author__ = "Jose Oscar Vogel <*****@*****.**>" __copyright__ = "Copyright (C) 2020 Jose Oscar Vogel" __license__ = "GPL 3.0" __version__ = "0.5" from peewee import MySQLDatabase, Model, BooleanField, SqliteDatabase from libs.Utiles import LeerIni, desencriptar if LeerIni(clave='base') == 'sqlite': if LeerIni(clave='usa_nombre_db') == 'S': db = SqliteDatabase(f'{LeerIni("basedatos")}.db') print(f'Usando {LeerIni("basedatos")}') else: db = SqliteDatabase(f'sistema.db') print("Usando sistema.db") else: db = MySQLDatabase(LeerIni("basedatos"), user=LeerIni("usuario"), password=desencriptar(LeerIni('password').encode(),LeerIni('key').encode()), host=LeerIni("host"), port=3306) class ModeloBase(Model): def __init__(self, *args, **kwargs): super(ModeloBase, self).__init__(*args, **kwargs) def getDb(self):
# Start Date: 11/13/2019 # End Date: 11/14/2019 """ The schema of the Customers DB (customer.db) """ import datetime from peewee import SqliteDatabase from peewee import Model from peewee import CharField from peewee import DecimalField from peewee import DateTimeField DATABASE = SqliteDatabase("customers.db") DATABASE.connect() DATABASE.execute_sql("PRAGMA foreign_keys = ON;") class BaseModel(Model): """ The base model for the customer database """ class Meta: """ The meta class """ database = DATABASE class Customers(BaseModel): """ The model representing the customers table.
def setUp(self): self.test_db = SqliteDatabase(':memory:') self.test_db.bind(MODELS) self.test_db.connect() self.test_db.create_tables(MODELS)