import peewee
from playhouse.postgres_ext import PostgresqlExtDatabase
psql_db = PostgresqlExtDatabase('simple_plotdata', user='******', password='******')
class Family(peewee.Model):
"""
ORM model of the Family table
"""
name = peewee.CharField()
class Meta:
database = psql_db
if __name__ == '__main__':
for art in Family.select():
print(art.name)
from typing import Dict, Iterable
import peewee
from playhouse.postgres_ext import BinaryJSONField, PostgresqlExtDatabase
from playhouse.shortcuts import model_to_dict
from robotoff import settings
from robotoff.utils.types import JSONType
db = PostgresqlExtDatabase(
settings.DB_NAME,
user=settings.DB_USER,
password=settings.DB_PASSWORD,
host=settings.DB_HOST,
port=5432,
)
def batch_insert(model_cls, data: Iterable[Dict], batch_size=100) -> int:
rows = 0
inserts = []
for item in data:
inserts.append(item)
rows += 1
if rows % batch_size == 0:
model_cls.insert_many(inserts).execute()
inserts = []
if inserts:
# lignes = fichier.readlines()
# liste = []
# for ligne in lignes:
# if ligne != '\\\n':
# lignepropre = ligne.replace("\\", "")
# lignepropre = lignepropre.replace("\n", "")
# lignepropre = lignepropre.replace("}", "")
# liste += [lignepropre]
#aprés lecture de ce fichier une connexion est initialisé
db = PostgresqlExtDatabase(host='localhost',
database='immo',
user='******',
password='******',
port=5432)
class BaseModel(Model):
class Meta:
database = db
class Logement(BaseModel):
id_logement = AutoField()
id_type = IntegerField()
surface = IntegerField()
nb_chambre = IntegerField()
"""
Postgresql settings for peewee mappings.
"""
from playhouse.postgres_ext import PostgresqlExtDatabase
from common.config import Config
CFG = Config()
DB = PostgresqlExtDatabase(
CFG.db_name,
user=CFG.db_user,
password=CFG.db_pass,
host=CFG.db_host,
port=CFG.db_port,
sslmode=CFG.db_ssl_mode,
sslrootcert=CFG.db_ssl_root_cert_path,
)
import os
import uuid
import datetime
from peewee import *
from playhouse.postgres_ext import PostgresqlExtDatabase, JSONField
import config
dir_path = os.path.dirname(os.path.realpath(__file__))
DATABASE = SqliteDatabase('{}{}people.db'.format(dir_path, os.path.sep))
psql_db = PostgresqlExtDatabase('my_database',
user=config.PGU,
password=config.PGP,
register_hstore=False,
host=config.HOST,
port=config.PORT)
class BasePost(Model):
class Meta:
database = psql_db
class Charge(BasePost):
info = JSONField()
class BaseModel(Model):
class Meta:
database = psql_db
import json
from peewee import *
from config import *
from playhouse.postgres_ext import PostgresqlExtDatabase, JSONField, ArrayField
db = PostgresqlExtDatabase(bdname,
user=bduser,
password=bdpassword,
host=bdhost,
port=bdport,
autoconnect=True,
autorollback=True)
from models.Films import Films
from models.Users import Users
from models.Dataset import Dataset
# Films.create_table()
# Users.create_table()
# Dataset.create_table()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setup import *
#DBs
DATADIR = /XXXXXX'
from playhouse.postgres_ext import PostgresqlExtDatabase, BinaryJSONField
db = PostgresqlExtDatabase(database='LiveAI', user='******')
def uuid_generater():
random.seed()
return uuid.uuid4()
# return base64.b64encode('/'.join([datetime.now(JST).strftime('%Y%m%d%H%M%S'), str(os.getpid())]).encode('utf-8'))
###################################################
#
# >>>>>>>>WEBDATA_SQL>>>>>>>>>>>>>>>>>>>>>>>>>>>
#
####################################################
class SQLModel(Model):
class Meta:
database = db
class SS(SQLModel):
url = TextField(null = True)
text = TextField(null = True)
time = DateTimeField(null=True, default = datetime.now())
class Meta:
db_table = 'ss'
class SSdialog(SQLModel):
url = TextField(null = True)
person = TextField(null = True)
text = TextField(null = True)
redis_kw = 'lsadfkj'
smtp_cfg = {
'host': "smtp.ym.163.com",
'user': "******",
'pass': "******",
'postfix': 'yunsuan.org',
}
# Used in HTML render files.
cfg = {
'app_url_name': 'map',
'DEBUG': True,
'PORT': '8088',
'site_type': 2,
}
dbconnect = PostgresqlExtDatabase(
'maplet',
user='******',
password='******',
host='127.0.0.1',
autocommit=True,
autorollback=True
)
router_post = {'1': 'post',
'2': 'map',
}
from playhouse.postgres_ext import PostgresqlExtDatabase
from peewee import SQL
from playhouse.postgres_ext import BinaryJSONField, JSONField
from peewee import TextField, IntegerField, DateTimeField, BooleanField
except ImportError:
print 'you need install peewee, please run:'
print 'sudo pip install peewee'
exit(1)
from db_bz import getDBConf
conf = getDBConf()
psql_db = PostgresqlExtDatabase(conf.db_name,
user=conf.user,
password=conf.password,
host=conf.host,
register_hstore=False)
import model_bz
class BaseModel(model_bz.base):
'''
>>> BaseModel.drop_table(True)
'''
class Meta:
database = psql_db
class test(BaseModel):
from peewee import Model, CharField, DateTimeField, ForeignKeyField, AutoField, IntegerField, FloatField, BooleanField
from playhouse.postgres_ext import PostgresqlExtDatabase, ArrayField, BlobField
from utils import log
pg_db = PostgresqlExtDatabase('postgres', user='******', password='******',
host='tcc_timescaledb', port=5432)
class BaseModel(Model):
"""A base model that will use our Postgresql database"""
class Meta:
database = pg_db
class Station(BaseModel):
name = CharField(primary_key=True, unique=True)
description = CharField()
is_training = BooleanField()
trained_model = BlobField(null=True) # Trained model for aggregate data
class Observation(BaseModel):
id_ = AutoField(primary_key=True)
station = ForeignKeyField(model=Station, backref='observations')
time = DateTimeField()
is_training = BooleanField()
sample_frequency = FloatField()
sample_count = IntegerField()
}
db_state = ContextVar("db_state", default=db_state_default.copy())
class PeeweeGetterDict(GetterDict):
def get(self, key: Any, default: Any = None):
res = getattr(self._obj, key, default)
if isinstance(res, peewee.ModelSelect):
return list(res)
return res
class PeeweeConnectionState(peewee._ConnectionState):
def __init__(self, **kwargs):
super().__setattr__("_state", db_state)
super().__init__(**kwargs)
def __setattr__(self, name, value):
self._state.get()[name] = value
def __getattr__(self, name):
return self._state.get()[name]
db = PostgresqlExtDatabase(POSTGRES_DB,
user=POSTGRES_USER,
password=POSTGRES_PASSWORD,
host=POSTGRES_HOST,
port=POSTGRES_PORT)
db._state = PeeweeConnectionState()
DATABASE_NAME = 'analytics'
DOMAIN = 'http://analytics.yourdomain.com' # TODO: change me.
JAVASCRIPT = """(function(id){
var d=document,i=new Image,e=encodeURIComponent;
i.src='%s/a.gif?id='+id+'&url='+e(d.location.href)+'&ref='+e(d.referrer)+'&t='+e(d.title);
})(%s)""".replace('\n', '')
# Flask settings.
DEBUG = bool(os.environ.get('DEBUG'))
SECRET_KEY = 'secret - change me' # TODO: change me.
app = Flask(__name__)
app.config.from_object(__name__)
database = PostgresqlExtDatabase(
DATABASE_NAME,
user='******')
class BaseModel(Model):
class Meta:
database = database
class Account(BaseModel):
domain = CharField()
def verify_url(self, url):
netloc = urlparse(url).netloc
url_domain = '.'.join(netloc.split('.')[-2:]) # Ignore subdomains.
return self.domain == url_domain
class PageView(BaseModel):
import peewee as pw
from settings import get
from playhouse.postgres_ext import PostgresqlExtDatabase, JSONField
db = PostgresqlExtDatabase(
host=get('POSTGRES_HOST'),
port=get('POSTGRES_PORT'),
database=get('POSTGRES_DB'),
user='******',
password=get('POSTGRES_PASSWORD')
)
class NetlytModel(pw.Model):
class Meta:
database = db
DATABASE_NAME = 'analytics'
DOMAIN = 'http://analytics.yourdomain.com' # TODO: change me.
JAVASCRIPT = """(function(id){
var d=document,i=new Image,e=encodeURIComponent;
i.src='%s/a.gif?id='+id+'&url='+e(d.location.href)+'&ref='+e(d.referrer)+'&t='+e(d.title);
})(%s)""".replace('\n', '')
# Flask settings.
DEBUG = bool(os.environ.get('DEBUG'))
SECRET_KEY = 'secret - change me' # TODO: change me.
app = Flask(__name__)
app.config.from_object(__name__)
database = PostgresqlExtDatabase(DATABASE_NAME,
user='******',
threadlocals=True)
class BaseModel(Model):
class Meta:
database = database
class Account(BaseModel):
domain = CharField()
def verify_url(self, url):
netloc = urlparse(url).netloc
url_domain = '.'.join(netloc.split('.')[-2:]) # Ignore subdomains.
return self.domain == url_domain
from peewee import *
from playhouse.shortcuts import model_to_dict
from playhouse.postgres_ext import PostgresqlExtDatabase
from time import perf_counter
db = PostgresqlExtDatabase(
"dc_heroes",
host = "0.0.0.0",
user = "******",
password = "******",
port = 5432
)
class SUPER_HEROE(Model):
id = IntegerField()
name = TextField()
full_name = TextField()
alter_egos = TextField()
aliases = TextField()
place_of_birth = TextField()
first_appearance = TextField()
publisher = TextField()
alignment = TextField()
gender = TextField()
race = TextField()
height = TextField()
weight = TextField()
eye_color = TextField()
hair_color = TextField()
occupation = TextField()
base = TextField()
from playhouse.postgres_ext import PostgresqlExtDatabase
from configs import DB_NAME, DB_USER, DB_PORT, DB_PASSWORD, DB_HOST
db = PostgresqlExtDatabase(
database=DB_NAME,
user=DB_USER,
port=DB_PORT,
password=DB_PASSWORD,
host=DB_HOST,
register_hstore=False,
)
from playhouse.postgres_ext import Model, CharField, TextField, BooleanField, PostgresqlExtDatabase, UUIDField, ForeignKeyField
from werkzeug.security import generate_password_hash, check_password_hash
db = PostgresqlExtDatabase('test',
host='db',
user='******',
password='******',
port='5432')
class BaseModel(Model):
class Meta:
database = db
class User(BaseModel):
login = CharField(unique=True)
email = CharField(unique=True)
pw_hash = TextField()
authenticated = BooleanField(default=False)
active = BooleanField(default=False)
def is_authenticated(self):
return self.authenticated
def is_active(self):
return self.active
def is_anonymous(self):
return False
DATABASE_NAME = 'analytics'
DOMAIN = 'http://analytics.yourdomain.com' # TODO: change me.
JAVASCRIPT = """(function(id){
var d=document,i=new Image,e=encodeURIComponent;
i.src='%s/a.gif?id='+id+'&url='+e(d.location.href)+'&ref='+e(d.referrer)+'&t='+e(d.title);
})(%s)""".replace('\n', '')
# Flask settings.
DEBUG = bool(os.environ.get('DEBUG'))
SECRET_KEY = 'secret - change me' # TODO: change me.
app = Flask(__name__)
app.config.from_object(__name__)
database = PostgresqlExtDatabase(DATABASE_NAME,
register_hstore=True,
user='******')
class BaseModel(Model):
class Meta:
database = database
class Account(BaseModel):
domain = CharField()
def verify_url(self, url):
netloc = urlparse(url).netloc
url_domain = '.'.join(netloc.split('.')[-2:]) # Ignore subdomains.
return self.domain == url_domain
from peewee import *
from playhouse.shortcuts import model_to_dict
from playhouse.postgres_ext import PostgresqlExtDatabase
db = PostgresqlExtDatabase(
"dc_heroes",
host = "dc_db",
user = "******",
password = "******",
)
class SUPER_HEROE(Model):
id = IntegerField()
name = TextField()
full_name = TextField()
alter_egos = TextField()
aliases = TextField()
place_of_birth = TextField()
first_appearance = TextField()
publisher = TextField()
alignment = TextField()
gender = TextField()
race = TextField()
height = TextField()
weight = TextField()
eye_color = TextField()
hair_color = TextField()
occupation = TextField()
base = TextField()
group_affiliation = TextField()
relatives = TextField()
import yaml
import slackbot.bot
import peewee
from playhouse.postgres_ext import PostgresqlExtDatabase
from plugins import fakenumbers
# pylint: disable=protected-access
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
CONFIG = os.path.join(BASE_DIR, '../config.yml')
with open(CONFIG, 'r') as fptr:
CFG = yaml.load(fptr.read(), Loader=yaml.FullLoader)
DBUSER = CFG['dbuser']
DBPASS = CFG['dbpass']
DB = CFG['db']
PSQL_DB = PostgresqlExtDatabase(DB, user=DBUSER, password=DBPASS)
def user(msg):
""" Get user from slack message
:param msg: Slack message
"""
return msg._client.users[msg._get_user_id()]['name']
def users(msg):
""" Get all users from slack message
:param msg: Slack message
"""
return [j['name'] for i, j in msg._client.users.items()]
from playhouse.postgres_ext import PostgresqlExtDatabase
from utils import config
pg_db = PostgresqlExtDatabase(database=config.DATABASE,
user=config.USER,
password=config.PASSWORD,
host=config.HOST,
port=config.PORT)
from peewee import *
from playhouse.shortcuts import model_to_dict
from playhouse.postgres_ext import PostgresqlExtDatabase, ArrayField, BinaryJSONField, BooleanField, JSONField
# support for arrays of uuid
import psycopg2.extras
psycopg2.extras.register_uuid()
from flask import abort
import config
import logging
log = logging.getLogger("db")
database = PostgresqlExtDatabase(config.DATABASE_NAME,
user=config.DATABASE_USER,
password=config.DATABASE_PASSWORD,
host=config.DATABASE_HOST,
port=config.DATABASE_PORT)
# --------------------------------------------------------------------------
# Base model and common methods
class BaseModel(Model):
"""Base class for all database models."""
# exclude these fields from the serialized dict
EXCLUDE_FIELDS = []
def serialize(self):
"""Serialize the model into a dict."""
"""
Postgresql settings for peewee mappings.
"""
import os
from playhouse.postgres_ext import PostgresqlExtDatabase
DB_NAME = os.getenv('POSTGRESQL_DATABASE', "vulnerability").strip()
DB_USER = os.getenv('POSTGRESQL_USER', "ve_db_user_unknown").strip()
DB_PASS = os.getenv('POSTGRESQL_PASSWORD', "ve_db_user_unknown_pwd").strip()
DB_HOST = os.getenv('POSTGRESQL_HOST', "ve_database").strip()
DB_PORT = int(os.getenv('POSTGRESQL_PORT', "5432").strip())
DB = PostgresqlExtDatabase(DB_NAME, user=DB_USER, password=DB_PASS, host=DB_HOST, port=DB_PORT)
redis_kw = 'lsadfkj'
smtp_cfg = {
'host': "smtp.ym.163.com",
'user': "******",
'pass': "******",
'postfix': 'yunsuan.org',
}
Email_site_name = '云算笔记'
PORT = '8088'
dbconnect = PostgresqlExtDatabase(
'torcms',
user='******',
password='******',
host='127.0.0.1',
autocommit=True,
autorollback=True
)
app_url_name = 'map'
template_dir_name = 'templates'
torlite_template_name = 'tplite'
app_template_name = 'pycate'
lang = 'en_US'
# Used in HTML render files.
from peewee import CharField, Model
from playhouse.postgres_ext import PostgresqlExtDatabase, HStoreField
import urlparse
import ujson as json
import os
from pastebot.config import config
urlparse.uses_netloc.append("postgres")
url = urlparse.urlparse(config["database_url"])
pgs_db = PostgresqlExtDatabase(url.path[1:],
user=url.username,
password=url.password,
host=url.hostname,
port=url.port)
class User(Model):
username = CharField(unique=True)
gistauth = CharField()
pastebinauth = CharField()
operationstatus = HStoreField()
# operationstatus template
# {
# 'operation': 'gist' or 'pastebin',
# # gist params
# 'description': 'gist description',
# 'public': true or false,
# '<num>name': '<file name>',
# '<num>content': '<file content>',
import peewee
import os
import yaml
import traceback
from playhouse.postgres_ext import PostgresqlExtDatabase
import slackbot.bot
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
yaml_loc = os.path.join(BASE_DIR, '../config.yml')
with open(yaml_loc, 'r') as fptr:
cfg = yaml.load(fptr.read())
dbuser = cfg['dbuser']
dbpass = cfg['dbpass']
db = cfg['db']
psql_db = PostgresqlExtDatabase(db, user=dbuser, password=dbpass)
class JeffCrisis(peewee.Model):
nick = peewee.CharField()
datetime = peewee.DateTimeField()
level = peewee.CharField()
class Meta:
database = psql_db
class Level(peewee.Model):
name = peewee.TextField(unique=True)
text = peewee.TextField(default='black')
font = peewee.TextField(default='Lucida Console')
ColumnFactory,
DateTimeField,
DeferredForeignKey,
ForeignKeyField,
BigIntegerField,
ModelSelect,
ProgrammingError,
TextField,
Model,
)
from playhouse.postgres_ext import BinaryJSONField, PostgresqlExtDatabase
from playhouse.signals import Model
import lena_tweets.config
database = PostgresqlExtDatabase(None, autorollback=True)
class ConnectionContext(ContextDecorator):
db = None
tables_created = None
global_in_context = False
def __init__(self):
self.dont_close_connection = False
def __enter__(self):
if ConnectionContext.global_in_context:
self.dont_close_connection = True
if not ConnectionContext.db:
import os, urlparse
from playhouse.postgres_ext import PostgresqlExtDatabase
urlparse.uses_netloc.append("postgres")
url = urlparse.urlparse(os.environ["DATABASE_URL"])
db = PostgresqlExtDatabase(url.path[1:],
user=url.username,
host=url.hostname,
port=url.port,
password=url.password,
register_hstore=False)
import os
import peewee as pw
import datetime
from playhouse.postgres_ext import PostgresqlExtDatabase
db = PostgresqlExtDatabase(os.getenv('DATABASE'))
class BaseModel(pw.Model):
created_at = pw.DateTimeField(default=datetime.datetime.now)
updated_at = pw.DateTimeField(default=datetime.datetime.now)
def save(self, *args, **kwargs):
self.updated_at = datetime.datetime.now()
return super(BaseModel, self).save(*args, **kwargs)
class Meta:
database = db
legacy_table_names = False
class Store(BaseModel):
name = pw.CharField(unique=True)
class Warehouse(BaseModel):
store = pw.ForeignKeyField(Store, backref='warehouses')
location = pw.TextField()
class Product(BaseModel):
from peewee import PostgresqlDatabase, Model, TextField, CharField, DateTimeField, ForeignKeyField, BooleanField, IntegerField, SQL
from playhouse.postgres_ext import PostgresqlExtDatabase # necessary for full text search
from datetime import datetime
from config import Config
import urllib.parse
db_parsed_url = urllib.parse.urlparse(Config.DATABASE_URL)
username = db_parsed_url.username
password = db_parsed_url.password
database = db_parsed_url.path[1:]
hostname = db_parsed_url.hostname
postgres_db = PostgresqlExtDatabase(database=database,
user=username,
password=password,
host=hostname,
autocommit=True,
autorollback=True,
register_hstore=True)
class User(Model):
name = TextField(unique=True)
admin = BooleanField(default=False)
password = TextField()
active = BooleanField(default=True)
created_at = DateTimeField(default=datetime.now)
updated_at = DateTimeField(default=datetime.now)
def get_id(self):
return str(self.id)
