def init_db():
global db
global update
global data_dir
tmp_db = None
if update:
update_db()
else:
tmp_db = SqliteDatabase(os.path.join(data_dir, "cozy.db"))
if PeeweeVersion[0] == '2':
with tmp_db.connection_context():
tmp_db.create_tables([Track, Book, Settings, ArtworkCache, Storage, StorageBlackList, OfflineCache], True)
else:
with tmp_db.connection_context():
tmp_db.create_tables([Track, Book, Settings, ArtworkCache, Storage, StorageBlackList, OfflineCache])
# this is necessary to ensure that the tables have indeed been created
if tmp_db:
while not tmp_db.table_exists("settings"):
time.sleep(0.01)
try:
db.connect()
except Exception as e:
log.error("Could not connect to database. ")
log.error(e)
if PeeweeVersion[0] == '3':
db.bind([Book, Track, Settings, ArtworkCache, StorageBlackList, OfflineCache, Storage], bind_refs=False, bind_backrefs=False)
if (Settings.select().count() == 0):
Settings.create(path="", last_played_book=None)
def create_database():
with open("/home/wojjak/PycharmProjects/untitled/data.db", "a") as f:
f.write("")
db = SqliteDatabase("data.db")
db.connect()
db.create_tables([Client])
db.create_tables([User])
def setup_db_before_test():
"""Sets up database automatically before each test"""
_db = SqliteDatabase(":memory:")
with _db.bind_ctx(MODELS):
_db.create_tables(MODELS)
yield _db
_db.drop_tables(MODELS)
def create(cls, db_name, db_type, host=None, user=None, password=None,
port=5432, models=_MODELS):
""" Setup ORM."""
if db_type == 'sqlite':
logger.info(F'Opening connection to sqlite')
db = SqliteDatabase(db_name,
pragmas={
'journal_mode': 'wal',
'cache_size': -1 * 64000, # 64MB
'foreign_keys': 1,
'ignore_check_constraints': 0,
}
)
elif db_type == 'postgres':
db = PostgresqlDatabase(db_name, user=user, password=password,
host=host, port=port, autoconnect=True)
else:
logger.error(F'Unknown database type {db_type}')
raise ValueError
db.bind(models)
db.create_tables(models, safe=True)
cls._db_handle = db
cls._db_name = db_name
cls._db_models = models
class SubstitutableDatabase(object):
def __init__(self, filepath=":memory:", tables=[]):
self._tables = tables
self._create_database(filepath)
def _create_database(self, filepath):
self._db = SqliteDatabase(
abspath(filepath) if filepath != ":memory:" else filepath,
pragmas={"foreign_keys": 1},
)
for model in self._tables:
model.bind(self._db, bind_refs=False, bind_backrefs=False)
self._db.connect()
self._db.create_tables(self._tables, safe=True)
def _change_path(self, filepath):
self.close()
self._create_database(filepath)
def _vacuum(self):
print("Vacuuming database ")
self.execute_sql("VACUUM;")
def __getattr__(self, attr):
return getattr(self._db, attr)
def create_db():
import os
if not ('DYNO' in os.environ):
db = SqliteDatabase('../sender.sqlite')
db.connect(True)
db.drop_tables([AdminPage, TargetGroup, UserPage, SenderPage])
db.create_tables([AdminPage, TargetGroup, UserPage, SenderPage])
yuri = AdminPage(vkid=142872618)
yuri.save()
else:
init_db()
db_proxy.connect(True)
print('CONNECTED')
# TODO сделать так, чтобы дубликаты не добавлялись
db_proxy.create_tables([AdminPage, TargetGroup, UserPage, SenderPage],
safe=True)
print('before AdminPage')
yuri = AdminPage(vkid=142872618)
yuri.save()
print('before db.close()')
db_proxy.close()
return 'DB is created!'
def create_db():
import os
if not ('HEROKU' in os.environ):
db = SqliteDatabase('sender.sqlite')
db.connect(True)
db.drop_tables([Account, Subscription, Messenger, AccessToken])
db.create_tables([Account, Subscription, Messenger, AccessToken])
vk = Messenger.create(name='VK', cost=200)
vk.save()
telegram = Messenger.create(name='Telegram', cost=200)
telegram.save()
else:
init_db()
db_proxy.connect(True)
print('CONNECTED')
db_proxy.create_tables([AdminPage, TargetGroup, UserPage, SenderPage],
safe=True)
print('before AdminPage')
yuri = AdminPage(vkid=142872618)
yuri.save()
print('before db.close()')
db_proxy.close()
return 'DB is created!'
class NonDeterminismCatcher:
__db = None
__logging = None
def __init__(self, logger) -> None:
self.__db = SqliteDatabase('non_determinism_quic.db')
self.__db.connect()
self.__db.drop_tables(
[LearningRunModel, NonDeterministicResponseModel])
self.__db.create_tables(
[LearningRunModel, NonDeterministicResponseModel])
self.__logging = logger
logger = logging.getLogger('peewee')
logger.addHandler(logging.StreamHandler())
logger.setLevel(logging.DEBUG)
def add_run(self, q, res):
# Check if there is already a record with this query
try:
if not res:
res = "---"
previous_run = LearningRunModel.get(LearningRunModel.run == q)
self.__logging.info("Received query {}".format(q))
if not previous_run.result == res:
self.__logging.info("Not deterministic with {}".format(
previous_run.result))
NonDeterministicResponseModel(run=q, result=res).save()
except LearningRunModel.DoesNotExist:
self.__logging.info("New run inserted.")
LearningRunModel(run=q, result=res).save()
def __init__(self, database: SqliteDatabase, view: MainView,
presenter: MainPresenter, builder: MainBuilder,
udev_interactor: UdevInteractor, *args: Any,
**kwargs: Any) -> None:
LOG.debug("init Application")
GLib.set_application_name(_(APP_NAME))
super().__init__(*args,
application_id=APP_ID,
flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE,
**kwargs)
database.connect()
database.create_tables(
[SpeedProfile, SpeedStep, CurrentSpeedProfile, Setting])
if SpeedProfile.select().count() == 0:
load_db_default_data()
self.add_main_option_entries(self._get_main_option_entries())
self._view = view
self._presenter = presenter
self._presenter.application_quit = self.quit
self._window: Optional[Gtk.ApplicationWindow] = None
self._builder: Gtk.Builder = builder
self._udev_interactor = udev_interactor
self._start_hidden: bool = False
def _create_database(self):
db = SqliteDatabase(self._filepath)
for model in self._tables:
model.bind(db, bind_refs=False, bind_backrefs=False)
db.connect()
db.create_tables(self._tables)
return db
def test_select_game_should_fail_if_game_had_been_registered(
self,
get_games_mock,
mock_keyboard
):
database = SqliteDatabase(':memory:')
database_proxy.initialize(database)
database.create_tables([User, Game])
mock_user = User.create(id=111, steam_id=0, authorization_key='')
Game.create(id=27000, owner=mock_user, name='Test Game')
bot_mock = Mock()
update_mock = Mock()
update_mock.message.from_user.id = 111
update_mock.message.text = 'Test Game'
mock_keyboard.return_value = mock_keyboard
with open(
(os.path.dirname(__file__))+'/fixtures/game_request.json'
) as f:
json_data = json.load(f)
game_data = json_data['Games']
get_games_mock.return_value = game_data
self.assertEqual(
ConversationHandler.END,
cmd_new_game.select_game(bot_mock, update_mock)
)
update_mock.message.reply_text.assert_called_with(
'Game already registered',
reply_markup=mock_keyboard
)
def test_new_game_should_return_list_of_games(
self,
get_games_mock,
mock_keyboard
):
database = SqliteDatabase(':memory:')
database_proxy.initialize(database)
database.create_tables([User, Game])
User.create(id=111, steam_id=0, authorization_key='')
mock_keyboard.return_value = mock_keyboard
bot_mock = Mock()
update_mock = Mock()
update_mock.message.from_user.id = 111
with open(
(os.path.dirname(__file__))+'/fixtures/game_request.json'
) as f:
json_data = json.load(f)
game_data = json_data['Games']
get_games_mock.return_value = game_data
self.assertEqual(
cmd_new_game.SELECT,
cmd_new_game.new_game(bot_mock, update_mock)
)
update_mock.message.reply_text.assert_called_with(
'Chose the game',
reply_markup=mock_keyboard
)
mock_keyboard.assert_called()
def test_add_game_should_display_error_if_no_available_games(
self,
get_games_mock
):
database = SqliteDatabase(':memory:')
database_proxy.initialize(database)
database.create_tables([User, Game])
mock_user = User.create(id=111, steam_id=0, authorization_key='')
Game.create(id=27000, owner=mock_user, name='Test Game')
bot_mock = Mock()
update_mock = Mock()
update_mock.message.from_user.id = 111
with open(
(os.path.dirname(__file__))+'/fixtures/game_request.json'
) as f:
json_data = json.load(f)
game_data = json_data['Games']
get_games_mock.return_value = game_data
self.assertEqual(
ConversationHandler.END,
cmd_new_game.new_game(bot_mock, update_mock)
)
update_mock.message.reply_text.assert_called_with(
'No games to be added'
)
class PeeweeDBManager(object):
def __init__(self, connection=None):
self.connection = connection
# proxy initialization
self.database = SqliteDatabase(
self.connection,
# thread_safe=False,
# check_same_thread=False,
pragmas={
'journal_mode': 'wal',
'cache_size': -1 * 64000, # 64MB
'foreign_keys': 1,
'ignore_check_constraints': 0,
'synchronous': 0
})
db.initialize(self.database)
# dynamic initialization
# db.init(self.connection)
# db = connect(self.connection)
# self.database = db
@property
def session(self):
return self.database.connection_context
def setup(self):
# Normally we would add whatever db setup code we needed here.
# This will for fine for the ORM
try:
self.database.create_tables(MODELS, safe=True)
except Exception as e:
print('Could not initialize DB: {}'.format(e))
def test_poll_game_should_return_false_if_it_is_not_in_any_chats(
self,
mock_gmr
):
bot_mock = Mock()
database = SqliteDatabase(':memory:')
database_proxy.initialize(database)
database.create_tables([User, Game, Subscription])
with open((os.path.dirname(__file__))
+ '/fixtures/game_request.json') as f:
json_data = json.load(f)
mock_gmr.return_value = json_data['Games'][0]
user = User.create(id=111, steam_id=0, authorization_key='')
game = Game.create(
id=27000,
name='Test Game',
owner=user
)
self.assertEqual(False, job_games.poll_game(bot_mock, game))
game.refresh()
self.assertEqual(True, game.active)
def CreateAllTables(self):
database = SqliteDatabase('database.db', pragmas={'foreign_keys': 1})
database.connect()
database.create_tables([
Player, LeaderboardRecord, Level, Terrain, Background, Monster,
TerrainInfo, BackgroundInfo, MonsterInfo
])
def initialize_database(path: Optional[str] = None):
path = path if path is not None else join(expanduser("~"), '.hyperion.db')
database = SqliteDatabase(path)
database_proxy.initialize(database)
database.connect()
database.create_tables([Neighbourhood, Bike, Location, Link, Postcode],
safe=True)
def main():
db = SqliteDatabase('daily.sqlite')
class Daily_2021(Model):
month = IntegerField()
day = IntegerField()
text = CharField(max_length=1000)
verset = CharField()
class Meta:
database = db
db.connect()
db.create_tables([Daily_2021])
# result = get_text()
for month in range(1, 13):
for day in range(1, get_month_days(month) + 1):
result = get_text(month, day)
print(f"{month} {day} {result[0]} {result[1]}")
Daily_2021.create(month=month,
day=day,
text=result[0],
verset=result[1])
print()
class TestArtRoutes(TestCase):
def setUp(self):
database_config.db_path = 'test_db.sqlite'
self.database = SqliteDatabase(database_config.db_path,
pragmas={'foreign_keys': 1})
self.database.drop_tables([Art, Artist])
self.database.create_tables([Art, Artist])
self.test_app = app.test_client()
def test_add_artist(self):
response = self.test_app.post('/artists',
data={
'name': 'cheese',
'email_address':
'*****@*****.**'
},
follow_redirects=True)
# response is a stream of bytes, decode into a string
response_text = response.data.decode('utf-8')
# Is data on page? Could also assert data is in specific HTML elements with a little more work
# A HTML parser like Beautiful Soup could help https://www.crummy.com/software/BeautifulSoup/bs4/doc/
self.assertIn('cheese', response_text)
self.assertIn('*****@*****.**', response_text)
# Flash message shown?
self.assertIn('The new artist has been added!', response_text)
# new artist in DB?
new_artist = Artist.get_or_none(
Artist.name == 'cheese'
and Artist.email_address == '*****@*****.**')
self.assertIsNotNone(new_artist)
def test_no_duplicate_artist(self):
self.ats1 = Artist.create(name='ats1',
email_address='*****@*****.**').save()
response = self.test_app.post('/artists',
data={
'name': 'ats1',
'email_address': '*****@*****.**'
})
response_text = response.data.decode('utf-8')
# Flash message?
self.assertIn('Artist ats1 has already been added.', response_text)
# Still only one artist in DB?
artist_count = Artist.select().count()
self.assertEqual(1, artist_count)
# artist with duplicate name not added
new_artist = Artist.get_or_none(
Artist.name == 'ats1' and Artist.email_address == '*****@*****.**')
self.assertIsNone(new_artist)
def db_connection():
models = [Metric]
db = SqliteDatabase(':memory:')
with db:
db.bind(models)
db.create_tables(models)
yield db
db.drop_tables(models)
def create_db_tables():
logger.info("Checking database...")
if not DB_PATH.exists():
logger.info("Database does not exist...")
db = SqliteDatabase(str(DB_PATH))
with db:
db.create_tables([User, Question])
logger.info("Tables created!")
def init_db(filename: str = ":memory:") -> SqliteDatabase:
"""
Bind an SQLite database to the Peewee ORM models.
"""
db = SqliteDatabase(filename)
db.bind(BaseModel.model_registry)
db.create_tables(BaseModel.model_registry)
return db
def make_database(address = ":memory:"):
database = SqliteDatabase(address)
proxy.initialize(database)
database.create_tables([
Author, Book, BookAuthors,
Card, CardIndex,
File, User])
return database
def db_connection():
models = [ClubUser, ClubMessage]
db = SqliteDatabase(':memory:')
with db:
db.bind(models)
db.create_tables(models)
yield db
db.drop_tables(models)
def db_connection():
models = [Event, EventSpeaking, MessageAuthor]
db = SqliteDatabase(':memory:')
with db:
db.bind(models)
db.create_tables(models)
yield db
db.drop_tables(models)
def create_database(db):
if not os.path.isfile(db):
database = SqliteDatabase(db)
database.connect()
database.execute_sql('PRAGMA foreign_keys = ON;')
database.create_tables([Customer])
database.close()
class ValveDriverTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
fakesleep.monkey_patch()
SetTestMode()
@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_valve_driver(self):
valve_output_1 = Output.create(number=2)
valve_1 = Valve.create(number=1,
name='valve 1',
delay=30,
output=valve_output_1)
SetUpTestInjections(output_controller=mock.Mock(OutputController))
driver_1 = ValveDriver(valve_1)
self.assertEqual(valve_1.id, driver_1.id)
self.assertEqual(0, driver_1.percentage)
self.assertEqual(0, driver_1._desired_percentage)
self.assertFalse(driver_1.is_open)
self.assertFalse(driver_1.in_transition)
driver_1.set(50)
self.assertEqual(50, driver_1._desired_percentage)
driver_1.close()
self.assertEqual(0, driver_1._desired_percentage)
driver_1.open()
self.assertEqual(100, driver_1._desired_percentage)
self.assertTrue(driver_1.will_open)
driver_1.steer_output()
driver_1._output_controller.set_output_status.assert_called_once()
self.assertFalse(driver_1.will_open)
self.assertEqual(100, driver_1.percentage)
self.assertFalse(driver_1.is_open)
self.assertTrue(driver_1.in_transition)
time.sleep(20)
self.assertFalse(driver_1.is_open)
self.assertTrue(driver_1.in_transition)
time.sleep(15)
self.assertTrue(driver_1.is_open)
self.assertFalse(driver_1.in_transition)
def test_db_closure(*args, **kwargs):
test_db = SqliteDatabase(":memory:")
with test_db.bind_ctx(dbs):
test_db.create_tables(dbs)
try:
func(*args, **kwargs)
finally:
test_db.drop_tables(dbs)
test_db.close()
def create_db():
db = SqliteDatabase(':memory:')
Promoter.bind(db)
Event.bind(db)
Ticket.bind(db)
Order.bind(db)
db.create_tables([Promoter, Event, Ticket, Order])
def app():
app = create_app({"TESTING": True})
database = SqliteDatabase(get_db_path())
database.create_tables([Poll, Choice, VoteCast])
yield app
database.drop_tables([Poll, Choice, VoteCast])
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)
name = Field(String, 10)
age = Field(Int, 2)
salary = Field(Float, 14, precision=4)
class Meta:
selector_string = u'01'
database = db
class Address(PeeweeRecord):
typ = Field(Int, 2)
address = Field(String, 10, truncate=True)
phone = Field(String, 20)
class Meta:
selector_string = u'02'
database = db
# read sample file
engine = FixedEngine([Header, Address], selector_slice=(0, 2))
# connect to db
db.connect()
# create tables
db.create_tables([Header, Address])
# write fields to db using save
for r in engine.load('../samples/sample_utf8.txt'):
r.save()
payment = Payment.get_by_id(payment_id)
return {
"payment": payment.to_dict(),
}
def put(self, payment_id):
payment = Payment.get_by_id(payment_id)
payment.name = request.form["name"]
payment.price = request.form["price"]
payment.save()
class MetricsResource(Resource):
def get(self):
return {
"balance": get_balance(),
"days_left": get_days_left(),
}
api.add_resource(PaymentsResource, "/payments")
api.add_resource(PaymentResource, "/payment/<int:payment_id>")
api.add_resource(MetricsResource, "/metrics")
db.connect()
db.create_tables([Payment], safe=True)
except :
pass
db = SqliteDatabase(DB_NAME, threadlocals=True)
class OUI(Model) :
class Meta :
database = db
oui = CharField(unique=True, max_length=OUI_LEN)
short_name = TextField()
long_name = TextField()
db.connect()
db.create_tables([OUI,])
with open(OUI_SOURCE, 'r') as f :
for line in f.readlines() :
if line.startswith('#') :
continue
parts = line.split()
if len(parts) <= 1 :
continue
if len(parts[0]) != OUI_LEN :
continue
oui = parts[0]
short_name = parts[1]
parts = line.split('#')
if len(parts) == 2 :
help_text='Imagem original')
normalized_image = CharField(unique=True,
verbose_name='Imagem normalizada',
help_text='Imagem normalizada')
thumbnail_image = CharField(unique=True,
verbose_name='Imagem reduzida',
help_text='Imagem reduzida')
def delete_all(self, site_img_path):
if self.original_image:
original_file = os.path.join(site_img_path, self.original_image)
if os.path.exists(original_file):
os.remove(original_file)
if self.normalized_image:
normalized_file = os.path.join(site_img_path, self.normalized_image)
if os.path.exists(normalized_file):
os.remove(normalized_file)
if self.thumbnail_image:
thumbnail_file = os.path.join(site_img_path, self.thumbnail_image)
if os.path.exists(thumbnail_file):
os.remove(thumbnail_file)
super(Picture, self).delete_instance()
def save(self, force_insert=False, only=None):
super(Picture, self).save(force_insert, only)
# Connect to db and create tables
db.connect()
db.create_tables([User, Site, Portfolio, Picture], safe=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)
if not isfile('peewee-simple.db'):
pw.connect()
pw.create_tables([Book])
if __name__ == '__main__':
app.run()
class AgentBook(object):
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 delete_info(self, agent):
""" Delete stored information for a given agent.
agent - agent name
"""
scoutlog.info('deleting stored information of agent %s' % agent)
try:
info = AgentInfo.get(AgentInfo.agent == agent)
except AgentInfo.DoesNotExist:
scoutlog.error('no information to delete for agent %s' % agent)
return False
info.delete_instance()
return True
def delete_messages(self, agent):
""" Delete stored messages for a given agent.
agent - agent name
"""
scoutlog.info('deleting stored messages of agent %s' % agent)
query = AgentMessage.delete().where(AgentMessage.agent == agent)
query.execute()
return True
def get_info(self, agent):
""" Return the stored information (if any).
agent - agent name
"""
scoutlog.info('obtaining stored information of agent %s' % agent)
try:
return AgentInfo.get(AgentInfo.agent == agent).info
except AgentInfo.DoesNotExist:
scoutlog.error('no information stored for agent %s' % agent)
return None
def get_messages(self, agent):
""" Return all messages for a given agent.
agent - agent name
"""
scoutlog.info('obtaining stored stored messages for agent %s' % agent)
try:
return [a.message for a in AgentMessage.select().where(
AgentMessage.agent == agent)]
except:
# Not found?
scoutlog.warning('no messages for agent %s' % agent)
return []
def store_info(self, parser):
""" Store serialized information for a given agent.
parser - zoe MessageParser instance
"""
dst = parser.get('agent')
scoutlog.info('storing information of agent %s' % dst)
new_map = parser._map.copy()
# Prepare for direct dispatch
new_map['dst'] = dst
del new_map['agent']
# Original tags removed! (should only have scout ones)
new_map['tag'] = ['settle!', ]
# Store message
raw_msg = zoe.MessageBuilder(new_map).msg()
try:
AgentInfo.create(agent=dst, info=raw_msg)
except IntegrityError as e:
scoutlog.exception('failed to store information of agent %s' % dst)
def store_message(self, parser):
""" Store deferred messages. Convert special tags to their original
counterparts.
parser - zoe MessageParser instance
"""
dst = parser.get('_outpost_dst')
src = parser.get('_outpost_src')
tag = parser.get('_outpost_tag')
scoutlog.info('storing deferred message for agent %s' % dst)
new_map = parser._map.copy()
# Remove unnecessary info
del new_map['_outpost_dst']
new_map['dst'] = dst
if src:
new_map['src'] = src
del new_map['_outpost_src']
if tag:
new_map['tag'] = tag
del new_map['_outpost_tag']
else:
del new_map['tag']
# Store message
raw_msg = zoe.MessageBuilder(new_map, parser._map).msg()
AgentMessage.create(agent=dst, message=raw_msg)
class TestBase(unittest.TestCase):
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 setUp(self):
self.app = app.test_client()
self.populate_database()
def request(self, method, url, auth=None, json_data=None, **kwargs):
headers = kwargs.get('headers', {})
if auth:
# Add the auth header if credentials are specified.
headers['Authorization'] = 'Basic %s' % b64encode(bytes(auth[0] + ':' + auth[1], 'utf-8')).decode('ascii')
if json:
headers['Content-Type'] = 'application/json'
kwargs['data'] = json.dumps(obj=json_data)
#print(kwargs['data'])
kwargs['headers'] = headers
#print(kwargs['headers'])
return self.app.open(url, method=method, **kwargs)
from datetime import datetime
from peewee import SqliteDatabase, CharField, DateTimeField, Model
db = SqliteDatabase("clipboard.db")
class Paste(Model):
text = CharField()
date = DateTimeField()
class Meta:
database = db
db.create_tables([Paste])
def save_new_paste(text):
paste = Paste(text=text, date=datetime.now())
paste.save()
def get_lastest_paste():
for paste in Paste.select().order_by(Paste.date.desc()):
return paste.text
def get_pastes():
return Paste.select().order_by(Paste.date.desc())
import sqlite3
from peewee import Model, SqliteDatabase, DateTimeField, ForeignKeyField, FloatField, CharField
from datetime import datetime
DB = SqliteDatabase('finance-manager.db')
DB.connect()
class User(Model):
username = CharField(primary_key=True)
class Meta:
database = DB
class Amount(Model):
user = ForeignKeyField(User, backref='amount')
amount = FloatField()
date_time = DateTimeField()
class Meta:
database = DB
DB.create_tables([User, Amount])
DB.close()
ask_volume_1=self.ask_volume_1,
gateway_name=self.gateway_name,
)
if self.bid_price_2:
tick.bid_price_2 = self.bid_price_2
tick.bid_price_3 = self.bid_price_3
tick.bid_price_4 = self.bid_price_4
tick.bid_price_5 = self.bid_price_5
tick.ask_price_2 = self.ask_price_2
tick.ask_price_3 = self.ask_price_3
tick.ask_price_4 = self.ask_price_4
tick.ask_price_5 = self.ask_price_5
tick.bid_volume_2 = self.bid_volume_2
tick.bid_volume_3 = self.bid_volume_3
tick.bid_volume_4 = self.bid_volume_4
tick.bid_volume_5 = self.bid_volume_5
tick.ask_volume_2 = self.ask_volume_2
tick.ask_volume_3 = self.ask_volume_3
tick.ask_volume_4 = self.ask_volume_4
tick.ask_volume_5 = self.ask_volume_5
return tick
DB.connect()
DB.create_tables([DbBarData, DbTickData])
#!/usr/bin/env python
import config
from peewee import SqliteDatabase, Model, FloatField, DateTimeField
database = SqliteDatabase(config.DB_FILE)
class BaseModel(Model):
class Meta:
database = database
class DataLog(BaseModel):
temp = FloatField()
hum = FloatField()
timestamp = DateTimeField(index=True)
class Meta:
order_by = ('timestamp',)
if __name__ == "__main__":
database.connect()
database.create_tables([DataLog])
database = SqliteDatabase('kongonline.sqlite', check_same_thread=False)
database.connect()
class Stats(Model):
time_t = IntegerField(null=True)
online = IntegerField(null=True)
games = IntegerField(null=True)
class Meta:
database = database
db_table = 'stats'
def write_info(time, online, games):
Stats.create(time_t=time, online=online, games=games)
def get_last(num=10):
ret = []
for item in Stats.select().order_by(Stats.time_t.desc()).limit(num):
time = dt.fromtimestamp(item.time_t).strftime('%y-%m-%d|%H:%M:%S')
ret.append((time, item.online, item.games))
return ret
def count_entries():
return Stats.select().count()
database.create_tables((Stats,), safe=True)
def setup_db(name):
db = SqliteDatabase(name)
db.create_tables([Location, Statistics])
class ZoneBook(object):
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 get_agents(self):
""" Return a list of agents.
Note that this returns the object rather than just the name in
case other information is wanted.
"""
return list(AgentZone.select())
def get_agent_location(self, name):
""" Get the location for a given agent.
Returns None if it does not exist.
name - name of the agent
"""
scoutlog.info('obtaining location of agent %s' % name)
try:
return AgentZone.get(AgentZone.name == name).location.name
except Exception as e:
scoutlog.warning('could not get location of agent %s' % name)
return None
def get_agents_in(self, outpost_id):
""" Get the agents found in a given location.
outpost_id - outpost id to search for
"""
scoutlog.info('obtaining agents located in %s' % outpost_id)
try:
outpost = OutpostZone.get(OutpostZone.name == outpost_id)
except OutpostZone.DoesNotExist as e:
scoutlog.warning('outpost %s not found in zone book' % outpost_id)
return []
return outpost.agents
def get_agent_names_in(self, outpost_id):
""" Get the agent names found in a given location.
outpost_id - outpost id to search for
"""
scoutlog.info('obtaining agent names located in %s' % outpost_id)
try:
outpost = OutpostZone.get(OutpostZone.name == outpost_id)
except OutpostZone.DoesNotExist as e:
scoutlog.warning('outpost %s not found in zone book' % outpost_id)
return []
return [agent.name for agent in outpost.agents]
def get_outposts(self):
""" Return a list of outposts.
Note that this returns the object rather than just the name in
case other information is wanted.
"""
return list(OutpostZone.select())
def is_outpost_running(self, name):
""" Check if an outpost is known to be running or not.
Returns boolean value.
name - name of the outpost
"""
scoutlog.info('checking if outpost %s is currently running' % name)
try:
return OutpostZone.get(OutpostZone.name == name).is_running
except OutpostZone.DoesNotExist as e:
scoutlog.warning('outpost %s not found in zone book' % name)
return None
def move_agent(self, name, location):
""" Move an agent to the given location.
name - name of the agent
location - new location of the agent
"""
scoutlog.info('moving agent %s to %s' % (name, location))
try:
outpost = OutpostZone.get(OutpostZone.name == location)
query = AgentZone.update(location=outpost).where(
AgentZone.name == name)
query.execute()
return True
except Exception as e:
scoutlog.exception('could not update location of agent %s' % name)
return False
def refresh_agents(self, agent_list):
""" Refresh the agents table with those in the given list.
Agents that do not exist will be created, while agents that no
longer exist will be removed.
agent_list - list of agent names
"""
scoutlog.info('refreshing agent list')
current_list = [agent.name for agent in AgentZone.select()]
diff_list = list(set(current_list) - set(agent_list))
# Add new agents
central, created = OutpostZone.get_or_create(name='central')
for agent in agent_list:
new, created = AgentZone.get_or_create(
name=agent,
defaults={'location': central})
# Remove non-existing agents
if diff_list:
query = AgentZone.delete().where(AgentZone.name << diff_list)
query.execute()
def refresh_outposts(self, outpost_list):
""" Refresh the outposts table with those in the given list.
Outposts that do not exist will be created. Outposts that no longer
exist are kept for historic purposes and to prevent issues with
keys.
outpost_list - ConfigParser instance of the outpost list
"""
scoutlog.info('refreshing outpost list')
# Add new outposts
for outpost in filter(
(lambda o: o.startswith('outpost ')), outpost_list.sections()):
name = outpost.replace('outpost ', '', 1)
outpost, created = OutpostZone.get_or_create(name=name)
def set_outpost_running(self, name, value):
""" Change the `is_running` flag of an outpost to indicate whether it
has been started or not.
name - name of the outpost to change
value - boolean indicating whether it is running or not
"""
scoutlog.info('setting running status of outpost %s to: %r' % (
name, value))
try:
query = OutpostZone.update(is_running=value).where(
OutpostZone.name == name)
query.execute()
return True
except Exception as e:
scoutlog.exception('could not set running status of outpost %s' %
name)
return False
def store_agent_resources(self, name, **info):
""" Update the resources for a given agent.
If no record for an outpost exists, it will be created.
name - name of the agent
info - parameters containing the information
"""
scoutlog.info('updating resources of agent %s' % name)
# Create agent record if necessary
agent, created = AgentZone.get_or_create(
name=name,
defaults=info)
if created:
# Was updated when created
return True
# Update information
try:
query = AgentZone.update(**info).where(
AgentZone.name == name)
query.execute()
return True
except Exception as e:
scoutlog.exception('error while updating resources of %s' % name)
return False
def open(self, *args, **kwargs):
cmd = [s.replace('\ ', ' ') for s in
re.split(r'(?<!\\) ', self.command)] + list(args)
print(str(cmd))
ukwargs = self.DEFAULT_POPEN_ARGS.copy()
if self.shell:
ukwargs.update(self.SHELL_ALL_DEVNULL)
ukwargs.update(kwargs)
return Popen(cmd, **ukwargs)
class Meta:
database = os_db
# safely create FileCommand table, its const records are referenced in FileType
os_db.create_tables([FileCommand], safe=True)
class FileType(BaseModel):
type = CharField()
mime = CharField(null=True, default=None)
command = ForeignKeyField(FileCommand, null=True, default=None)
DIR = Record(id=1, type="Directory")
PDF = Record(id=2, type="PDF", command=FileCommand.OPEN)
TXT = Record(id=3, type="TXT", command=FileCommand.OPEN)
XML = Record(id=4, type="XML", command=FileCommand.OPEN)
ASP = Record(id=5, type="AS Project", command=FileCommand.ANDROID_STUDIO)
OTH = Record(id=10, type="unknown file")
from peewee import BooleanField, IntegerField, Model, SqliteDatabase, TextField
db = SqliteDatabase('gen/data.db')
class User(Model):
user_id = IntegerField(unique=True)
chat_id = IntegerField()
first_name = TextField()
last_name = TextField(null=True)
is_member = BooleanField() # Current status of user (member/left)
class Meta:
database = db
db.create_tables([User], safe=True)
operator = 'TELE2'
# network status
network_status = 'unknown'
if network_info['State'] == 'HomeNetwork':
network_status = 'online'
modem_str += 'IMEI: {}, SIM IMSI: {}, Status: {}, Device: {}, Operator: {}, Network: {}, LAC: {}, CID: {}'.format(
state_machine.GetIMEI(),
state_machine.GetSIMIMSI(),
network_status,
state_machine.GetConfig()['Device'],
operator,
network_info['NetworkCode'],
network_info['LAC'],
network_info['CID']
)
modem_str += '\n'
except gammu.ERR_TIMEOUT:
return 'Modem timeout problem, please reload page'
return modem_str
def main():
cli()
if __name__ == '__main__':
db.connect()
db.create_tables([Message, Number], safe=True)
main()
db.close()
class TestModel(unittest.TestCase):
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 tearDown(self):
self.db.close()
self.db = None
def test_group_get(self):
os = Group.select()
self.assertEqual(len(os), 3)
o = Group.select().where(Group.name == 'group0name').get()
self.assertEqual(o, self.group0)
o = Group.select().where(Group.id == self.group0.id).get()
self.assertEqual(o, self.group0)
self.assertTrue(o.owner_id)
def test_group_memberships(self):
self.assertTrue(self.group0.is_member(self.user0))
self.assertTrue(self.group0.is_member(self.user1))
self.assertTrue(self.group1.is_member(self.user0))
self.assertFalse(self.group1.is_member(self.user1))
self.assertFalse(self.group2.is_member(self.user0))
self.assertTrue(self.group2.is_member(self.user1))
def test_get_reg_ids_by_user_id(self):
user_id = self.user0.id
devices = Device.select(Device, User).join(User).where(User.id == user_id)
self.assertEqual(len(devices), 1)
reg_ids = [d.reg_id for d in devices]
self.assertEqual(reg_ids, ['device0regid'])
class Operation(BaseModel):
timestamp = DateTimeField(primary_key=True)
user = ForeignKeyField(User, related_name="operations", null=True)
chamber = ForeignKeyField(Chamber, related_name='chamber', null=True)
action = CharField(null=True)
locker = CharField(default='Dev Locker')
def __repr__(self):
return '<TRANSACTION> {}'.format(self.timestamp)
@staticmethod
@db.atomic()
def add_operation(chamber=None, action=None, user=None):
now = datetime.utcnow()
op = Operation.create(timestamp=now, chamber=chamber,
action=action, user=user)
op.save()
return op
# this creates indexes, not sure why
tables = [User, Operation, Chamber]
db.create_tables(tables, True)
# ERASE TABLES
def drop_tables():
try:
db.drop_tables(tables)
except:
pass
database = db
def get_user(user_id):
try:
user = User.get(User.id == user_id)
except User.DoesNotExist:
user = User.get(User.id == 0)
return user
if __name__ == "__main__":
if User.table_exists():
print("Database Already Exists")
sys.exit()
db.connect()
db.create_tables([User])
User.insert_many([
{"id": 0, "name": "Invlid User", "langpair": "!!|!!"},
{"id": 120755813, "name": "Boris", "langpair": "ru|en"},
{"id": 93649293, "name": "Elizaveta", "langpair": "ru|en"},
{"id": 77815902, "name": "James", "langpair": "en|ru"},
{"id": 68382468, "name": "Jill", "langpair": "en|ru"},
{"id": 82080280, "name": "Kyle", "langpair": "en|ru", "admin": True},
{"id": 117778855, "name": "Mickey", "langpair": "en|ru"},
{"id": 97384423, "name": "Nataly", "langpair": "__|__"},
{"id": 96351689, "name": "Transbotor", "langpair": "!!|!!"},
]).execute()
db.close()
from peewee import SqliteDatabase, Model, \
CharField, IntegerField, DateField, BlobField
db = SqliteDatabase(':memory:', threadlocals=True)
class BaseModel(Model):
class Meta:
database = db
class Vehicle(BaseModel):
description = CharField(null=False)
cylinder = IntegerField(null=False)
brand = CharField(null=False)
year = DateField(formats="%Y")
owner = CharField(null=False)
photo = BlobField(null=True)
db.connect()
db.create_tables([Vehicle])