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)
