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