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 __init__(self, db: Database):
class CasbinRule(db.Entity):
id = PrimaryKey(int, auto=True)
ptype = Required(str, max_len=255)
v0 = PonyOptional(str, max_len=255)
v1 = PonyOptional(str, max_len=255)
v2 = PonyOptional(str, max_len=255)
v3 = PonyOptional(str, max_len=255)
v4 = PonyOptional(str, max_len=255)
v5 = PonyOptional(str, max_len=255)
def __str__(self):
arr = [self.ptype]
for v in (self.v0, self.v1, self.v2, self.v3, self.v4, self.v5):
if not v:
break
arr.append(v)
return ", ".join(arr)
def __repr__(self):
return '<CasbinRule {}: "{}">'.format(self.id, str(self))
self.rule_cls = CasbinRule
self._filtered = False
db.generate_mapping(create_tables=True)
global _adapter
_adapter = self
def perform_ponyorm_benchmark(database, conn_str, args, benchmark_result):
host, user, password, db = get_metadata_from_conn_str(conn_str)
db = Database(database, host=host, user=user, passwd=password, db=db)
class Person(db.Entity):
name = Required(unicode)
addresses = Set("Address")
class Address(db.Entity):
address = Required(unicode)
person = Required(Person)
db.generate_mapping(create_tables=True)
test_data = test_data_from_args(args)
assert test_data
if 'ponyorm' not in benchmark_result:
benchmark_result['ponyorm'] = dict()
if database not in benchmark_result['ponyorm']:
benchmark_result['ponyorm'][database] = dict()
test_aspects = ['insert', 'read', 'update', 'delete']
__builtin__.__dict__.update(locals())
timeit_funcs = [
'_{0}_{1}_data(test_data, Person, Address, db)'.format(
'ponyorm', test_aspect
)
for test_aspect in test_aspects
]
for index, tf in enumerate(timeit_funcs):
rst = timeit.timeit(tf, number=args.num_repeats)
benchmark_result['ponyorm'][database][test_aspects[index]] = rst
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 perform_ponyorm_benchmark(database, conn_str, args, benchmark_result):
host, user, password, db = get_metadata_from_conn_str(conn_str)
db = Database(database, host=host, user=user, passwd=password, db=db)
class Person(db.Entity):
name = Required(unicode)
addresses = Set("Address")
class Address(db.Entity):
address = Required(unicode)
person = Required(Person)
db.generate_mapping(create_tables=True)
test_data = test_data_from_args(args)
assert test_data
if 'ponyorm' not in benchmark_result:
benchmark_result['ponyorm'] = dict()
if database not in benchmark_result['ponyorm']:
benchmark_result['ponyorm'][database] = dict()
test_aspects = ['insert', 'read', 'update', 'delete']
__builtin__.__dict__.update(locals())
timeit_funcs = [
'_{0}_{1}_data(test_data, Person, Address, db)'.format(
'ponyorm', test_aspect) for test_aspect in test_aspects
]
for index, tf in enumerate(timeit_funcs):
rst = timeit.timeit(tf, number=args.num_repeats)
benchmark_result['ponyorm'][database][test_aspects[index]] = rst
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 main():
db = Database(provider='sqlite', filename=':memory:')
appdb.bind_to(db)
db.generate_mapping(create_tables=True)
with db_session():
john, created = get_or_create(Person, {'name': 'John Swag'},
{'type': PersonType.Student})
print('Hello, {} ({}, created: {})'.format(john.name, john.type,
created))
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 _create_db_schemata(database_file, *schemata):
from pony.orm import Database
db = Database('sqlite', database_file)
models = {}
for schema in schemata:
# Build db.Entity objects for the side effect of registering them
# with the ORM
models[schema] = type(schema.__name__, (db.Entity, ),
_pony_schema_from_sheets_schema(schema))
db.generate_mapping(create_tables=True)
return db, models
def _create_db_schemata(database_file, *schemata):
from pony.orm import Database
db = Database('sqlite', database_file)
models = {}
for schema in schemata:
# Build db.Entity objects for the side effect of registering them
# with the ORM
models[schema] = type(schema.__name__, (db.Entity,),
_pony_schema_from_sheets_schema(schema))
db.generate_mapping(create_tables=True)
return db, models
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)
class TestFunc(unittest.TestCase):
def setUp(self):
self.db = Database(provider='sqlite', filename=':memory:')
define_entity(self.db)
self.db.generate_mapping(create_tables=True)
create_entities(self.db, user_data)
def tearDown(self):
self.db.drop_all_tables(with_all_data=True)
@db_session
def test_create_entities(self):
# pylint: disable=E1101
user = self.db.User.get(username="******")
self.assertEqual(user.location, 'London')
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 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)
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()
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)
def init_orm(db: orm.Database):
class Account(db.Entity, DictConversionMixin):
# __slot__ = ('name', 'balance', 'posts', 'budget_items')
name = orm.PrimaryKey(str)
balance = orm.Optional(lambda: Balance, cascade_delete=True)
posts = orm.Set(lambda: Post, cascade_delete=True)
class Balance(db.Entity, DictConversionMixin):
account = orm.PrimaryKey(Account)
amount = orm.Required(Decimal, precision=16, scale=2)
date_eod = orm.Required(Date)
class Post(db.Entity, DictConversionMixin):
account = orm.Required(Account)
amount = orm.Required(Decimal, precision=16, scale=2)
date_occurred = orm.Required(Date)
date_resolved = orm.Required(Date)
transaction = orm.Optional(lambda: Transaction)
class Transaction(db.Entity, DictConversionMixin):
uid = orm.PrimaryKey(str, auto=True)
min_date_occurred = orm.Required(Date)
max_date_resolved = orm.Required(Date)
description = orm.Optional(str)
ref = orm.Optional(str)
posts = orm.Set(Post)
@classmethod
def from_posts(cls, posts: List[Tuple[Account, float, Date, Date]]):
db_posts = [
db.Post(account=acc,
amount=amt,
date_occurred=date_o,
date_resolved=date_r)
for acc, amt, date_o, date_r in posts
]
return db.Transaction(uid=str(uuid.uuid4()),
min_date_occurred=min(p.date_occurred
for p in db_posts),
max_date_resolved=max(p.date_resolved
for p in db_posts),
posts=db_posts)
db.generate_mapping(create_tables=True)
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)
"""
Pony ORM model of album table
"""
artist = pny.Required(Artist)
title = pny.Required(unicode)
release_date = pny.Required(datetime.date)
publisher = pny.Required(unicode)
media_type = pny.Required(unicode)
# turn on debug mode
#pny.sql_debug(True)
# map the models to the database
# and create the tables, if they don't exist
database.generate_mapping(create_tables=True)
@pny.db_session
def add_data():
""""""
new_artist = Artist(name=u"Newsboys")
bands = [u"MXPX", u"Kutless", u"Thousand Foot Krutch"]
for band in bands:
artist = Artist(name=band)
album = Album(artist=new_artist,
title=u"Read All About It",
release_date=datetime.date(1988, 12, 1),
publisher=u"Refuge",
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 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()
if pydict == '':
class Main(db.Entity):
"""
ORM 中的表结构，这里的变量名即存放进数据库的列名
不能为这个 class 重写 str 或 repr 方法
因为 pony 存放的时候会调用这个方法
"""
id = PrimaryKey(int, size=64, unsigned=True)
hitokoto = Required(str)
source = Required(str)
origin = Required(str)
with db_session:
db.generate_mapping()
Helper = type('Helper', (object, ),
{'amount': Main.select(lambda p: p.id).count()})
def fmt_data(c: dict, url: str) -> None:
hitokoto_tmp = c.get('hitokoto') or c.get('text') or c.get('HITO')
source = c.get('source') or c.get('from') or c.get('SOURCE')
hitokoto = sub(r'[\xa0-\xad]', '', hitokoto_tmp)
origin = url.split('.')[1]
# 去除一些无用字符
fmt_hitokoto = sub(r'[,，。.“” …！、\!\?：’；\\‘？「/」—-♬《》⋯『』（）]', '', hitokoto)
id_ = xxh64(fmt_hitokoto).intdigest()
if (source and origin):
insert_data(id_, hitokoto, source, origin)
from pony.orm import Database, PrimaryKey, Optional, db_session, commit ,CommitException
db = Database(
'mysql',
host = 'localhost',
user = '******',
password = '',
database = 'redes_sociais_tt'
)
class Tweet(db.Entity):
id = PrimaryKey(int, auto = True)
#text = Required(str)
text = Optional(str)
hashtag = Optional(int)
db.generate_mapping()
@db_session
def getAllTweets():
return Tweet.select()
@db_session
def save(t):
try:
_ = Tweet(text=t)
commit()
return True
except CommitException:
return False
rosa_prosjek = Optional(float)
prognoza = Required(str)
preostalo_dana = Required(int)
class Predikcije(db.Entity):
id = PrimaryKey(str)
dan_boravka = Required(dt.date)
sif_rezervacije = Required(str)
vrsta_sobe = Required(str)
kanal = Required(str)
jedinice = Required(int)
iznos_bruto = Required(float)
predikcije = Required(int)
datum_predikcije = Required(dt.date)
db.generate_mapping(check_tables=True, create_tables=True)
# test
if __name__ == "__main__":
with db_session() as s:
u = User(id="1", ime="Test", prezime="Test", email="test@test", mob="12345", rola="user", lozinka="123")
b = Hotel(id="1", naziv="Croatia")
p = Soba(id="1", naziv="Socijalna skrb", sifra="Prva")
t = Rezervacija(id = "1", sif_hotela = "28", godina = "2017", sif_rezervacije = "2618", rbr_stavke = 1, vrijeme_kreiranje = "14:08:03", datum_kreiranja = "2017-04-22", datum_od = "2017-04-24", datum_do = "2017-04-26", broj_dana = 2, sif_usluge = "PLO", status_rezervacije = "F", datum_do_potvrde_opcije = "23.04.2017", sif_drzave = "HRV", sif_agencije = "5596", tip_ro = "O", obaveza_akontacije = "NE", iznos_akontacije = "0", storno = "NE", vrijeme_storna = "14:08:03", datum_storna = "2017-04-25", broj_osoba = 2, broj_djece = 1, broj_soba = 1, nocenja = 4, jedinice = 4, cijena_pans_usl = 163.8, iznos_bruto = 655.4, valuta = "EUR", tecaj = 7.45, lead_time_dani = 2, dat_storna_do_dat_dolaska = 1, tip_garancije = "D", postotak_akontacije = 0, mjesec = 4, godina_rezervacije = "2017", vrsta_sobe = "D110", kanal = "Individualci", nacin_rezervacije = "Recepcija", vrsta_sobe_naplata = "B2")
d = Drzava(id="1", naziv="Croatija")
v = VremePrognoza(id="1", prognoza_za_datum = "2020-03-23", datum_prognoze = dt.datetime.now(), temp_prosjek = 5.0, temp_max = 7.3, temp_min = 1.6, vidljivost = 0.0, smjer_vjetra_stupnjevi = 44, brzina_vjetra = 7.88496, nalet_vjetra_brzina = 16.8236, relativna_vlaznost = "33", tlak_zraka = 1025.64, uv_index = 4.44799, oblaci_pokrice = 22, oborine_akumulirano = 0.0, dubina_snijega = 0, rosa_prosjek = -10.2, prognoza = "Scattered clouds", preostalo_dana = 3)
r = RezervacijaDani(id = "1", id_rezervacije = "1", sif_hotela = "28", godina = "2017", sif_rezervacije = "2618", rbr_stavke = 1, vrijeme_kreiranje = "14:08:03", datum_kreiranja = "2017-04-22", broj_dana = 2, sif_usluge = "PLO", status_rezervacije = "F", datum_do_potvrde_opcije = "23.04.2017", sif_drzave = "HRV", sif_agencije = "5596", tip_ro = "O", obaveza_akontacije = "NE", iznos_akontacije = "0", storno = "NE", vrijeme_storna = "14:08:03", datum_storna = "2017-04-25", broj_osoba = 2, broj_djece = 1, broj_soba = 1, nocenja = 4, jedinice = 4, cijena_pans_usl = 163.8, iznos_bruto = 655.4, valuta = "EUR", tecaj = 7.45, lead_time_dani = 2, dat_storna_do_dat_dolaska = 1, tip_garancije = "D", postotak_akontacije = 0, mjesec = 4, godina_rezervacije = "2017", vrsta_sobe = "D110", kanal = "Individualci", nacin_rezervacije = "Recepcija", vrsta_sobe_naplata = "B2", dan_boravka = "2017-04-23")
o = Predikcije(id = 1, dan_boravka = "2020-01-20", vrsta_sobe = 'A2120', kanal = 'Individualci', jedinice = 1, iznos_bruto = 1000.00, predikcije = 1, datum_predikcije = dt.datetime.now())
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
