def define_db(*args, **kwargs):
set_sql_debug(app.debug, True)
db = Database()
db.bind(*args, **kwargs)
define_entities(db)
db.generate_mapping(create_tables=True)
return db
def clean_core(args):
major_version = '.'.join(get_distribution('CGRdb').version.split('.')[:-1])
schema = args.name
db_config = Database()
LazyEntityMeta.attach(db_config, database='CGRdb_config')
db_config.bind('postgres', **args.connection)
db_config.generate_mapping()
with db_session:
config = db_config.Config.get(name=schema, version=major_version)
if not config:
raise KeyError('schema not exists or version incompatible')
config = config.config
for p in config['packages']:
try:
p = get_distribution(p)
import_module(p.project_name)
except (DistributionNotFound, VersionConflict):
raise ImportError(
f'packages not installed or has invalid versions: {p}')
db = Database()
LazyEntityMeta.attach(db, schema, 'CGRdb')
db.bind('postgres', **args.connection)
db.generate_mapping()
with db_session:
db.execute(f'TRUNCATE TABLE "{schema}"."MoleculeSearchCache", '
f'"{schema}"."ReactionSearchCache" RESTART IDENTITY')
def pony_setup(request, app, tmpdir, realdburl):
pytest.importorskip("pony")
from pony.orm import Database, Optional, Required, Set
from pony.orm.core import SetInstance
SetInstance.append = SetInstance.add
db = Database()
class Role(db.Entity):
name = Required(str, unique=True)
description = Optional(str, nullable=True)
users = Set(lambda: User)
class User(db.Entity):
email = Required(str)
fs_uniquifier = Required(str, nullable=False)
username = Optional(str)
security_number = Optional(int)
password = Optional(str, nullable=True)
last_login_at = Optional(datetime)
current_login_at = Optional(datetime)
tf_primary_method = Optional(str, nullable=True)
tf_totp_secret = Optional(str, nullable=True)
tf_phone_number = Optional(str, nullable=True)
us_totp_secrets = Optional(str, nullable=True)
us_phone_number = Optional(str, nullable=True)
last_login_ip = Optional(str)
current_login_ip = Optional(str)
login_count = Optional(int)
active = Required(bool, default=True)
confirmed_at = Optional(datetime)
roles = Set(lambda: Role)
def has_role(self, name):
return name in {r.name for r in self.roles.copy()}
if realdburl:
db_url, db_info = _setup_realdb(realdburl)
pieces = urlsplit(db_url)
db.bind(
provider=pieces.scheme.split("+")[0],
user=pieces.username,
password=pieces.password,
host=pieces.hostname,
database=pieces.path[1:],
)
else:
app.config["DATABASE"] = {"name": ":memory:", "engine": "pony.SqliteDatabase"}
db.bind("sqlite", ":memory:", create_db=True)
db.generate_mapping(create_tables=True)
def tear_down():
if realdburl:
_teardown_realdb(db_info)
request.addfinalizer(tear_down)
return PonyUserDatastore(db, User, Role)
def update_core(args):
major_version = '.'.join(get_distribution('CGRdb').version.split('.')[:-1])
schema = args.name
db_config = Database()
LazyEntityMeta.attach(db_config, database='CGRdb_config')
db_config.bind('postgres',
user=args.user,
password=args.password,
host=args.host,
database=args.base,
port=args.port)
db_config.generate_mapping()
with db_session:
config = db_config.Config.get(name=schema, version=major_version)
if not config:
raise KeyError('schema not exists or version incompatible')
config = config.config
for p in config['packages']:
try:
p = get_distribution(p)
import_module(p.project_name)
except (DistributionNotFound, VersionConflict):
raise ImportError(
f'packages not installed or has invalid versions: {p}')
db = Database()
LazyEntityMeta.attach(db, schema, 'CGRdb')
db.bind('postgres',
user=args.user,
password=args.password,
host=args.host,
database=args.base,
port=args.port)
db.generate_mapping()
with db_session:
db.execute(init_session.replace('{schema}', schema))
db.execute(merge_molecules.replace('{schema}', schema))
db.execute(insert_molecule.replace('{schema}', schema))
db.execute(after_insert_molecule.replace('{schema}', schema))
db.execute(delete_molecule.replace('{schema}', schema))
db.execute(insert_reaction.replace('{schema}', schema))
db.execute(search_similar_molecules.replace('{schema}', schema))
db.execute(search_substructure_molecule.replace('{schema}', schema))
db.execute(search_similar_reactions.replace('{schema}', schema))
db.execute(search_substructure_reaction.replace('{schema}', schema))
db.execute(
search_substructure_fingerprint_molecule.replace(
'{schema}', schema))
db.execute(
search_similar_fingerprint_molecule.replace('{schema}', schema))
db.execute(search_reactions_by_molecule.replace('{schema}', schema))
db.execute(search_mappingless_reaction.replace('{schema}', schema))
def _bind(db_file: Path, create_tables=False) -> Database:
db = Database()
_define_entities(db)
db.bind(provider="sqlite", filename=str(db_file))
db.generate_mapping(create_tables=create_tables)
return db
def model():
_db = Database()
class TestModel(_db.Entity, NapMixin):
pass
_db.bind('sqlite', ':memory:')
_db.generate_mapping(create_tables=True)
return TestModel
def init_core(args):
db = Database()
LazyEntityMeta.attach(db, database='CGRdb_config')
db.bind('postgres', **args.connection)
db.generate_mapping(create_tables=True)
with db_session:
db.execute('CREATE EXTENSION IF NOT EXISTS intarray')
db.execute('CREATE EXTENSION IF NOT EXISTS plpython3u')
def init_core(args):
db = Database()
LazyEntityMeta.attach(db, database='CGRdb_config')
db.bind('postgres',
user=args.user,
password=args.password,
host=args.host,
database=args.base,
port=args.port)
db.generate_mapping(create_tables=True)
def index_core(args):
major_version = '.'.join(get_distribution('CGRdb').version.split('.')[:-1])
schema = args.name
db_config = Database()
LazyEntityMeta.attach(db_config, database='CGRdb_config')
db_config.bind('postgres',
user=args.user,
password=args.password,
host=args.host,
database=args.base,
port=args.port)
db_config.generate_mapping()
with db_session:
config = db_config.Config.get(name=schema, version=major_version)
if not config:
raise KeyError('schema not exists or version incompatible')
config = config.config
for p in config['packages']:
try:
p = get_distribution(p)
import_module(p.project_name)
except (DistributionNotFound, VersionConflict):
raise ImportError(
f'packages not installed or has invalid versions: {p}')
db = Database()
LazyEntityMeta.attach(db, schema, 'CGRdb')
db.bind('postgres',
user=args.user,
password=args.password,
host=args.host,
database=args.base,
port=args.port)
db.generate_mapping()
with db_session:
db.execute(
f'CREATE INDEX idx_moleculestructure__smlar ON "{schema}"."MoleculeStructure" USING '
'GIST (fingerprint _int4_sml_ops)')
db.execute(
f'CREATE INDEX idx_moleculestructure__subst ON "{schema}"."MoleculeStructure" USING '
'GIN (fingerprint gin__int_ops)')
db.execute(
f'CREATE INDEX idx_reactionindex__smlar ON "{schema}"."ReactionIndex" USING '
'GIST (fingerprint _int4_sml_ops)')
db.execute(
f'CREATE INDEX idx_reactionindex__subst ON "{schema}"."ReactionIndex" USING '
'GIN (fingerprint gin__int_ops)')
def create_core(**kwargs):
schema = kwargs['name']
user = DB_USER if kwargs['user'] is None else kwargs['user']
password = DB_PASS if kwargs['pass'] is None else kwargs['pass']
x = Database()
load_tables(x, schema)
if DEBUG:
sql_debug(True)
x.bind('sqlite', '../database.sqlite')
else:
x.bind('postgres', user=user, password=password, host=DB_HOST, database=DB_NAME)
x.generate_mapping(create_tables=True)
def db(self):
db = Database()
load_tables(db, 'cgrdb', None)
db.bind('postgres',
user='******',
password='******',
host=None,
database=None)
with db_session:
db.execute('drop SCHEMA cgrdb CASCADE')
db.execute('CREATE SCHEMA cgrdb')
db.generate_mapping(create_tables=True)
return db
def geef_chocoladeletters(familie: list):
db = Database()
db.bind(provider='sqlite', filename=':memory:', create_db=True)
db.generate_mapping(create_tables=True)
for familielid in familie:
if isinstance(familielid, Familielid):
persoon = Persoon(naam=familielid.naam,
geboortedatum=familielid.geboortedatum)
cadeau_idee = 'chocoladeletter ' + familielid.naam[:1].upper()
aanleiding = 'Sinterklaas'
cadeau = Cadeau(aanleiding=aanleiding,
omschrijving=cadeau_idee,
datum=vandaag())
commit()
def load_schemas(cls):
if not cls.__schemas:
for schema in DB_DATA_LIST:
x = Database()
cls.__schemas[schema] = x
cls.__databases[schema] = load_tables(x, schema)
if DEBUG:
x.bind('sqlite', 'database.sqlite')
else:
x.bind('postgres',
user=DB_USER,
password=DB_PASS,
host=DB_HOST,
database=DB_NAME)
x.generate_mapping(create_tables=False)
class Client:
db: Database
mappings: List[str] = []
def bind_db(self):
self.db = Database()
self.db.bind(
provider="sqlite", filename=str(BASE_DIR / "db.sqlite3"), create_db=True
)
@property
def Entity(self) -> Type[Entity]:
return self.db.Entity
def generate_mappings(self):
from model import Profile, Message
self.db.generate_mapping(create_tables=True)
class DatabaseTest(unittest.TestCase):
def setUp(self):
self.db = Database()
def tearDown(self):
self.db = None
def test_database_connection(self):
try:
self.db.bind(
provider="postgres",
user="******",
password="******",
host="127.0.0.1",
database="mealcare_dev",
)
except (Exception, psycopg2.Error) as error:
self.fail(error)
def connect(fname: str = None,
create_db: bool = False,
create_tables: bool = False) -> Database:
db = Database()
define_entities(db)
environment = os.environ.get('ENV', "DEVELOPMENT")
if environment == "DEVELOPMENT":
fname = fname if fname is not None else "rooms.sqlite"
db.bind("sqlite", filename=fname, create_db=create_db)
db.generate_mapping(create_tables=create_tables)
else:
db.bind(provider="mysql",
host="publicdb",
user="******",
password="******",
db="rooms_db")
db.generate_mapping(create_tables=create_tables)
return db
def __init__(self, bindargs, tokenizer: Tokenizer):
"""
:param bindargs: pony bind args such as {'provider':'sqlite', 'filename':':memory:'}
:param tokenizer: A class implementing :class:`tokenizer.Tokenizer`
"""
self.tokenizer = tokenizer
# set_sql_debug(True)
db = Database()
self.db = db
@db.on_connect(provider="sqlite")
def sqlite_sync_off(db, connection):
cursor = connection.cursor()
cursor.execute("PRAGMA synchronous = OFF")
cursor.execute("PRAGMA cache_size = 64000")
cursor.execute("PRAGMA journal_mode = OFF")
class Token(db.Entity):
tok = Required(str, unique=True)
doc_freq = Required(int)
documents = Set("Document")
class Document(db.Entity):
# url = pony.orm.core.Index(Required(str))
url_sha = PrimaryKey(str)
url = Required(str, unique=True)
filename = Required(str)
mtime = Required(int)
content = Optional(LongStr)
content_sha = Optional(str)
tokens = Set("Token")
tokfreq = Required(bytes)
self.Token = Token
self.Document = Document
db.bind(**bindargs)
db.generate_mapping(create_tables=True)
self.update()
def create_core(args):
schema = args.name
config = args.config and load(args.config) or {}
db_config = Database()
LazyEntityMeta.attach(db_config, database='CGRdb_config')
db_config.bind('postgres', user=args.user, password=args.password, host=args.host, database=args.base,
port=args.port)
db_config.generate_mapping()
db = Database()
LazyEntityMeta.attach(db, schema, 'CGRdb')
db.bind('postgres', user=args.user, password=args.password, host=args.host, database=args.base, port=args.port)
db.generate_mapping(create_tables=True)
with db_session:
db.execute('CREATE EXTENSION IF NOT EXISTS smlar')
db.execute('CREATE EXTENSION IF NOT EXISTS intarray')
db.execute('CREATE EXTENSION IF NOT EXISTS pg_cron')
with db_session:
db.execute(f'CREATE INDEX idx_smlar_molecule_structure ON "{schema}"."MoleculeStructure" USING '
'GIST (bit_array _int4_sml_ops)')
db.execute(f'CREATE INDEX idx_smlar_reaction_index ON "{schema}"."ReactionIndex" USING '
'GIST (bit_array _int4_sml_ops)')
db.execute(f'CREATE INDEX idx_subst_molecule_structure ON "{schema}"."MoleculeStructure" USING '
'GIN (bit_array gin__int_ops)')
db.execute(f'CREATE INDEX idx_subst_reaction_index ON "{schema}"."ReactionIndex" USING '
'GIN (bit_array gin__int_ops)')
db.execute(f"SELECT cron.schedule('0 3 * * *', $$$$\n"
f'DELETE FROM "{schema}"."MoleculeSearchCache"'
" WHERE date < CURRENT_TIMESTAMP - INTERVAL '1 day' $$$$)")
db.execute(f"SELECT cron.schedule('0 3 * * *', $$$$\n"
f'DELETE FROM "{schema}"."ReactionSearchCache"'
" WHERE date < CURRENT_TIMESTAMP - INTERVAL '1 day' $$$$)")
with db_session:
db_config.Config(name=schema, config=config, version=major_version)
def load_schema(schema, *args, **kwargs):
"""
Load schema from db with compatible version
:param schema: schema name for loading
"""
major_version = '.'.join(get_distribution('CGRdb').version.split('.')[:-1])
db_config = Database()
LazyEntityMeta.attach(db_config, database='CGRdb_config')
db_config.bind('postgres', *args, **kwargs)
db_config.generate_mapping()
with db_session:
config = db_config.Config.get(name=schema, version=major_version)
if not config:
raise KeyError('schema not exists')
config = config.config
for p in config['packages']:
try:
p = get_distribution(p)
import_module(p.project_name)
except (DistributionNotFound, VersionConflict):
raise ImportError(
f'packages not installed or has invalid versions: {p}')
db = Database()
LazyEntityMeta.attach(db, schema, 'CGRdb')
db.bind('postgres', *args, **kwargs)
db.generate_mapping()
init = f'SELECT "{schema}".cgrdb_init_session(\'{dumps(config)}\')'
db.cgrdb_init_session = db_session()(
lambda: db.execute(init) and True or False)
db.cgrdb_init_session()
return db
class Application(object):
instance = None
@staticmethod
def create(token):
if Application.instance is None:
Application.instance = Application(token)
Application.instance.setup_db()
return Application.instance
def __init__(self, token):
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
self.handler = Handler(token)
def setup_db(self):
self.db = Database()
self.db.bind('sqlite', 'db.sqlite', create_db=True)
self.inject_models()
self.inject_controllers()
def inject_controllers(self):
from telebotty.telebotty.controller import Controller
for cl in get_classes('controllers'):
if cl is not Controller and issubclass(cl, Controller):
logging.log(logging.INFO, 'Control class is loaded %s' % cl)
cl(self)
def inject_models(self):
for cl in get_classes('models'):
if cl is not self.db.Entity and issubclass(cl, self.db.Entity):
logging.log(logging.INFO, 'Entity class is loaded %s' % cl)
self.db.generate_mapping(create_tables=True)
# database.py
from pony.orm import Database, PrimaryKey, Required, Optional
db = Database()
class Mahasiswa(db.Entity):
id = PrimaryKey(int, auto=True)
nik = Optional(int)
name = Required(str)
address = Optional(str)
gender_id = Optional(int)
class Gender(db.Entity):
gender_id = Optional(int)
name = Required(str)
# connect to mysql
db.bind('mysql', host='localhost', user='******', passwd='', db='universitas')
# from pathlib import Path
import json
import pprint
import secrets
from datetime import datetime
db = Database()
class Sessions(db.Entity):
sessionid = PrimaryKey(str)
datetime = Required(datetime)
jsonstr = Optional(str)
db.bind(provider='sqlite', filename='db/SessionsLog.db', create_db=False)
db.generate_mapping(create_tables=False)
def _getdict():
with db_session:
jsoninfo = Sessions[sessionID]
value = jsoninfo.jsonstr
if value is None or value == '':
return ''
value = json.loads(value)
return value
def getSession(name):
pydict = _getdict()
class Cinema(db.Entity):
name = Required(str)
city = Required(CinemaCity)
rooms = Set("CinemaRoom")
PrimaryKey(name, city)
class CinemaRoom(db.Entity):
name = Required(str)
cinema = Required(Cinema)
shows = Set("Show")
PrimaryKey(name, cinema)
class Show(db.Entity):
movie = Required(Movie)
room = Required(CinemaRoom)
date = Required(datetime.datetime)
PrimaryKey(movie, room, date)
db.bind(provider="postgres",
user=config.POSTGRES_USER,
password=config.POSTGRES_PASSWORD,
host=config.POSTGRES_HOST,
port=config.POSTGRES_PORT,
database=config.POSTGRES_DB)
db.generate_mapping(create_tables=True)
ping_interval=None)
await ctx.server
for wssocket in ctx.server.ws_server.sockets:
socketname = wssocket.getsockname()
if wssocket.family == socket.AF_INET6:
logging.info(
f'Hosting game at [{get_public_ipv6()}]:{socketname[1]}')
elif wssocket.family == socket.AF_INET:
logging.info(
f'Hosting game at {get_public_ipv4()}:{socketname[1]}')
while ctx.running:
await asyncio.sleep(1)
logging.info("Shutting down")
import asyncio
if ".." not in sys.path:
sys.path.append("..")
from MultiServer import Context, server
from Utils import get_public_ipv4, get_public_ipv6
import socket
asyncio.run(main())
if __name__ == "__main__":
multiprocessing.freeze_support()
multiprocessing.set_start_method('spawn')
db.bind(**app.config["PONY"])
db.generate_mapping(create_tables=True)
app.run(debug=True)
from flask import Flask from pony.flask import Pony from pony.orm import Database app = Flask(__name__) Pony(app) db = Database() db.bind(provider='sqlite', filename='database.sqlite', create_db=True) import views db.generate_mapping(create_tables=True)
from pony.orm import Database, Required
db = Database()
db.bind(provider="sqlite", filename="weather.db", create_db=True)
class Weather(db.Entity):
"""Погода"""
date = Required(str)
temperature_day = Required(str)
temperature_night = Required(str)
day_description = Required(str)
db.generate_mapping(create_tables=True)
import sys
from datetime import (date, datetime)
from pony.orm import (Database, Required, Optional, Set, db_session, sql_debug, show, select, commit)
db = Database()
sql_debug(True)
class Task(db.Entity):
task = Required(str)
date_created = Required(date)
date_of_completion = Optional(date)
db.bind('sqlite', filename='Jara.sqlite',create_db=True)
db.generate_mapping(create_tables=True)
def main():
actions = {
'1': action_find_all,
'2': action_find_by_pk,
'3': action_find_by_created,
'4': action_find_by_date_of_completion,
'5': action_add_task,
'6': action_update_task,
'7': action_add_date_of_completion,
'8': action_add_date_of_completion,
'm': action_show_menu,
'q': action_exit
#!/usr/bin/env python # coding=utf-8 # [email protected] from datetime import datetime from settings import SETTINGS from pony.orm import Database, Required, Optional, PrimaryKey db = Database() db.bind('sqlite', SETTINGS['sqlite_file'], create_db=True) class User(db.Entity): uuid = PrimaryKey(str, 36) wechat_uuid = Optional(str, 36) is_valid = Required(int, size=8) created_at = Required(datetime, sql_default='CURRENT_TIMESTAMP') db.generate_mapping(create_tables=True)
#!/usr/bin/env python
from pony.orm import Database
db = Database()
from .post import Post
db.bind('sqlite', '../db.sqlite', create_db=True)
db.generate_mapping(create_tables=True)
__all__ = ('Post',)
@staticmethod
def get_fear(reaction):
return fear.get_cgr_string(cgr_core.getCGR(reaction))
@property
def structure(self):
products = []
substrats = []
for mr in self.molecules:
molcont = nx.relabel_nodes(mr.molecule.structure, dict(mr.mapping))
if mr.product:
products.append(molcont)
else:
substrats.append(molcont)
return ReactionContainer(products=products, substrats=substrats)
class ReactionsMolecules(db.Entity):
id = PrimaryKey(int, auto=True)
molecule = Required(Molecules)
reaction = Required(Reactions)
product = Required(bool)
mapping = Required(Json)
db.bind("sqlite", "datatest.db")
db.generate_mapping(create_tables=True)
sql_debug(True)
# Copyright 2021 21CN Corporation Limited
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
# -*- coding: utf-8 -*-
from pony.orm import Database, set_sql_debug
from config import db_user, db_password, db_host, db_port, db_name
db = Database()
db.bind(provider='postgres',
user=db_user,
password=db_password,
host=db_host,
port=db_port,
database=db_name)
set_sql_debug(True)
name = Required(str)
order = Optional('Order')
class OrderItem(db.Entity):
"""Товар (одна позиция) в заказе"""
order = Required("Order")
product = Optional('Product')
amount = Required(int) # 1 единица товара
class Menu:
"""Меню"""
db.bind(provider='sqlite', filename='shop.sqlite', create_db=True)
db.generate_mapping(create_tables=True)
sql_debug(True)
@db_session
def add_product():
product_1 = Product(title='M200 "Intervention"',
description='Make your self a long joy',
price=11850,
unit='1')
product_2 = Product(title='Mossberg 500',
description='For close relationships',
price=370.34,
unit='1')
product_3 = Product(title='Ammo .408 Cheyenne Tactical',
from pony.orm import Database, Required, Json, select
from Settings import DB_CONFIG
db = Database()
db.bind(**DB_CONFIG)
class UserStates(db.Entity):
"""Состояние польхователя внутри сценария"""
user_id = Required(str, unique=True)
scenario_name = Required(str)
step_name = Required(str)
context = Required(Json)
class Registration(db.Entity):
"""Заявка на регистрацию"""
name = Required(str)
city_from = Required(str)
city_to = Required(str)
date = Required(str)
db.generate_mapping(create_tables=True)
from pony.orm import Database, sql_debug
from helpers import CommandFailure
from configstartup import config
DB_FILE = config['FILES'].get('DB')
db = Database()
db.bind('sqlite', DB_FILE, create_db=True)
class Table(object):
@classmethod
def get_or_err(cls, err=None, **kwargs):
obj = cls.get(**kwargs)
if obj is None:
raise CommandFailure(cls.err if err is None else err)
return obj
@classmethod
def create_or_update(cls, **kwargs):
old_obj = cls.get(**dict((k, kwargs[k]) for k in cls._pk_columns_))
if old_obj is None:
return cls(**kwargs)
for k, v in kwargs.items():
if k not in cls._pk_columns_:
setattr(old_obj, k, v)
return old_obj
@classmethod
def delete_or_err(cls, err=None, **kwargs):
from pony.orm import Database
db = Database()
db.bind('sqlite', 'app.db')
