import os from peewee import PostgresqlDatabase, Model, CharField, BooleanField, ForeignKeyField from flask_security import UserMixin, RoleMixin from playhouse.db_url import connect DATABASE = "hurtigen" db = PostgresqlDatabase(DATABASE) DATABASE_URL = os.environ.get("DATABASE_URL") if DATABASE_URL: db = connect(DATABASE_URL) else: DATABASE = "hurtigen" db = PostgresqlDatabase(DATABASE) class BaseModel(Model): class Meta: database = db class Contact(BaseModel): email = CharField() message = CharField() class Password(BaseModel): password = CharField() class User(BaseModel, UserMixin):
from chalicelib import settings from peewee import PostgresqlDatabase db = PostgresqlDatabase(settings.DATABASE['NAME'], user=settings.DATABASE['USER'], password=settings.DATABASE['PASSWORD'], host=settings.DATABASE['HOST'], port=settings.DATABASE['PORT'])
from peewee import Model, CharField, IntegerField, DateTimeField, PostgresqlDatabase, TextField from playhouse.postgres_ext import JSONField from datetime import datetime from config import get_cfg db_cfg = get_cfg('db') db_conn = { 'host': db_cfg['host'], 'user': db_cfg['user'], 'password': db_cfg['password'], 'database': db_cfg['database'], 'autorollback': db_cfg['autorollback'] } db = PostgresqlDatabase(**db_conn) msg_ids = {"b_info": 0, "b_main": 0} class BaseModel(Model): class Meta: database = db class User(BaseModel): tg_id = IntegerField() username = CharField() registered = DateTimeField(default=datetime.now)
from dynaconf import settings from enum import Enum from peewee import Model, PostgresqlDatabase, CharField, IntegerField,BigIntegerField,FloatField,ForeignKeyField, DateTimeField from peewee_extra_fields import EnumField db = PostgresqlDatabase(settings.DATABASE_NAME, user=settings.DATABASE_USERNAME, password=settings.DATABASE_PASSWORD, host= settings.DATABASE_HOST) class BaseModel(Model): class Meta: database = db only_save_dirty = True def __str__(self): sb = [] for key in self.__dict__: sb.append("{key}='{value}'".format(key=key, value=self.__dict__[key])) return ', '.join(sb) def __repr__(self): return self.__str__() class TransactionType(Enum): BUY = 1 SELL = 2 class Client(BaseModel) : name = CharField() wallet = FloatField()
from .OrangeDB import Orange from peewee import PostgresqlDatabase from redis import Redis config = Orange(file_path='config.json', auto_dump=False, load=True) db = PostgresqlDatabase( config['database']['name'], user=config['database']['user'], host=config['database']['host'], port=config['database']['port'], password=config['database'].get('password') ) redis = Redis( host=config['redis']['host'], port=config['redis']['port'], db=config['redis']['db'], password=config['redis'].get('password') )
import os import pw_database_url from peewee import PostgresqlDatabase, Model config = pw_database_url.config() database = PostgresqlDatabase(config['name'], host=config['host'], port=config['port'], user=config['user'], password=config['password']) database.connect() class BaseModel(Model): class Meta: database = database
def init_postgresql(settings: dict): keys = {"database", "user", "password", "host", "port"} settings = {k: v for k, v in settings.items() if k in keys} db = PostgresqlDatabase(**settings) return db
from peewee import PostgresqlDatabase, UUIDField, Model, CharField, TextField, ForeignKeyField, CompositeKey, \ IntegerField, DoubleField PEWEE_DB = PostgresqlDatabase(None) class Student(Model): id = UUIDField(primary_key=True) name = CharField(max_length=64) surname = CharField(max_length=64) group_name = CharField(max_length=16) class Meta: database = PEWEE_DB db_table = 'students' class Article(Model): id = UUIDField(primary_key=True) url = CharField(unique=True) title = CharField() text = TextField() keywords = CharField() author = CharField(null=True) student = ForeignKeyField(Student, to_field='id', db_column='student_id') class Meta: database = PEWEE_DB db_table = 'articles'
from peewee import PostgresqlDatabase, Model, CharField, TextField connection = { 'user': '******', 'password': '******', 'host': '46.30.164.249', 'port': 5432 } db = PostgresqlDatabase('library', **connection) class MyTexts(Model): key = CharField() slug = CharField() text = TextField() class Meta: database = db table_name = 'dor_texts' # sql = "INSERT INTO dor_texts VALUES (556, 'value2', 'value3', 'Hello World');" # db.execute_sql(sql) # cursor = db.execute_sql('select * from dor_texts where slug = "asterisk";') # for raw in cursor: # print(raw) # text = MyTexts.create( # key='blabla',
IntegerField, Model, PostgresqlDatabase) import settings as config POSTGRES_HOST = config.DATABASE['HOST'] POSTGRES_PORT = int(config.DATABASE['PORT']) POSTGRES_DATABASE = config.DATABASE['DATABASE'] POSTGRES_USER = config.DATABASE['USER'] POSTGRES_PASSWORD = config.DATABASE['PASSWORD'] db_handle = PostgresqlDatabase(database=POSTGRES_DATABASE, host=POSTGRES_HOST, port=POSTGRES_PORT, user=POSTGRES_USER, password=POSTGRES_PASSWORD) class BaseModel(Model): class Meta: database = db_handle class Transactions(BaseModel): id_transaction = IntegerField(primary_key=True) id_account = IntegerField() transaction_type = CharField(max_length=255) transaction_date = DateField() transaction_amount = FloatField()
from decimal import Decimal from decouple import config from peewee import PostgresqlDatabase from twitter import Api INTERVAL = config('INTERVAL', cast=lambda x: int(x) * 60) TIMEZONE = config('TIMEZONE') REDIS_URL = config('REDIS_URL') DATABASE = PostgresqlDatabase(database=config('POSTGRES_DB'), user=config('POSTGRES_USER'), password=config('POSTGRES_PASSWORD'), host=config('POSTGRES_HOST'), port=config('POSTGRES_PORT')) CELERY_CONFIG = {'broker': REDIS_URL, 'timezone': TIMEZONE} CREDENTIALS = { 'consumer_key': config('TWITTER_CONSUMER_KEY', default=None), 'consumer_secret': config('TWITTER_CONSUMER_SECRET', default=None), 'access_token_key': config('TWITTER_ACCESS_TOKEN', default=None), 'access_token_secret': config('TWITTER_ACCESS_TOKEN_SECRET', default=None) } TWITTER = Api(**CREDENTIALS) if all(CREDENTIALS.values()) else None TWEET = config('TWEET') CONTRACT_SPEED = config('CONTRACT_SPEED', cast=lambda x: int(x) * 10**6) MINIMUM_SPEED = config('THRESHOLD', cast=lambda x: Decimal(x) * CONTRACT_SPEED)
'''configuration values for api''' from argon2 import PasswordHasher from peewee import PostgresqlDatabase, SqliteDatabase import os DEBUG = True HOST = '0.0.0.0' PORT = 8000 SECRET_KEY = 'SD:FLKDWUdsfk;aifaw:WEFJuqhw*GF%DR$*&%$eFgYrtUjhuu9IuyR5p^TGIYv' DEFAULT_RATE = '100/hour' HASHER = PasswordHasher() try: DATABASE = PostgresqlDatabase(os.environ['database'], host=os.environ['host'], port=os.environ['port'], user=os.environ['user'], password=os.environ['password'], sslmode=os.environ['sslmode'], sslrootcert=os.environ['sslrootcert']) except KeyError: DATABASE = SqliteDatabase('courses.sqlite')
import os from dotenv import load_dotenv from peewee import PostgresqlDatabase from models.Oglas import Zupanija, Grad, Naselje, Oglas load_dotenv() env = os.environ db = PostgresqlDatabase( "nadimistan", user=env.get("DB_USER"), password=env.get("DB_USER_PWD"), host=env.get("DB_HOST"), ) db.create_tables([Zupanija, Grad, Naselje, Oglas])
# I Ruby/Rails så brukes det flertall i navn på databasemodeller. Siden peewee # ikke bruker dette mønsteret, så bruker vi `Meta.table_name` for å overskrive # klassenavnet. import os from datetime import datetime from peewee import PostgresqlDatabase, CharField, ForeignKeyField, Model, DateTimeField, TextField USER = os.getenv('POSTGRES_USER', 'postgres') PASSWORD = os.getenv('POSTGRES_PASSWORD', 'postgres') HOST = os.getenv('POSTGRES_SOCKET_PATH', 'localhost') DB = PostgresqlDatabase('standbot', user=USER, password=PASSWORD, host=HOST, port='5432') class BaseModel(Model): class Meta: database = DB class Team(BaseModel): class Meta: table_name = 'teams' name = CharField()
# from app.server import server # api = server.get_api() config_name = os.getenv('FLASK_CONFIG') if config_name == "development": db = SqliteDatabase("id.db") else: database = { 'user': '******', 'password': '******', 'host': '127.0.0.1', 'port': 5432 } db = PostgresqlDatabase("PAMS", **database) class BaseModel(Model): class Meta: database = db class UserRole(BaseModel): role = TextField() class User(BaseModel): username = TextField()
from peewee import ( Model, CharField, AutoField, PostgresqlDatabase, DateField, IntegerField, TextField, ) db = PostgresqlDatabase("reviews", host="localhost", user="******") class BaseModel(Model): class Meta: database = db class Album(BaseModel): id = AutoField() title = CharField() title_en = CharField() magazine_name = CharField() date = DateField() class Reader(BaseModel): id = AutoField() first_name = CharField() last_name = CharField() age = IntegerField()
import os import datetime from peewee import Model, PostgresqlDatabase, CharField, DateTimeField,\ IntegerField, TextField, BigIntegerField from playhouse.db_url import connect import settings if os.environ.get('DATABASE_URL'): database = connect(os.environ.get('DATABASE_URL')) else: database = PostgresqlDatabase( settings.DB_NAME, user=settings.DB_USER, password=settings.DB_PASS, host=settings.DB_HOST, ) class BaseModel(Model): class Meta: database = database class Users(BaseModel): name = CharField() mobile = BigIntegerField() email = CharField() idcard = TextField() rtype = CharField() tickets = IntegerField() rdate = DateTimeField(default=datetime.datetime.now)
import os from dotenv import load_dotenv from peewee import PostgresqlDatabase load_dotenv() DATABASE = os.getenv("DB_DATABASE") USER = os.getenv("DB_USER") PASSWORD = os.getenv("DB_PASSWORD") HOST = os.getenv("DB_HOST") db = PostgresqlDatabase(database=DATABASE, user=USER, password=PASSWORD, host=HOST)
import numpy as np ######################################## # Begin database stuff if 'DATABASE_URL' in os.environ: db_url = os.environ['DATABASE_URL'] dbname = db_url.split('@')[1].split('/')[1] user = db_url.split('@')[0].split(':')[1].lstrip('//') password = db_url.split('@')[0].split(':')[2] host = db_url.split('@')[1].split('/')[0].split(':')[0] port = db_url.split('@')[1].split('/')[0].split(':')[1] DB = PostgresqlDatabase( dbname, user=user, password=password, host=host, port=port, ) else: 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
import os from peewee import PostgresqlDatabase DB = PostgresqlDatabase(os.environ.get('ECONAPP_DATABASE'), user=os.environ.get('ECONAPP_DATABASE_USER'), password=os.environ.get('ECONAPP_DATABASE_PASSWORD'), host=os.environ.get('ECONAPP_DATABASE_HOST', 'localhost'))
from peewee import PostgresqlDatabase import os SECRET = os.environ.get('SECRET') POSTGRES_PASSWORD = os.environ.get('POSTGRES_PASSWORD') POSTGRES_USER = os.environ.get('POSTGRES_USER') POSTGRES_DB = os.environ.get('POSTGRES_DB') TOKEN = os.environ.get('TOKEN') GOD_ID = os.environ.get('GOD_ID') GOD_NAME = os.environ.get('GOD_NAME') MAX_SUM = os.environ.get('MAX_SUM') db = PostgresqlDatabase( POSTGRES_DB, user=POSTGRES_USER, password=POSTGRES_PASSWORD, host='db') # # for debug # from peewee import SqliteDatabase # import base64 # # db = SqliteDatabase('bot.db') # SECRET = base64.b64encode(open('secret', 'rb').read()) # TOKEN = '565567133:AAFrjt4yMptoRC1FUt8kB4RqTi1IoIEdnYY'
app = Flask(__name__) app.config.from_pyfile('flask.cfg') if app.config['ENV'] == 'development': app.config['CHROME_DRIVER'] = 'chromedriver78' app.config['DATABASE_NAME'] = 'scraping' app.config['DATABASE_HOST'] = '35.227.74.45' app.config['DATABASE_USER'] = '******' app.config['DATABASE_PASSWORD'] = '******' app.config['PROXY_LIST'] = ['127.0.0.1:80'] db = PostgresqlDatabase( app.config['DATABASE_NAME'], host=app.config['DATABASE_HOST'], port=app.config['DATABASE_PORT'], user=app.config['DATABASE_USER'], password=app.config['DATABASE_PASSWORD'] ) Bootstrap(app) # This hook ensures that a connection is opened to handle any queries # generated by the request. @app.before_request def _db_connect(): db.connect() # This hook ensures that the connection is closed when we've finished # processing the request.
import os from peewee import PostgresqlDatabase db = PostgresqlDatabase( 'scheduleDB', user='******', password='******', host='schedule-db.clhrtwy2vi9q.us-east-2.rds.amazonaws.com', port=5432) def get_secret_key(): return os.urandom(24)
import os, logging import azure.functions as func from azure.storage.blob import BlobServiceClient from peewee import PostgresqlDatabase, Model, CharField, DateTimeField, TextField db = PostgresqlDatabase(os.environ["PGDATABASE"]) class LogEntry(Model): name = CharField() created = DateTimeField() text = TextField() class Meta: indexes = ((('name', 'created'), True), ) database = db def init_database(): db.connect() db.create_tables([LogEntry]) def main(myblob: func.InputStream): container, blobname = myblob.name.split("/", 1) blobclient = BlobServiceClient.from_connection_string( os.environ["FLEETCARE_CONNSTRING"]) blob = blobclient.get_container_client(container).get_blob_client(blobname) blobprops = blob.get_blob_properties() blobtext = blob.download_blob().content_as_text()
from peewee import PostgresqlDatabase, SqliteDatabase from peewee import Model, CharField, TextField, IntegerField, BooleanField, DateTimeField, ForeignKeyField, CompositeKey import bcrypt import config if config.production: db = PostgresqlDatabase(config.database.database, user=config.database.user, password=config.database.password) else: db = SqliteDatabase("dev.db") class BaseModel(Model): class Meta: database = db class Team(BaseModel): name = CharField(unique=True) affiliation = CharField(null=True) restricts = TextField(default="") key = CharField(unique=True, index=True) eligibility = BooleanField(null=True) def solved(self, challenge): return ChallengeSolve.select().where(ChallengeSolve.team == self, ChallengeSolve.challenge == challenge).count() def eligible(self): if self.eligibility is not None: return self.eligibility return all([member.eligible() for member in self.members]) and self.members.count() <= 3
from datetime import datetime as dt import peeweedbevolve from peewee import (CharField, DateTimeField, Model, AutoField, IntegerField, PostgresqlDatabase, TextField, FloatField, ForeignKeyField, BooleanField, DecimalField) from config import PG_CONN db = PostgresqlDatabase(**PG_CONN) class BaseModel(Model): class Meta: database = db class Users(BaseModel): id = AutoField() telegram_id = IntegerField(unique=1) username = CharField(null=True, unique=1) first_name = CharField(null=True) last_name = CharField(null=True) created_dt = DateTimeField(default=dt.utcnow) last_seen_dt = DateTimeField(default=dt.utcnow) class Channels(BaseModel): id = AutoField() uuid = CharField() name = CharField(null=True) members_count = IntegerField(default=0) tid = CharField(unique=True)
import os import click from flask import g from flask.cli import with_appcontext from peewee import PostgresqlDatabase database = PostgresqlDatabase(os.environ['POSTGRES_DB'], user=os.environ['POSTGRES_USER'], password=os.environ['POSTGRES_PASSWORD'], host=os.environ['POSTGRES_HOST'], port=os.environ['POSTGRES_PORT']) def get_db(): if 'db' not in g: g.db = database return g.db def close_db(e=None): db = g.pop('db', None) if db is not None: db.close() def init_db(): db = get_db() from flaskr.models import User, Post, AuthToken db.create_tables([User, Post, AuthToken])
from peewee import PostgresqlDatabase, Model, CharField from playhouse.shortcuts import model_to_dict, dict_to_model from functools import partial db = PostgresqlDatabase('bookmarks', user='******', password='', host='localhost', port=5432) db.connect() class BaseModel(Model): class Meta: database = db class Bookmark(BaseModel): name = CharField() category = CharField() url = CharField() # db.drop_tables([Bookmark]) db.create_tables([Bookmark]) def bookmarker(): current_bookmarks() print("What would you like to do?")
from decimal import Decimal from decouple import config from peewee import PostgresqlDatabase from twitter import Api INTERVAL = config("INTERVAL", cast=lambda x: int(x) * 60) TIMEZONE = config("TIMEZONE") REDIS_URL = config("REDIS_URL") DATABASE = PostgresqlDatabase( database=config("POSTGRES_DB"), user=config("POSTGRES_USER"), password=config("POSTGRES_PASSWORD"), host=config("POSTGRES_HOST"), port=config("POSTGRES_PORT"), ) CELERY_CONFIG = {"broker": REDIS_URL, "timezone": TIMEZONE} CREDENTIALS = { "consumer_key": config("TWITTER_CONSUMER_KEY", default=None), "consumer_secret": config("TWITTER_CONSUMER_SECRET", default=None), "access_token_key": config("TWITTER_ACCESS_TOKEN", default=None), "access_token_secret": config("TWITTER_ACCESS_TOKEN_SECRET", default=None), } TWITTER = Api(**CREDENTIALS) if all(CREDENTIALS.values()) else None TWEET = config("TWEET") CONTRACT_SPEED = config("CONTRACT_SPEED", cast=lambda x: int(x) * 10**6) MINIMUM_SPEED = config("THRESHOLD", cast=lambda x: Decimal(x) * CONTRACT_SPEED)
from os import environ from flask_login import UserMixin from dsnparse import parse_environ from peewee import (SqliteDatabase, PostgresqlDatabase, Model, CharField, TextField, DateTimeField, ForeignKeyField, DecimalField, IntegerField,) if(environ.get('DATABASE_URL')): url = parse_environ('DATABASE_URL') db = PostgresqlDatabase(url.paths[0], user=url.username, password=url.password, host=url.host, port=url.port) else: db = SqliteDatabase('groovin.db') class Promoter(Model, UserMixin): name = CharField() email = CharField(unique=True) bio = TextField() password = CharField() def to_map(self): data = self.__dict__['__data__'] data.pop('password') return data class Meta: