def setUp(self):
os.system(
"createdb peeweedbevolve_test && psql peeweedbevolve_test -c 'create extension IF NOT EXISTS hstore;' > /dev/null 2> /dev/null"
)
self.db = PooledPostgresqlExtDatabase('peeweedbevolve_test')
self.db.connect()
peeweedbevolve.clear()
class PooledPostgreSQL(PostgreSQL):
def setUp(self):
os.system(
"createdb peeweedbevolve_test && psql peeweedbevolve_test -c 'create extension IF NOT EXISTS hstore;' > /dev/null 2> /dev/null"
)
self.db = PooledPostgresqlExtDatabase('peeweedbevolve_test')
self.db.connect()
peeweedbevolve.clear()
def tearDown(self):
self.db.manual_close()
os.system('dropdb peeweedbevolve_test')
def __init__(self, logger=None):
self.database = PooledPostgresqlExtDatabase(
database=os.environ.get('DB_NAME'),
user=os.environ.get('DB_USER'),
password=os.environ.get('DB_PASSWORD'),
host=os.environ.get('DB_HOST'),
port=os.environ.get('DB_PORT'),
max_connections=os.environ.get('DB_POOL_MAX_CONNECTIONS'),
stale_timeout=os.environ.get('DB_POOL_TIMEOUT'),
)
self.open_connection()
self.logger = logger
def return_db():
db_config = parse_db_url(os.environ['DATABASE_URL'])
if os.getenv('MIGRATION','0') =='1':
from playhouse.postgres_ext import PostgresqlExtDatabase
return PostgresqlExtDatabase(
db_config['database'],
user=db_config.get('user', None),
password=db_config.get('password', None),
host=db_config.get('host', 'localhost'),
port=db_config.get('port', '5432')
)
else:
from playhouse.pool import PooledPostgresqlExtDatabase
return PooledPostgresqlExtDatabase(
db_config['database'],
max_connections=os.getenv('DB_POOL', 5),
stale_timeout=os.getenv('DB_TIMEOUT', 300), # 5 minutes.
user=db_config.get('user', None),
password=db_config.get('password', None),
host=db_config.get('host', 'localhost'),
port=db_config.get('port', '5432'))
def spawn_deferred_db(field_types=dict()):
return PooledPostgresqlExtDatabase(None,
max_connections=8,
stale_timeout=600,
register_hstore=False,
autorollback=True,
field_types=field_types)
def load_db_config(server_config=None):
"""Initialise db proxy with parameters from inifile
Args:
serverconfig (dict): dict of server parameters as returned by waptserver_config.load_config(ainifilename)
Returns
configured db : db which has been put in wapt_db proxy
"""
global wapt_db
if server_config is None:
server_config = waptserver_config.load_config()
logger.info(
'Initializing a DB connection pool for db host:%s db_name:%s. Size:%s'
% (server_config['db_host'], server_config['db_name'],
server_config['db_max_connections']))
pgdb = PooledPostgresqlExtDatabase(
database=server_config['db_name'],
host=server_config['db_host'],
user=server_config['db_user'],
password=server_config['db_password'],
max_connections=server_config['db_max_connections'],
stale_timeout=server_config['db_stale_timeout'],
timeout=server_config['db_connect_timeout'])
wapt_db.initialize(pgdb)
return pgdb
def __init__(self):
super().__init__()
self.db = PooledPostgresqlExtDatabase(
database=os.environ.get("POSTGRES_DB_NAME", "postgres"),
user=os.environ.get("POSTGRES_DB_USER", "postgres"),
host=os.environ.get("POSTGRES_DB_HOST", "127.0.0.1"),
port=os.environ.get("POSTGRES_DB_PORT", "5432"),
# password='******'
autorollback=True,
max_connections=32,
stale_timeout=300, # 5 minutes
)
# TODO: figure this out (try with creating a base class and only assigning
# _meta.database to that base class)
Block._meta.database = self.db
Transaction._meta.database = self.db
Round._meta.database = self.db
PoolTransaction._meta.database = self.db
self._active_delegates = []
self.wallets = WalletManager()
def postgres(self):
assert app.config['DB_ENGINE'] == 'peewee.PostgresqlDatabase'
db_url = urlparse(os.environ.get('DATABASE_URL', None))
database = db_url.path[1:]
return PooledPostgresqlExtDatabase(
database,
max_connections=1,
stale_timeout=300, # 5 minutes
timeout=0, # Wait forever for a connection
user=db_url.username,
password=db_url.password,
host=db_url.hostname,
port=db_url.port,
register_hstore=False)
class PostgreSQLProvider():
def __init__(self, logger=None):
self.database = PooledPostgresqlExtDatabase(
database=os.environ.get('DB_NAME'),
user=os.environ.get('DB_USER'),
password=os.environ.get('DB_PASSWORD'),
host=os.environ.get('DB_HOST'),
port=os.environ.get('DB_PORT'),
max_connections=os.environ.get('DB_POOL_MAX_CONNECTIONS'),
stale_timeout=os.environ.get('DB_POOL_TIMEOUT'),
)
self.open_connection()
self.logger = logger
def __del__(self):
self.close_connection()
def open_connection(self):
self.database.connect(reuse_if_open=True)
print('Connected to PostgreSQL database')
def close_connection(self):
self.database.close()
print('Connection to PostgreSQL database closed')
def create_pgdb_pool(host=None,
database=None,
user=None,
password=None,
max_connections=32):
return PooledPostgresqlExtDatabase(
database=database,
host=host,
user=user,
password=password,
max_connections=max_connections,
autorollback=True,
register_hstore=False,
stale_timeout=60 * 2,
) # 2 minutes
def setup(settings):
"""
Setup the database connection.
"""
connector = settings.get('db_connector')
if connector == 'postgres':
from playhouse.pool import PooledPostgresqlExtDatabase
return PooledPostgresqlExtDatabase(
settings['db_name'],
user=settings['db_user'],
password=settings['db_password'],
host=settings['db_host'],
port=settings.get('db_port'),
max_connections=settings.get('db_max_conn'),
stale_timeout=settings.get('db_stale_timeout'),
timeout=settings.get('db_timeout'),
register_hstore=False)
def database_init(app, models):
logging.info("Init database connection: %s %s" % (app.config["DATABASE"], app.config["DATABASE_NAME"]))
if app.config["DATABASE"] == "postgresql":
from playhouse.pool import PooledPostgresqlExtDatabase
database = PooledPostgresqlExtDatabase(app.config["DATABASE_NAME"], max_connections=16, stale_timeout=300, **app.config["DATABASE_AUTH"])
elif app.config["DATABASE"] == "sqlite":
from playhouse.pool import PooledSqliteDatabase
database = PooledSqliteDatabase(app.config["DATABASE_PATH"], pragmas={
"journal_mode": "wal",
"cache_size": -1024 * 64,
"foreign_keys": 1
})
else:
raise RuntimeError("No database set or invalid")
try:
DB.initialize(database)
except:
logging.exception("Could not initialize database")
def database_init(app, models):
logging.debug("ConnectDB: " + app.config["DATABASE"])
if app.config["DATABASE"] == "postgresql":
from playhouse.pool import PooledPostgresqlExtDatabase
database = PooledPostgresqlExtDatabase(app.config["DATABASE_NAME"],
max_connections=16,
stale_timeout=300,
**app.config["DATABASE_AUTH"])
elif app.config["DATABASE"] == "sqlite":
from playhouse.pool import PooledSqliteDatabase
database = PooledSqliteDatabase(app.config["DATABASE_PATH"],
pragmas=(("journal_mode", "wal"),
("cache_size", -1024 * 64)))
else:
raise RuntimeError("No database set or invalid")
DB.initialize(database)
def init_database(database_name: Path,
database_type="postgres",
user="******",
password=None,
host="localhost",
port=5432):
assert database_type in DATABASE_TYPES
if database_type == "postgres":
logger.debug(f"Opening postgres database {database_name}\n"
f"user={user}; host={host} port={port}")
db = PooledPostgresqlExtDatabase(database_name,
user=user,
host=host,
port=port,
password=password,
max_connections=MAX_PROCESSES,
stale_timeout=300)
elif database_type == "sqlite":
db = pw.SqliteDatabase(str(database_name), pragmas=PRAGMAS)
else:
raise ValueError("Allowed database types: {}".format(DATABASE_TYPES))
return db
from peewee import CharField, CompositeKey, DateField, DecimalField, Model
from playhouse.pool import PooledPostgresqlExtDatabase
db = PooledPostgresqlExtDatabase(database='exchangerates',
user='******',
password='******',
host='127.0.0.1',
max_connections=32,
stale_timeout=300)
class ExchangeRates(Model):
source = CharField(choices=(('ecb', 'European Central Bank'), ))
date = DateField(index=True)
currency = CharField()
rate = DecimalField(max_digits=16, decimal_places=6)
class Meta:
database = db
primary_key = CompositeKey('date', 'currency')
import logging
import json
import falcon
from peewee import *
from playhouse.postgres_ext import ArrayField
from werkzeug.serving import run_simple
from playhouse.pool import PooledPostgresqlExtDatabase
import config
# PG DB connection string
database = PooledPostgresqlExtDatabase(None,
stale_timeout=300,
max_connections=20,
register_hstore=False)
# PeeWee models
class BaseModel(Model):
class Meta:
database = database
class User(BaseModel):
username = CharField(unique=True)
password = CharField()
remember_token = CharField(unique=True)
join_date = DateTimeField()
# How many messages consider a user rain eligible
LAST_MSG_RAIN_COUNT = 5
# (Seconds) How spaced out the messages must be
LAST_MSG_RAIN_DELTA = 60
# How many words messages must contain
LAST_MSG_RAIN_WORDS = 3
# (Seconds) How long user must wait between tiprandom
TIP_RANDOM_WAIT = 10
# (Seconds) How long user mus wait between tipfavorites
TIP_FAVORITES_WAIT = 150
db = PooledPostgresqlExtDatabase(settings.database,
user=settings.database_user,
password=settings.database_password,
host='localhost',
port=5432,
max_connections=16)
logger = util.get_logger("db")
### User Stuff
@db.connection_context()
def get_accounts():
u = User.select(User.wallet_address)
accts = []
for a in u:
accts.append(a.wallet_address)
return accts
from peewee import CharField, DateTimeField, AutoField
from playhouse.postgres_ext import BinaryJSONField
from playhouse.pool import PooledPostgresqlExtDatabase
from actinia_gdi.resources.config import JOBTABLE
from actinia_gdi.resources.logging import log
log.debug("Database config loaded: " + JOBTABLE.host + ":" + JOBTABLE.port +
"/" + JOBTABLE.database + "/" + JOBTABLE.schema + "." +
JOBTABLE.table)
"""database connection"""
jobdb = PooledPostgresqlExtDatabase(
JOBTABLE.database, **{
'host': JOBTABLE.host,
'port': JOBTABLE.port,
'user': JOBTABLE.user,
'password': JOBTABLE.pw,
'max_connections': 8,
'stale_timeout': 300
})
class BaseModel(Model):
"""Base Model for tables in jobdb
"""
class Meta:
database = jobdb
class Job(BaseModel):
"""Model for jobtable in database
import os
import waptserver_config
# You must be sure your database is an instance of PostgresqlExtDatabase in order to use the JSONField.
server_config = waptserver_config.load_config()
import logging
logger = logging.getLogger()
logger.debug('DB connection pool : %s' % server_config['db_max_connections'])
wapt_db = PooledPostgresqlExtDatabase(
database=server_config['db_name'],
host=server_config['db_host'],
user=server_config['db_user'],
password=server_config['db_password'],
max_connections=server_config['db_max_connections'],
stale_timeout=server_config['db_stale_timeout'])
class BaseModel(SignaledModel):
"""A base model that will use our Postgresql database"""
class Meta:
database = wapt_db
class ServerAttribs(BaseModel):
"""key/value registry"""
key = CharField(primary_key=True, null=False, index=True)
value = BinaryJSONField(null=True)
# -*- coding:utf-8 -*-
from peewee import Model
from playhouse.pool import PooledPostgresqlExtDatabase
from jobs.jobs_config import DB_CONFIG
SUCCESS_INVOICE_STATUS = 3
trio_db = PooledPostgresqlExtDatabase(**DB_CONFIG)
trio_db.commit_select = True
trio_db.autorollback = True
class BaseModel(Model):
class Meta:
database = trio_db
@classmethod
def get_by_id(cls, id):
try:
return cls.get(cls.id == id)
except cls.DoesNotExist:
return None
# -*- coding: utf-8 -*-
from peewee import *
from playhouse.migrate import *
from datetime import datetime
try:
raise ImportError
import conf
import psycopg2
from playhouse.pool import PooledPostgresqlExtDatabase
db = PooledPostgresqlExtDatabase(conf.dbname,
max_connections=8,
stale_timeout=300,
user=conf.user,
host=conf.host,
password=conf.passwd,
autorollback=True,
register_hstore=False)
migrator = PostgresqlMigrator(db)
except ImportError:
db = SqliteDatabase('db.sqlite')
migrator = SqliteMigrator(db)
class BaseModel(Model):
class Meta:
database = db
class Provs(BaseModel):
# -*- coding:utf-8 -*-
from peewee import (Model, TextField, DoubleField, DateTimeField, datetime as
peewee_datetime)
from playhouse.pool import PooledPostgresqlExtDatabase
from config import db_config
binance_db = PooledPostgresqlExtDatabase(**db_config)
binance_db.commit_select = True
binance_db.autorollback = True
class BaseModel(Model):
class Meta:
database = binance_db
class PriceLog(BaseModel):
class Meta:
db_table = "price_logs"
created = DateTimeField(default=peewee_datetime.datetime.now)
symbol = TextField()
max_price = DoubleField()
min_price = DoubleField()
drop_percent = DoubleField()
def init_db():
try:
from functools import partial
from peewee import (
Check,
CharField,
DecimalField,
ForeignKeyField,
IntegerField,
Model,
DateField,
SQL)
from playhouse.pool import PooledPostgresqlExtDatabase
DATABASE = PooledPostgresqlExtDatabase(None)
class BaseModel(Model):
class Meta:
database = DATABASE
legacy_table_names = False
MoneyField = partial(DecimalField, decimal_places=10, max_digits=30)
class RelationType(BaseModel):
name = CharField(max_length=30, unique=True)
class TransactionType(BaseModel):
# !/usr/bin/env python
# -*- coding: utf-8 -*-
from peewee import *
from datetime import datetime
try:
import psycopg2
from playhouse.pool import PooledPostgresqlExtDatabase
db = PooledPostgresqlExtDatabase("***",
max_connections=8,
stale_timeout=300,
user="******",
host='your ip',
password="******",
autorollback=True,
register_hstore=False)
except Exception, err:
db = SqliteDatabase('smzdm.sqlite')
class BaseModel(Model):
class Meta:
database = db
class Smzdmarticle(BaseModel):
url = CharField(max_length=300,
null=False,
primary_key=True,
if sys.version[0] == '2':
from functools32 import wraps
else:
from functools import wraps
from enum import Enum
from peewee import DateTimeField, Model
from playhouse.pool import PooledPostgresqlExtDatabase
from playhouse.shortcuts import model_to_dict
import settings
db = PooledPostgresqlExtDatabase(
database=settings.DB_NAME,
host=settings.DB_HOST,
user=settings.DB_USER,
password=settings.DB_PASSWORD,
max_connections=settings.DB_MAXCONNECTIONS,
register_hstore=False,
stale_timeout=60*2) # 2 minutes
class BaseModel(Model):
class Meta:
database = db
only_save_dirty = True
def to_dict(self, only=None, exclude=None, recurse=False):
return model_to_dict(self, only=only, exclude=exclude, recurse=recurse)
class CommonModel(BaseModel):
app = Flask(__name__)
api = Api(app)
# settings = {
# 'database': 'psqltest',
# 'user': '******',
# 'password': '******',
# 'host': '120.53.223.160',
# 'port': '7080',
# }
DATABASE = PooledPostgresqlExtDatabase(
database='psqltest',
user='******',
password='******',
host='120.53.223.160',
port='7080',
)
class BaseModel(peewee.Model):
class Meta:
database = DATABASE
# def create_tables():
class PostModel(BaseModel):
id = peewee.PrimaryKeyField(primary_key=True, )
from typing import Dict, Union
import os
from fastapi import FastAPI, Body
from pydantic import BaseModel
from peewee import (
Model, IntegerField, TextField, CompositeKey, IntegrityError
)
from playhouse.postgres_ext import JSONField
from playhouse.pool import PooledPostgresqlExtDatabase
DB = PooledPostgresqlExtDatabase(
database=os.environ['DATABASE'],
user=os.environ['USER'],
password=os.environ['PASSWORD'],
host=os.environ['HOST'],
max_connections=19,
stale_timeout=10,
)
class Submission_api(BaseModel):
learning_unit: Union[str, int]
slack_id: str = Body(..., min_length=5, max_length=20)
grade: int
metadata: Dict[str, str]
class Submission_db(Model):
learning_unit = IntegerField()
slack_id = TextField()
from playhouse.pool import PooledPostgresqlExtDatabase
from peewee import Model
from database import *
# PooledPostgresqlExtDatabase.
db = PooledPostgresqlExtDatabase(PG_DB,
user=PG_USER,
password=PG_PASSWORD,
host=PG_HOST,
port=PG_PORT,
max_connections=1000,
stale_timeout=5,
register_hstore=False)
class DatabaseModel(Model):
class Meta:
database = db
4: "RUNTIME_ERROR",
5: "SYSTEM_ERROR",
6: "PENDING",
7: "JUDGING",
8: "PARTIALLY_ACCEPTED",
}
with open("./conf.d/database.json", "r") as f:
setting = json.load(f)
# with open("./database.json", "r") as f:
# setting = json.load(f)
database_name = "Judee_dev"
# database_name = "postgres"
db = PooledPostgresqlExtDatabase(database_name, **setting)
class BaseModel(Model):
class Meta:
database = db
class submission(BaseModel):
ID = IntegerField(primary_key=True)
create_time = DateTimeField()
code = TextField()
result = IntegerField()
info = BinaryJSONField()
language = CharField(max_length=15)
ip = TextField()
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self): #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
print("Starting " + self.name)
print_time(self.name, self.counter)
print("Exiting " + self.name)
db = PooledPostgresqlExtDatabase(
'adminlq',
max_connections=2,
stale_timeout=300, # 5 minutes.
timeout=0,
password='******',
host='127.0.0.1',
user='******')
def print_time(threadName, delay):
db.connect()
count = 0
while count < 1:
time.sleep(delay)
count += 1
print('%s: %s' % (threadName, time.ctime(time.time())))
db.close()
from itsdangerous import (TimedJSONWebSignatureSerializer
as Serializer, BadSignature, SignatureExpired)
from peewee import (Model, CharField, TextField, ForeignKeyField, IntegerField, SmallIntegerField,
DateTimeField, DoubleField, BooleanField, DecimalField, datetime as peewee_datetime,
fn)
from playhouse.pool import PooledPostgresqlExtDatabase
from flask import Markup, request, g
from config import DB_CONFIG, SECRET_KEY, MEDIA_ROOT, MEDIA_URL
from zippy_gig.constants import AccountType
from geopy.geocoders import Nominatim
db = PooledPostgresqlExtDatabase(**DB_CONFIG)
db.commit_select = True
db.autorollback = True
import zippy_gig.sql_additional
peewee_now = peewee_datetime.datetime.now
class _Model(Model):
class Meta:
database = db
class Photo(_Model):
def __call__(self):
return PooledPostgresqlExtDatabase(**self.kwargs, max_connections=30, stale_timeout=300)
