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:')