logger.debug("model.py DEBUG messages enabled!")
import hashlib
from datetime import datetime
import traceback
import peewee as pw
from playhouse.signals import Model, pre_save
from peewee import SqliteDatabase
import config
import operator
import re
DoesNotExist = pw.DoesNotExist
SelectQuery = pw.SelectQuery
#we need these two lines or SQLite will complain about interthread access
db = SqliteDatabase('%s/peewee.db' % CURRENT_DIR, threadlocals=True)
db.connect()
def better_get(self, **kwargs):
if kwargs:
return self.filter(**kwargs).get()
clone = self.paginate(1, 1)
try:
return clone.execute().next()
except StopIteration:
raise self.model_class.DoesNotExist(
'instance matching query does not exist:\nSQL: %s\nPARAMS: %s' %
(self.sql()))
def __init__(self, *args, **kwargs):
super(TestStrangerService, self).__init__(*args, **kwargs)
self.database = SqliteDatabase(':memory:')
import datetime
from peewee import SqliteDatabase, Model, CharField, IntegerField, DateTimeField
import os
db = SqliteDatabase(os.getenv('DB_PATH', 'discord.db'))
### Logic
def meme_exists(url):
return Meme.select().where(Meme.url == url).count() > 0
def pup_exists(url):
return Pup.select().where(Pup.url == url).count() > 0
def meow_exists(url):
return Meow.select().where(Meow.url == url).count() > 0
def fridge_exists(url):
return Fridge.select().where(Fridge.url == url).count() > 0
def get_meme_sequence():
try:
memeSeq = Sequence.select().where(Sequence.name == 'meme').get()
memeCount = Meme.select().count()
curSeq = memeSeq.index + 1
if curSeq > memeCount:
curSeq = 1
Sequence.update(index=curSeq).where(Sequence.name == 'meme').execute()
return curSeq
except Sequence.DoesNotExist:
memeSeq = Sequence(name='meme')
memeSeq.save()
# -*- coding: utf-8 -*-
"""
Models to store scraped data in a database.
"""
import inspect
from peewee import SqliteDatabase, Model
from peewee import CompositeKey, FloatField, IntegerField, TextField
from playhouse.sqliteq import SqliteQueueDatabase
db = SqliteDatabase("{{cookiecutter.database}}.db")
# db = SqliteQueueDatabase("{{cookiecutter.database}}.db", autostart=True)
class BaseModel(Model):
class Meta:
database = db
def __getitem__(self, key):
return getattr(self, key)
def __setitem__(self, key, value):
return setattr(self, key, value)
def __delitem__(self, key):
return setattr(self, key, None)
@classmethod
from peewee import SqliteDatabase, Model, UUIDField, TextField, IntegerField, DateTimeField, DateField, AutoField
import uuid
from datetime import datetime
sqlite_db = SqliteDatabase(
'/media/aji/datautama.NeTv3SD/Development/python/project/todo-cli/db/todo.db3',
pragmas={'journal_mode': 'wal'})
class Todo(Model):
class Meta:
database = sqlite_db
id = IntegerField(
primary_key=True) #UUIDField(primary_key=True, default=uuid.uuid4())
todo = TextField()
priority = IntegerField(default=0)
deadline = DateField()
status = IntegerField(default=0)
created_at = DateTimeField(default=datetime.now())
def __str__(self):
return "| " + str(self.id) + " | " + self.todo + " | " + str(
self.priority) + " | " + str(self.deadline)[0:10] + " | " + (
'done' if self.status == 1 else 'undone') + " | "
# pylint: disable=C0103,C0111,R0903
'''
Peewee ORM, sqlite and Python
what is this 'peewee.' preamble? -> only if you do a * import
class = table
model = file where you are saving the classes/tables -> like a db essentially
'''
# C:\Users\v-ollock\AppData\Local\Programs\Python\Python37-32\Lib\sqlite3
# http://zetcode.com/python/peewee/
from peewee import SqliteDatabase, Model, CharField, DecimalField
db = SqliteDatabase('Gibbs.db')
# db.connect()
# db.execute_sql("PRAGMA foreign_keys = ON;")
class BaseModel(Model):
"""Peewee meta class. Assign db and table"""
class Meta:
database = db # database is a keyword
class Customer(BaseModel):
""" class = model = table"""
# customer_id = IdentityField() or AutoField()
# the videos said use your 'business sense' for primary key
name = CharField(primary_key=True, max_length=50)
last_name = CharField(max_length=50)
home_address = CharField(max_length=50)
import datetime
from peewee import Model, ForeignKeyField, CharField, SqliteDatabase
db = SqliteDatabase('amazon.db')
class User(Model):
telegramId = CharField(unique=True)
class Meta:
database = db # this model uses the "amazon.db" database
class Tracking(Model):
user = ForeignKeyField(User, backref='user_id')
asin = CharField()
status = CharField()
class Meta:
database = db # this model uses the "amazon.db" database
# Create tables
db.connect()
db.create_tables([User, Tracking])
def __init__(self, url=None):
self.url = url
self.db = SqliteDatabase(None)
import logging
import os
from peewee import DeleteQuery
from peewee import Model, SqliteDatabase, CharField, IntegerField
import config
logger = logging.getLogger("DB")
# Config
conf = config.Config()
db_path = conf.settings['queuefile']
database = SqliteDatabase(db_path, threadlocals=True)
class BaseQueueModel(Model):
class Meta:
database = database
class QueueItemModel(BaseQueueModel):
scan_path = CharField(max_length=256, unique=True, null=False)
scan_for = CharField(max_length=64, null=False)
scan_section = IntegerField(null=False)
scan_type = CharField(max_length=64, null=False)
def create_database(db, db_path):
if not os.path.exists(db_path):
db.create_tables([QueueItemModel])
logger.info("Created Plex Autoscan database tables.")
def connect(db):
import os
import datetime
from pathlib import Path
from peewee import SqliteDatabase, Model, CharField, IntegerField, DateTimeField
pwd = Path(__file__).parent
db = SqliteDatabase(str(Path(pwd) / "../lufly/sys_data/sys_table.sqlite"))
class BaseModel(Model):
class Meta:
database = db
class CharPhoneTable(BaseModel):
id = IntegerField(primary_key=True)
char = CharField()
xhe = CharField()
full = CharField()
zrm = CharField()
lu = CharField()
bingji = CharField()
priority = IntegerField()
updatedt = DateTimeField("%Y-%m-%d %H:%M:%S")
def __str__(self):
return f"<{self.id},{self.char},{self.xhe},{self.full},{self.zrm},{self.lu},{self.bingji},{self.priority},{self.updatedt}>"
class CharHeShapeTable(BaseModel):
from Coins.CoinBase import CoinBase
from Coins.coinUtils import getAnswer
from db.dbUtils import addUser, getUserCoinList, addCoinToList, addUserList, getUserCoinListPrice, removeCoinFromList
with open('config.json', 'r') as confile:
config = json.load(confile)
ptrnOneCoin = r"(\A[a-zA-Z-]+\Z)"
ptrnSomeCoins = r"\A(\d*.?\d*)\s([A-Za-z-]+\Z)"
urlCmcApi = config["coinmarketcap"]["url"] + config["coinmarketcap"]["limit"]
coinBase = CoinBase("coinList.json", urlCmcApi)
API_TOKEN = config["bot"]["token"]
db = SqliteDatabase('bot_database.db')
db.connect()
bot = telebot.TeleBot(API_TOKEN)
@bot.message_handler(commands=['start', 'help'])
def start(m):
bot.send_message(
m.chat.id, "Получи курс криптовалюты в USD.\n"
"Введи :\n"
"\"Bitcoin\" - узнай курс Биткоина.\n"
"\"23 bitcoin-cash\" - узнай сколько стоит 23 Биткоин Кэш.\n"
"\"0.005 Ethereum\" - узнай сколько стоит 0.005 Эфира.\n"
"Добавлена новая функция /mylist. Введи /mylist чтобы узнать больше.\n"
"Не забудь ввести /help, чтобы обновить клавиатуру.\n"
"Курс берётся с сайта coinmarketcap.com.\n"
from peewee import (
SqliteDatabase, PostgresqlDatabase, Model, IntegerField,
FloatField, BooleanField, TextField,
)
DB = SqliteDatabase('predictions.db')
class Prediction(Model):
observation_id = IntegerField(unique=True)
observation = TextField()
proba = FloatField()
true_class = IntegerField(null=True)
class Meta:
database = DB
DB.create_tables([Prediction], safe=True)
""""""
from peewee import SqliteDatabase, Model, CharField, DateTimeField, FloatField
#from .constant import Exchange, Interval
#from .object import BarData, TickData
#from .utility import get_file_path
from vnpy.trader.constant import Exchange, Interval
from vnpy.trader.object import BarData, TickData
from vnpy.trader.utility import get_file_path
DB_NAME = "database.db"
dbname = str(get_file_path(DB_NAME))
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()
def db_load(self):
"load db"
db_path = os.path.join(sys_conf._basedir, self.m_conf['db_path'])
db = SqliteDatabase(db_path, **sys_conf.DATABASE_CONNECT_OPTIONS)
db_proxy.initialize(db)
from peewee import SqliteDatabase, Model, CharField, ForeignKeyField
from settings import DB_FILE_PATH
db = SqliteDatabase(DB_FILE_PATH, pragmas={'foreign_keys': 1})
class BaseModel(Model):
class Meta:
database = db
class Group(BaseModel):
group_name = CharField(unique=True)
class User(BaseModel):
telegram_id = CharField(unique=True)
first_name = CharField()
last_name = CharField()
status = CharField()
class Links(BaseModel):
user = ForeignKeyField(User, backref='links')
group = ForeignKeyField(Group, backref='links')
class Equipment(BaseModel):
it_id = CharField(unique=True)
pos_in_buh = CharField()
from peewee import SqliteDatabase, Model
database = SqliteDatabase(None)
def init(db_name: str):
database.init(db_name)
class BaseModel(Model):
class Meta:
database = database
class Meta:
database = SqliteDatabase(constants.get_gateway_database_file(),
pragmas={'foreign_keys': 1})
def __init__(self):
self.movies = SqliteDatabase('movies.db')
def init_sqlite(settings: dict):
database = settings["database"]
path = str(get_file_path(database))
db = SqliteDatabase(path)
return db
from peewee import (SqliteDatabase, Model, CharField, TextField)
db = SqliteDatabase('bookmarks.db')
class Bookmarks(Model):
title = CharField()
url = TextField()
notes = TextField(null=True)
date_added = CharField()
class Meta:
database = db
class PeeweeDatabaseManager:
def __init__(self):
self.db = db
def __del__(self):
self.db.close()
def create_table(self):
with self.db:
self.db.create_tables([Bookmarks])
def add(self, data: dict):
with self.db:
m = Bookmarks.create(title=data['title'],
url=data['url'],
notes=data['notes'],
import os
import datetime
from peewee import CharField, DateTimeField, IntegerField
from peewee import TextField, ForeignKeyField
from peewee import Model
from peewee import SqliteDatabase
from playhouse.shortcuts import model_to_dict
from cianmon.config import CFG_DIR, DATABASE
database = SqliteDatabase(DATABASE)
class BaseModel(Model):
class Meta:
database = database
@classmethod
def get_visible_fields(cls):
return getattr(cls, "_visible_fields", ())
def to_dict(self):
return {
key: value
for key, value in model_to_dict(self).items()
if key in self.get_visible_fields()
}
class Flat(BaseModel):
import sqlite3
conn = sqlite3.connect('golden-eye.db')
cur = conn.cursor()
# cur.execute("SELECT * FROM xrates")
rows = cur.fetchall()
for row in rows:
print(row)
conn.close()
from peewee import (SqliteDatabase)
db = SqliteDatabase('golden-eye.db')
# class XRate(Model):
# class Meta:
# database = db
# db_table = 'xrates'
# index = (
# (('from_currency', 'to_currency'), True),
# )
#
# from_currency = IntegerField()
# to_currency = IntegerField()
# rate = DoubleField()
# update = DateTimeField(default=peewee_datetime.datetime.now)
from other import models
models.XRate.create_table()
models.XRate.create(from_currency=980, to_currency=840, rate=25)
from peewee import SqliteDatabase, Model, CharField, IntegerField, ForeignKeyField, DateTimeField, DateField, \
DecimalField, FloatField
# nome do arquivo do banco de dados
# Connect to a SQLite local database.
# database = SqliteDatabase('sucellus.db')
# SQLite database using WAL journal mode and 64MB cache.
database = SqliteDatabase('hostel.db',
pragmas={
'journal_mode': 'wal',
'cache_size': -1024 * 64
})
class ModelBase(Model): # classe modelo
"""
Classe que cria a Entidade modelo a ser usada no projeto através da biblioteca peewee.
Best practice: define a base model class that points at the database object you wish to use,
and then all your models will extend it:
"""
class Meta:
"""
Meta classe que ao ser herdada define o metodo de conexao atravez do objeto database
"""
database = database
class Address(ModelBase):
"""
Classe de Endereco para mapeamento
"""
from peewee import Model, CharField, Database, Check, SqliteDatabase, DecimalField, ForeignKeyField, AutoField
from .config import db_path
import os
from apis.conversion_dicts import months_string, months_int
db = SqliteDatabase(db_path)
# The base model is used to link all subsequent models to the database
class BaseModel(Model):
class Meta:
database = db
class Park(BaseModel):
park_id = CharField(unique=True,
constraints=[Check('length(park_id) <= 500')])
park_name = CharField(null=False,
constraints=[Check('length(park_name) <= 500')])
park_city = CharField(null=False,
constraints=[Check('length(park_city) <= 500')])
park_state = CharField(null=False,
constraints=[Check('length(park_state) <= 500')])
park_description = CharField(
null=False, constraints=[Check('length(park_description) <= 1000')])
latitude = DecimalField(null=False,
constraints=[Check('length(latitude) <= 500')])
longitude = DecimalField(null=False,
constraints=[Check('length(longitude) <= 500')])
def __str__(self):
import os
from flask import Flask, g
from peewee import SqliteDatabase
app = Flask(__name__)
# config
app.config.update(
dict(
SECRET_KEY='my_session',
TYTUL='Expenses',
DATABASE=os.path.join(app.root_path, 'test.db'),
))
print("my_path " + app.root_path)
# db instance
base = SqliteDatabase(app.config['DATABASE'])
@app.before_request
def before_request():
g.db = base
g.db.connection()
@app.after_request
def after_request(response):
g.db.close()
return response
from peewee import CharField, DateTimeField, SqliteDatabase, Model
import datetime
from flask_peewee_crud import CrudConfig
db = SqliteDatabase('my_app.db')
class BaseModel(Model):
class Meta:
database = db
config = CrudConfig()
config.COLLECTION_MAX_RESULTS_PER_PAGE = 500
class Person(BaseModel):
crud_config = config
name = CharField()
email = CharField()
create_datetime = DateTimeField(default=datetime.datetime.now, null=True)
def __init__(self, team, db_name):
self.config = team
if db_name == "snoohelper_test.db":
user_agent = "Snoohelper 0.3 by /u/Santi871 - unittesting"
else:
user_agent = "Snoohelper 0.3 by /u/Santi871 - bot of /r/" + self.config.subreddit
if isinstance(db, Proxy):
db.initialize(
SqliteDatabase(db_name,
threadlocals=True,
check_same_thread=False,
timeout=30))
db.connect()
try:
db.create_tables(models=[
UserModel, AlreadyDoneModel, SubmissionModel,
UnflairedSubmissionModel
])
except OperationalError:
pass
db.close()
self.db_name = db_name
self.halt = False
self.webhook = self.config.webhook
if self.config.reddit_refresh_token:
self.r = praw.Reddit(
user_agent=user_agent,
client_id=REDDIT_APP_ID,
client_secret=REDDIT_APP_SECRET,
refresh_token=self.config.reddit_refresh_token)
self.thread_r = praw.Reddit(
user_agent=user_agent,
client_id=REDDIT_APP_ID,
client_secret=REDDIT_APP_SECRET,
refresh_token=self.config.reddit_refresh_token)
else:
self.r = praw.Reddit(user_agent=user_agent,
client_id=REDDIT_APP_ID,
client_secret=REDDIT_APP_SECRET,
redirect_uri=REDDIT_REDIRECT_URI)
self.thread_r = praw.Reddit(user_agent=user_agent,
client_id=REDDIT_APP_ID,
client_secret=REDDIT_APP_SECRET,
redirect_uri=REDDIT_REDIRECT_URI)
self.subreddit = self.thread_r.subreddit(self.config.subreddit)
self.subreddit_name = self.subreddit.display_name
self.already_done_helper = AlreadyDoneHelper()
if db_name != "snoohelper_test.db":
t = Thread(target=self._init_modules, daemon=True)
t.start()
else:
self._init_modules()
Here we define the schema
Use logging for messages so they can be turned off
"""
import logging
from peewee import Model, CharField, BooleanField, FloatField, SqliteDatabase
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
logger.info('Here we define our data (the schema)')
logger.info('First name and connect to a database (sqlite here)')
logger.info('The next 3 lines of code are the only database specific code')
database = SqliteDatabase('customers.db')
database.connect()
database.execute_sql('PRAGMA foreign_keys = ON;') # needed for sqlite only
# if you wanted to use heroku postgres:
#
# psycopg2
#
# parse.uses_netloc.append("postgres")
# url = parse.urlparse(os.environ["DATABASE_URL"])
#
# conn = psycopg2.connect(
# database=url.path[1:],
# user=url.username,
# password=url.password,
# host=url.hostname,
from peewee import SqliteDatabase
from Models import RealtyItem
db = SqliteDatabase('database.db')
db.drop_tables([RealtyItem])
db.create_tables([RealtyItem])
def setUpClass(cls):
SetTestMode()
cls.test_db = SqliteDatabase(':memory:')
