class AsyncDatabase: """ @type manager: Manager @type database: peewee_async.PostgresqlDatabase """ DATABASE_NAME = 'test_db' manager = None database = peewee_async.PostgresqlDatabase(None) @classmethod async def setup_database(cls, app): app.database = cls.database cls.database.init(database=cls.DATABASE_NAME) app.database.set_allow_sync(False) app.objects = cls.manager = Manager(app.database) @classmethod def psycopg_exec(cls, query): with psycopg2.connect(host='localhost') as conn: conn.set_isolation_level( psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT) with conn.cursor() as cursor: cursor.execute(query) @classmethod def create(cls): cls.psycopg_exec('CREATE DATABASE {}'.format(cls.DATABASE_NAME)) @classmethod def drop(cls): cls.psycopg_exec('DROP DATABASE IF EXISTS {}'.format( cls.DATABASE_NAME))
def database(): db = peewee_async.PostgresqlDatabase( host=config.Config.db_host, port=config.Config.db_port, database=config.Config.db_name, user=config.Config.db_user, password=config.Config.db_password, ) yield db
def init_db(db_name: str, db_user: str, db_pass: str, host: str, port: int): db = peewee_async.PostgresqlDatabase(db_name, user=db_user, password=db_pass, host=host, port=port) db_proxy.initialize(db) Ticker.create_table(True) Price.create_table(True) Insider.create_table(True) Trade.create_table(True) objects = peewee_async.Manager(db_proxy) return objects
def __init__(self, dbname, dbuser, dbpassword, dbhost): """Adds self to messages and event's `data` field. Through this instance you can access peewee_async.Manager instance (data["peewee_async"].manager). This plugin should be included first! """ super().__init__() self.database = peewee_async.PostgresqlDatabase(dbname, user=dbuser, password=dbpassword, host=dbhost) self.models = [] self.create_models() self.manager = peewee_async.Manager(self.database) database.set_allow_sync(False)
def init_db(db_name): try: from local_settings import DATABASE except ImportError: from settings import DATABASE db = peewee_async.PostgresqlDatabase( database=DATABASE['database'], user=DATABASE['user'], password=DATABASE['password'], host=DATABASE['host'], ) # db = peewee.PostgresqlDatabase(db_name, user='******', password='******', host='localhost') db.set_allow_sync(True) db.create_tables([ Wallet, MultisigInfo, Proposal, ProposalDecision, ])
class PostManagerTestCase(unittest.TestCase): database = peewee_async.PostgresqlDatabase('test') manager = PostManager(database) model = Post loop = None @classmethod def setUpClass(cls): Post.create_table() @classmethod def tearDownClass(cls): Post.drop_table() def setUp(self): self.loop = setup_test_loop() def tearDown(self): Post.delete().execute() self.loop.run_until_complete(self.manager.manager.close()) teardown_test_loop(self.loop) @unittest_run_loop async def test_get_by_id(self): data = dict(title='title') instance = await self.manager.create(**data) retrieved = await self.manager.get_by_id(instance.id) self.assertEqual(instance, retrieved) @unittest_run_loop async def test_create(self): data = dict(title='title', text='text') instance = await self.manager.create(**data) self.assertEqual(data, dict(title=instance.title, text=instance.text))
import peewee import peewee_async from playhouse.fields import ManyToManyField from feed import settings database = peewee_async.PostgresqlDatabase(**settings.DATABASE) class Speaker(peewee.Model): first_name = peewee.CharField() last_name = peewee.CharField() photo = peewee.CharField() class Meta: database = database db_table = 'meetups_speaker' def full_name(self): return '{} {}'.format(self.first_name, self.last_name) class Sponsor(peewee.Model): logo = peewee.CharField() class Meta: database = database db_table = 'meetups_sponsor' DeferredMeetupSponsor = peewee.Proxy()
from datetime import date, datetime import peewee_async from aiohttp import web from playhouse.shortcuts import model_to_dict import config from managers.data import DataManager from models.data import Data # logging.config.dictConfig(config.debug_dict_config) logging.config.dictConfig(config.info_dict_config) logger = logging.getLogger('endpoint') database = peewee_async.PostgresqlDatabase('test') manager = DataManager(database) routes = web.RouteTableDef() def json_serial(obj): """ JSON serializer for objects not serializable(datetime) by default json code """ if isinstance(obj, (datetime, date)): return obj.isoformat() raise TypeError(f"Type {type(obj)} not serializable") @routes.view('/{name}') class DataHandler(web.View):
import peewee import peewee_async database = peewee_async.PostgresqlDatabase(None) class BaseModel(peewee.Model): """ Base model with db Meta """ class Meta: database = database
import asyncio import datetime from enum import unique import peewee_async from peewee import ForeignKeyField, Model, CharField, TextField, DateTimeField from wtforms.fields.core import BooleanField db = peewee_async.PostgresqlDatabase( "blog_tornado", user="******", password="******", host="127.0.0.1", ) class BaseModel(Model): class Meta: database = db class User(BaseModel): username = CharField(max_length=20, unique=True) email = CharField(max_length=50, unique=True) password = CharField() first_name = CharField(max_length=20) middle_name = CharField(max_length=20, null=True) last_name = CharField(max_length=20) created_at = DateTimeField(default=datetime.datetime.now) is_active = BooleanField(default=True) is_superuser = BooleanField(default=False) last_login = DateTimeField(null=True) def __str__(self): return self.username
import logging import os import peewee_async from tornado.options import options, parse_command_line psql_db = peewee_async.PostgresqlDatabase('seabattle', user='******', password='******', host='localhost') objects = peewee_async.Manager(psql_db) objects.database.allow_sync = logging.ERROR options.logging = 'error' options.log_file_prefix = os.path.join(os.path.dirname(__file__), "error.log") parse_command_line()
import logging from datetime import datetime from typing import List import peewee import peewee_async from hackernews.app.config import Config log = logging.getLogger(__name__) db = peewee_async.PostgresqlDatabase( host=Config.db_host, port=Config.db_port, database=Config.db_name, user=Config.db_user, password=Config.db_password, ) class BaseModel(peewee.Model): class Meta: database = db class Post(BaseModel): title = peewee.CharField(max_length=255, unique=True) url = peewee.CharField(max_length=255, unique=True) created = peewee.DateTimeField(default=datetime.now, unique=True) def __repr__(self):
import os import peewee import peewee_async DB_NAME = os.environ.get('DB_NAME') DB_USER = os.environ.get('DB_USER') DB_PASSWORD = os.environ.get('DB_PASSWORD') DB_IP = os.environ.get('DB_IP', '127.0.0.1') DB_PORT = os.environ.get('DB_PORT', 5432) database = peewee_async.PostgresqlDatabase(DB_NAME, user=DB_USER, password=DB_PASSWORD, host=DB_IP, port=DB_PORT) class BaseModel(peewee.Model): """Base class for peewee so it can manage the database connection for us""" class Meta: database = database # These must match the name of the input on the spawner, and the <input> fields nprocs = peewee.IntegerField(default=1) # How many CPUs memory = peewee.IntegerField(default=1) # How much memory can they use? runtime = peewee.IntegerField(default=1) # Maximum runtime gpu = peewee.BooleanField(default=False) # Should they have a GPU? class User(BaseModel): """Represents a docker image""" # What is the username? username = peewee.CharField(unique=True)
import peeweedbevolve import peewee import peewee_async from settings import DATABASE database = peewee_async.PostgresqlDatabase( database=DATABASE['database'], user=DATABASE['user'], password=DATABASE['password'], host=DATABASE['host'], ) database.set_allow_sync(True) objects = peewee_async.Manager(database)
from os import getenv import peewee import peewee_async database = { 'database': getenv('DB_DATABASE'), 'user': getenv('DB_USER'), 'password': getenv('DB_PASSWORD'), 'host': getenv('DB_HOST'), 'port': getenv('DB_PORT', '5432'), } database = peewee_async.PostgresqlDatabase(**database) class CDE(peewee.Model): code = peewee.TextField() name = peewee.TextField() drug_type = peewee.TextField(null=True) apply_type = peewee.TextField(null=True) reg_type = peewee.TextField(null=True) pharm_name = peewee.TextField(null=True) accept_date = peewee.DateField(null=True) class Meta: database = database indexes = ((('code', ), True), ) if __name__ == '__main__':
import peewee import peewee_async from marshmallow import ( Schema, fields, ) # Connect to a Postgres database. database = peewee_async.PostgresqlDatabase( 'aiohttp_demo', user='******', password='******' ) class BaseModel(peewee.Model): id = peewee.PrimaryKeyField(unique=True) class Meta: order_by = 'sequence' database = database class Block(BaseModel): """Блок контент""" name = peewee.CharField(max_length=200) video_link = peewee.CharField(max_length=250) sequence = peewee.IntegerField() view_count = peewee.IntegerField() class Meta:
import peewee_async DATABASE_NAME = 'aiochat' DATABASE_USER = '******' DATABASE_PASSWORD = '******' DATABASE_HOST = 'localhost' DATABASE_PORT = 5432 database = peewee_async.PostgresqlDatabase(database=DATABASE_NAME, user=DATABASE_USER, password=DATABASE_PASSWORD, host=DATABASE_HOST, port=DATABASE_PORT)
from hashlib import md5 import logging import peewee_async import peewee import settings db = peewee_async.PostgresqlDatabase( settings.DB_NAME, user=settings.DB_USER, password=settings.DB_PASSWORD, host=settings.DB_HOST, autocommit=True, autorollback=True, ) class BaseModel(peewee.Model): class Meta: database = db class User(BaseModel): username = peewee.CharField(unique=True) password = peewee.CharField() is_admin = peewee.BooleanField() class Shift(BaseModel): user = peewee.ForeignKeyField(User, related_name='shifts')
import asyncio import peewee import peewee_async from app.config import * # Nothing special, just define model and database: database = peewee_async.PostgresqlDatabase( database=DB_NAME, user=DB_USER, host=DB_HOST, port=DB_PORT, password=DB_PASS ) objects = peewee_async.Manager(database=database)
import datetime import peewee_async from peewee import * connection = { 'user': '******', 'password': '******', 'host': '46.30.164.249', 'port': 5432 } db = peewee_async.PostgresqlDatabase('library', autorollback=True, **connection) class Page(Model): title = CharField(max_length=1024) title_len = IntegerField() response_time = FloatField() domain = CharField(max_length=1024, index=True) description = CharField(max_length=1024) description_len = IntegerField() h1 = CharField(max_length=1024) url = CharField(max_length=1024) scanned = DateTimeField(default=datetime.datetime.now) class Meta: database = db table_name = '27_less'
import asyncio import os import peewee import aiohttp_jinja2 import jinja2 import peewee_async import json as JSON from aiohttp import web, request as arequest database = peewee_async.PostgresqlDatabase('benchmark', user='******', password='******') class Message(peewee.Model): content = peewee.CharField(max_length=512) class Meta: database = database @asyncio.coroutine def json(request): return web.Response(text=JSON.dumps({'message': 'Hello, World!'}), content_type='application/json') @asyncio.coroutine def remote(request): response = yield from arequest('GET', 'http://test') # noqa text = yield from response.text()
import peewee_async from aiohttp import web from playhouse.db_url import parse from app import settings from writer.handlers import WriterView db_param = parse(settings.DATABASE_URL) db = peewee_async.PostgresqlDatabase(**db_param) app = web.Application() app.db = db app.objects = peewee_async.Manager(db) app.router.add_route('*', '/', WriterView)
import peewee import peewee_async from backbones.config import config # Imports go here. database = peewee_async.PostgresqlDatabase( database=config['postgres_config']['database'], user=config['postgres_config']['username'], host=config['postgres_config']['hostname'], port=config['postgres_config']['port'], password=config['postgres_config']['password']) # The Postgres database. objects = peewee_async.Manager(database) # The Peewee async manager. class BaseModel(peewee.Model): class Meta: database = database # the base model. class Guild(BaseModel): guild_id = peewee.BigIntegerField(primary_key=True) voice_channel = peewee.BigIntegerField(null=True) enabled = peewee.BooleanField(default=True)