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)
