def test_freezer_one(self): import ptah class Test(ptah.get_base()): __tablename__ = 'test10' id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column(sqla.Unicode()) ptah.get_base().metadata.create_all() transaction.commit() sql_get = ptah.QueryFreezer( lambda: Session.query(Test) .filter(Test.name == sqla.sql.bindparam('name'))) self.assertRaises( sqla.orm.exc.NoResultFound, sql_get.one, name='test') rec = Test() rec.name = 'test' Session.add(rec) Session.flush() rec = sql_get.one(name='test') self.assertEqual(rec.name, 'test') rec = Test() rec.name = 'test' Session.add(rec) Session.flush() self.assertRaises( sqla.orm.exc.MultipleResultsFound, sql_get.one, name='test')
def test_freezer_first(self): import ptah class Test(ptah.get_base()): __tablename__ = "test12" id = sqla.Column("id", sqla.Integer, primary_key=True) name = sqla.Column(sqla.Unicode()) Session = ptah.get_session() ptah.get_base().metadata.create_all() transaction.commit() sql_get = ptah.QueryFreezer(lambda: Session.query(Test).filter(Test.name == sqla.sql.bindparam("name"))) self.assertIsNone(sql_get.first(name="test")) rec = Test() rec.name = "test" Session.add(rec) Session.flush() rec = sql_get.one(name="test") self.assertEqual(rec.name, "test") sql_get.reset() rec = sql_get.one(name="test") self.assertEqual(rec.name, "test")
def test_freezer_all(self): import ptah class Test(ptah.get_base()): __tablename__ = 'test13' id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column(sqla.Unicode()) ptah.get_base().metadata.create_all() transaction.commit() sql_get = ptah.QueryFreezer( lambda: Session.query(Test) .filter(Test.name == sqla.sql.bindparam('name'))) self.assertIsNone(sql_get.first(name='test')) rec = Test() rec.name = 'test' Session.add(rec) Session.flush() rec = sql_get.all(name='test') self.assertEqual(rec[0].name, 'test')
def test_freezer_one(self): import ptah class Test(ptah.get_base()): __tablename__ = 'test10' id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column(sqla.Unicode()) Session = ptah.get_session() ptah.get_base().metadata.create_all() transaction.commit() sql_get = ptah.QueryFreezer(lambda: Session.query(Test).filter( Test.name == sqla.sql.bindparam('name'))) self.assertRaises(sqla.orm.exc.NoResultFound, sql_get.one, name='test') rec = Test() rec.name = 'test' Session.add(rec) Session.flush() rec = sql_get.one(name='test') self.assertEqual(rec.name, 'test') rec = Test() rec.name = 'test' Session.add(rec) Session.flush() self.assertRaises(sqla.orm.exc.MultipleResultsFound, sql_get.one, name='test')
def test_freezer_all(self): import ptah class Test(ptah.get_base()): __tablename__ = 'test13' id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column(sqla.Unicode()) Session = ptah.get_session() ptah.get_base().metadata.create_all() transaction.commit() sql_get = ptah.QueryFreezer(lambda: Session.query(Test).filter( Test.name == sqla.sql.bindparam('name'))) self.assertIsNone(sql_get.first(name='test')) rec = Test() rec.name = 'test' Session.add(rec) Session.flush() rec = sql_get.all(name='test') self.assertEqual(rec[0].name, 'test')
def test_settings_load_from_db_on_startup(self): grp = self._make_grp() grp.updatedb(node1='new text', node2=65) grp.clear() ptah.get_base().metadata.tables['ptah_db_versions'].drop() self.config.make_wsgi_app() self.assertEqual(grp['node1'], 'new text') self.assertEqual(grp['node2'], 65)
def test_settings_load_from_db_on_startup_do_not_brake(self): from ptah.settings import SettingRecord ptah.get_base().metadata.drop_all() grp = self._make_grp() self.config.make_wsgi_app() self.assertEqual(grp['node1'], 'test') self.assertEqual(grp['node2'], 50) self.assertFalse(SettingRecord.__table__.exists())
def test_settings_load_from_db_on_startup(self): grp = self._make_grp() grp.updatedb(node1 = 'new text', node2 = 65) grp.clear() ptah.get_base().metadata.tables['ptah_db_versions'].drop() self.config.make_wsgi_app() self.assertEqual(grp['node1'], 'new text') self.assertEqual(grp['node2'], 65)
def upgrade(): # it possible that this script is being called on new database # in this case we should not do anything insp = reflection.Inspector.from_engine(ptah.get_base().metadata.bind) if 'annotations' in [r['name'] for r in insp.get_columns('ptah_nodes')]: return # ptah_nodes op.add_column('ptah_nodes', sa.Column('annotations', ptah.JsonDictType(), default={})) # ptah_content op.add_column('ptah_content', sa.Column('lang', sa.String(12), default='en')) op.create_index('ix_ptah_content_path', 'ptah_content', ('path', )) # sqlite doesnt support column drop impl = context.get_impl() if impl.__dialect__ != 'sqlite': op.drop_column('ptah_content', 'view') op.drop_column('ptah_content', 'creators') op.drop_column('ptah_content', 'subjects') op.drop_column('ptah_content', 'publisher') op.drop_column('ptah_content', 'contributors') op.drop_table('test_sqla_table')
def upgrade(): # it possible that this script is being called on new database # in this case we should not do anything insp = reflection.Inspector.from_engine(ptah.get_base().metadata.bind) if "annotations" in [r["name"] for r in insp.get_columns("ptah_nodes")]: return # ptah_nodes op.add_column("ptah_nodes", sa.Column("annotations", ptah.JsonDictType(), default={})) # ptah_content op.add_column("ptah_content", sa.Column("lang", sa.String(12), default="en")) op.create_index("ix_ptah_content_path", "ptah_content", ("path",)) # sqlite doesnt support column drop impl = context.get_impl() if impl.__dialect__ != "sqlite": op.drop_column("ptah_content", "view") op.drop_column("ptah_content", "creators") op.drop_column("ptah_content", "subjects") op.drop_column("ptah_content", "publisher") op.drop_column("ptah_content", "contributors") op.drop_table("test_sqla_table")
class User(ptah.get_base()): __tablename__ = 'rackptahbles_users' pid = sqla.Column(sqla.Integer, primary_key=True) uri = sqla.Column(sqla.Unicode, unique=True, info={'uri': True}) name = sqla.Column(sqla.Unicode) login = sqla.Column(sqla.Unicode, unique=True) email = sqla.Column(sqla.Unicode, unique=True) password = sqla.Column(sqla.Unicode) _uri_gen = ptah.UriFactory('custom-user') def __init__(self, name, login, email, password=u''): super(User, self).__init__() self.name = name self.login = login self.email = email self.password = ptah.pwd_tool.encode(password) self.uri = self._uri_gen() @classmethod def get_byuri(cls, uri): return ptah.get_session().query(User).filter(User.uri==uri).first() @classmethod def get_bylogin(cls, login): return ptah.get_session().query(User).filter(User.login==login).first()
def test_ptahinit_sqla(self): config = Configurator(settings={'sqlalchemy.url': 'sqlite://'}) config.include('ptah') config.commit() config.ptah_init_sql() self.assertIsNotNone(ptah.get_base().metadata.bind)
class TestSqlaModuleBase(ptah.get_base()): __tablename__ = 'ptah_nodes' __table_args__ = {'extend_existing': True} __mapper_args__ = {'polymorphic_identity': 'node'} id = sqla.Column(sqla.Integer(), primary_key=True) name = sqla.Column(sqla.Unicode(), default=text_type('123'))
def upgrade(pkg, sql=False): """Upgrade to a later version.""" from alembic.config import Config from alembic.environment import EnvironmentContext if ':' in pkg: pkg, rev = pkg.split(':', 1) else: rev = 'head' script = ScriptDirectory(pkg) env = EnvironmentContext(Config(''), script) conn = ptah.get_base().metadata.bind.connect() def upgrade(revision, context): return script._upgrade_revs(rev, revision) env.configure( connection=conn, fn=upgrade, as_sql=sql, starting_rev=None, destination_rev=rev, ) mc = env._migration_context env._migration_context = MigrationContext(pkg, conn.dialect, conn, mc.opts) with env: try: with env.begin_transaction(): env.run_migrations() finally: conn.close()
def upgrade(pkg, sql=False): """Upgrade to a later version.""" from alembic.config import Config from alembic.environment import EnvironmentContext if ':' in pkg: pkg, rev = pkg.split(':',1) else: rev = 'head' script = ScriptDirectory(pkg) env = EnvironmentContext(Config(''), script) conn = ptah.get_base().metadata.bind.connect() def upgrade(revision, context): return script._upgrade_revs(rev, revision) env.configure( connection = conn, fn = upgrade, as_sql = sql, starting_rev = None, destination_rev = rev, ) mc = env._migration_context env._migration_context = MigrationContext(pkg, conn.dialect, conn, mc.opts) with env: try: with env.begin_transaction(): env.run_migrations() finally: conn.close()
class MyContentSql(ptah.get_base()): __tablename__ = 'tinfo_sql_test22' id = sqla.Column(sqla.Integer, primary_key=True) test = sqla.Column(sqla.Unicode) test1 = sqla.Column(sqla.Unicode)
class CrowdGroup(ptah.get_base()): """Crowd group ``title``: Group title. ``description``: Group description. ``users``: Users list. """ __tablename__ = 'ptahcrowd_groups' id = sqla.Column(sqla.Integer, primary_key=True) title = sqla.Column(sqla.Unicode(255)) description = sqla.Column(sqla.UnicodeText, default=text_type(''), info = {'missing': '', 'field_type': 'textarea', 'default': '', 'required': False}) _sql_get_id = ptah.QueryFreezer( lambda: ptah.get_session().query(CrowdGroup)\ .filter(CrowdGroup.id==sqla.sql.bindparam('id'))) @classmethod def get_byid(cls, id): return cls._sql_get_id.first(id=id) def __str__(self): return self.title
def main(global_config, **settings): """ This is your application startup.""" config = Configurator(settings=settings, session_factory=session_factory, authentication_policy=auth_policy) # config.commit() # config.begin() # init ptah settings config.ptah_init_settings() # init sqlalchemy engine config.ptah_init_sql() # configure ptah manage config.ptah_init_manage( managers=['*'], disable_modules=['rest', 'introspect', 'apps', 'permissions']) # we love them routes config.add_route('root', '/') config.add_route('contact-us', '/contact-us.html') config.add_route('edit-objects', '/objects/{id}/edit', factory=models.rackobject.factory, use_global_views=True) config.add_route('add-object', '/objects/add.html') config.add_route('login', '/login.html') config.add_route('logout', '/logout.html') # static assets config.add_static_view('rackptahbles', 'rackptahbles:static') config.scan() # create sql tables Base = ptah.get_base() Base.metadata.create_all() transaction.commit() # populate database config.commit() config.begin() Session = ptah.get_session() # admin user user = Session.query(User).first() if user is None: user = User('Admin', 'admin', '*****@*****.**', '12345') Session.add(user) #bootstrap data here, removed rackptahbles link population # Need to commit bootstrap data to database manually. transaction.commit() return config.make_wsgi_app()
def test_ptahinit_sqla(self): config = Configurator( settings = {'sqlalchemy.url': 'sqlite://'}) config.include('ptah') config.commit() config.ptah_init_sql() self.assertIsNotNone(ptah.get_base().metadata.bind)
class Gallery(ptah.get_base()): __tablename__ = 'gallery' id = sqla.Column(sqla.Integer, primary_key=True) user = sqla.Column(sqla.Integer, sqla.ForeignKey('users.id')) name = sqla.Column(sqla.Unicode(255)) description = sqla.Column(sqla.UnicodeText())
class Storage(ptah.get_base()): __tablename__ = 'ptahcrowd_auth_storage' access_token = sqla.Column(sqla.String(255), primary_key=True) domain = sqla.Column(sqla.String(255), default='') uri = sqla.Column(sqla.String(255), index=True) uid = sqla.Column(sqla.String(128), default='', unique=True) name = sqla.Column(sqla.String(255), default='') email = sqla.Column(sqla.String(128), default='') verified = sqla.Column(sqla.Boolean(), default=False) profile = sqla.Column(ptah.JsonDictType()) expires = sqla.Column(sqla.DateTime()) @classmethod def get_by_token(cls, access_token): return ptah.get_session().query(cls).filter( sqla.and_(cls.access_token == access_token)).first() @classmethod def create(cls, access_token, domain, uid='', name='', email='', verified=False, profile=None, expires=None): params = {'access_token': access_token, 'domain': domain, 'uid': uid, 'name': name, 'email': email.lower(), 'verified': verified, 'profile': profile} session = ptah.get_session() # reuse old authorization q = session.query(cls).filter(cls.uid == uid) old = q.first() if old is not None: params['uri'] = old.uri q.delete() entry = cls(**params) session.add(entry) return entry @classmethod def delete(cls, key): ptah.get_session().query(cls).filter(cls.key == key).delete() return True @classmethod def purge_expired(cls): ptah.get_session().query(cls)\ .filter(cls.expires < datetime.utcnow()).delete() return True
def main(global_config, **settings): """ This is your application startup.""" config = Configurator(settings=settings, session_factory = session_factory, authentication_policy = auth_policy) # config.commit() # config.begin() # init ptah settings config.ptah_init_settings() # init sqlalchemy engine config.ptah_init_sql() # configure ptah manage config.ptah_init_manage( managers = ['*'], disable_modules = ['rest', 'introspect', 'apps', 'permissions']) # we love them routes config.add_route('root', '/') config.add_route('contact-us', '/contact-us.html') config.add_route('edit-objects', '/objects/{id}/edit', factory=models.rackobject.factory, use_global_views=True) config.add_route('add-object', '/objects/add.html') config.add_route('login', '/login.html') config.add_route('logout', '/logout.html') # static assets config.add_static_view('rackptahbles', 'rackptahbles:static') config.scan() # create sql tables Base = ptah.get_base() Base.metadata.create_all() transaction.commit() # populate database config.commit() config.begin() Session = ptah.get_session() # admin user user = Session.query(User).first() if user is None: user = User('Admin', 'admin', '*****@*****.**', '12345') Session.add(user) #bootstrap data here, removed rackptahbles link population # Need to commit bootstrap data to database manually. transaction.commit() return config.make_wsgi_app()
class Test(ptah.get_base()): __tablename__ = 'test' id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column(sqla.Unicode()) count = sqla.Column(sqla.Integer()) score = sqla.Column(sqla.Float()) date = sqla.Column(sqla.Date()) datetime = sqla.Column(sqla.DateTime()) boolean = sqla.Column(sqla.Boolean())
class Link(ptah.get_base()): """ A basic model. """ __tablename__ = 'links' # Required primary field __id__ = sqla.Column('id', sqla.Integer, primary_key=True) # Your custom fields title = sqla.Column(sqla.Unicode) href = sqla.Column(sqla.Unicode) color = sqla.Column(sqla.Unicode)
class Test2(ptah.get_base()): __tablename__ = 'test2' id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column(sqla.Unicode(), info={ 'title': 'Test title', 'missing': 'missing value', 'description': 'Description', 'field_type': 'textarea', 'vocabulary': ['1', '2'] })
def test_jsondict(self): import ptah ptah.reset_session() self.config.ptah_init_sql() class Test(ptah.get_base()): __tablename__ = 'test14' id = sqla.Column('id', sqla.Integer, primary_key=True) data = sqla.Column(ptah.JsonDictType()) Session = ptah.get_session() ptah.get_base().metadata.create_all() transaction.commit() rec = Test() rec.data = {'test': 'val'} Session.add(rec) Session.flush() id = rec.id transaction.commit() rec = Session.query(Test).filter_by(id = id).one() self.assertEqual(rec.data, {'test': 'val'}) rec.data['test2'] = 'val2' transaction.commit() rec = Session.query(Test).filter_by(id = id).one() self.assertEqual(rec.data, {'test': 'val', 'test2': 'val2'}) del rec.data['test'] transaction.commit() rec = Session.query(Test).filter_by(id = id).one() self.assertEqual(rec.data, {'test2': 'val2'})
class User(ptah.get_base()): """Default user ``name``: User name. ``email``: User email. ``properties``: User properties. """ __tablename__ = 'users' id = sqla.Column(sqla.Integer, primary_key=True) token = sqla.Column(sqla.String(255), index=True) source = sqla.Column(sqla.String(18)) name = sqla.Column(sqla.Unicode(255)) email = sqla.Column(sqla.Unicode(255), unique=True) joined = sqla.Column(sqla.DateTime()) properties = sqla.Column(ptah.JsonDictType(), default={}) def __init__(self, **kw): self.joined = datetime.utcnow() self.properties = {} super(User, self).__init__(**kw) def __str__(self): return self.name def __name__(self): return str(self.id) def __repr__(self): return '%s<%s:%s>' % (self.__class__.__name__, self.name, self.__uri__) _sql_get_id = ptah.QueryFreezer( lambda: ptah.get_session().query(User)\ .filter(User.id==sqla.sql.bindparam('id'))) @classmethod def get_byid(cls, id): return cls._sql_get_id.first(id=id) _sql_get_token = ptah.QueryFreezer( lambda: ptah.get_session().query(User)\ .filter(User.token==sqla.sql.bindparam('token'))) @classmethod def get_bytoken(cls, token): return cls._sql_get_token.first(token=token)
def test_jsondict(self): import ptah self.config.ptah_init_sql() class Test(ptah.get_base()): __tablename__ = "test14" id = sqla.Column("id", sqla.Integer, primary_key=True) data = sqla.Column(ptah.JsonDictType()) Session = ptah.get_session() ptah.get_base().metadata.create_all() transaction.commit() rec = Test() rec.data = {"test": "val"} Session.add(rec) Session.flush() id = rec.id transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, {"test": "val"}) rec.data["test2"] = "val2" transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, {"test": "val", "test2": "val2"}) del rec.data["test"] transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, {"test2": "val2"})
def test_jsondict(self): import ptah self.config.ptah_init_sql() class Test(ptah.get_base()): __tablename__ = 'test14' id = sqla.Column('id', sqla.Integer, primary_key=True) data = sqla.Column(ptah.JsonDictType()) Session = ptah.get_session() ptah.get_base().metadata.create_all() transaction.commit() rec = Test() rec.data = {'test': 'val'} Session.add(rec) Session.flush() id = rec.id transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, {'test': 'val'}) rec.data['test2'] = 'val2' transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, {'test': 'val', 'test2': 'val2'}) del rec.data['test'] transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, {'test2': 'val2'})
def init_ptah(self, *args, **kw): self.registry.settings.update(self._settings) self.config.include("ptah") for pkg in self._includes: # pragma: no cover self.config.include(pkg) pkg = package_name(sys.modules[self.__class__.__module__]) if pkg != "ptah": parts = self.__class__.__module__.split(".") for l in range(len(parts)): pkg = ".".join(parts[: l + 1]) if pkg == "ptah" or pkg.startswith("ptah.") or pkg in self._includes: continue # pragma: no cover try: self.config.include(pkg) except: # pragma: no cover pass self.config.scan(self.__class__.__module__) self.config.commit() self.config.ptah_init_settings() if self._init_static: self.config.add_bower_components("ptah:static/bower_components") if self._init_sqla: # create engine self.config.ptah_init_sql() # create sql tables Base = ptah.get_base() Base.metadata.create_all() transaction.commit() if self._init_mail: self.config.init_mailer(ptah.mail.DummyMailer()) if self._trusted_manage: def trusted(*args): return True ptah.manage.set_access_manager(trusted)
class Token(ptah.get_base()): __tablename__ = 'ptah_tokens' id = sqla.Column(sqla.Integer, primary_key=True) token = sqla.Column(sqla.Unicode(48)) valid = sqla.Column(sqla.DateTime) data = sqla.Column(sqla.Text) typ = sqla.Column('type', sqla.Unicode(48)) def __init__(self, typ, data): super(Token, self).__init__() self.typ = typ.id self.data = data self.valid = datetime.datetime.now() + typ.timeout self.token = uuid.uuid4().hex
def register_sqla_type(config, cls, tinfo, name, **kw): base = ptah.get_base() if not issubclass(cls, base): return # generate schema fieldset = tinfo.fieldset if fieldset is None: fieldset = ptah.generate_fieldset( cls, fieldNames=kw.get('fieldNames'), namesFilter=kw.get('namesFilter')) log.info("Generating fieldset for %s content type.", cls) if fieldset is not None: tinfo.fieldset = fieldset if tinfo.add_method is None: tinfo.add_method = sqla_add_method # install __uri__ property if not hasattr(cls, '__uri__') or hasattr(cls, '__uri_reinstall__'): pname = None for cl in cls.__table__.columns: if cl.primary_key: pname = cl.name break l = len(tinfo.name)+1 cls.__uri_reinstall__ = True cls.__uri__ = UriProperty(tinfo.name, cl.name) cls.__uri_sql_get__ = ptah.QueryFreezer( lambda: ptah.get_session().query(cls) \ .filter(getattr(cls, pname) == sqla.sql.bindparam('uri'))) def resolver(uri): """Content resolver for %s type'"""%tinfo.name return cls.__uri_sql_get__.first(uri=uri[l:]) storage = config.get_cfg_storage(ID_RESOLVER) if tinfo.name in storage: raise ConfigurationError( 'Resolver for "%s" already registered'%tinfo.name) storage[tinfo.name] = resolver
def register_sqla_type(config, cls, tinfo, name, **kw): base = ptah.get_base() if not issubclass(cls, base): return # generate schema fieldset = tinfo.fieldset if fieldset is None: fieldset = ptah.generate_fieldset(cls, fieldNames=kw.get('fieldNames'), namesFilter=kw.get('namesFilter')) log.info("Generating fieldset for %s content type.", cls) if fieldset is not None: tinfo.fieldset = fieldset if tinfo.add_method is None: tinfo.add_method = sqla_add_method # install __uri__ property if not hasattr(cls, '__uri__') or hasattr(cls, '__uri_reinstall__'): pname = None for cl in cls.__table__.columns: if cl.primary_key: pname = cl.name break l = len(tinfo.name) + 1 cls.__uri_reinstall__ = True cls.__uri__ = UriProperty(tinfo.name, cl.name) cls.__uri_sql_get__ = ptah.QueryFreezer( lambda: ptah.get_session().query(cls) \ .filter(getattr(cls, pname) == sqla.sql.bindparam('uri'))) def resolver(uri): """Content resolver for %s type'""" % tinfo.name return cls.__uri_sql_get__.first(uri=uri[l:]) storage = config.get_cfg_storage(ID_RESOLVER) if tinfo.name in storage: raise ConfigurationError('Resolver for "%s" already registered' % tinfo.name) storage[tinfo.name] = resolver
def setUp(self): global TestSqlaModuleContent Base = ptah.get_base() ptah.get_session() @ptah.tinfo('Test') class TestSqlaModuleContent(TestSqlaModuleBase): __tablename__ = 'test_sqla_content' __table_args__ = {'extend_existing': True} __mapper_args__ = {'polymorphic_identity': 'content'} id = sqla.Column( sqla.Integer(), sqla.ForeignKey('ptah_nodes.id'), primary_key=True) title = sqla.Column(sqla.Unicode()) super(TestSqlaModule, self).setUp()
def init_ptah(self, *args, **kw): self.registry.settings.update(self._settings) self.config.include('ptah') for pkg in self._includes: # pragma: no cover self.config.include(pkg) pkg = package_name(sys.modules[self.__class__.__module__]) if pkg != 'ptah': parts = self.__class__.__module__.split('.') for l in range(len(parts)): pkg = '.'.join(parts[:l + 1]) if pkg == 'ptah' or pkg.startswith('ptah.') or \ pkg in self._includes: continue # pragma: no cover try: self.config.include(pkg) except: # pragma: no cover pass self.config.scan(self.__class__.__module__) self.config.commit() self.config.ptah_init_settings() if self._init_static: self.config.add_bower_components('ptah:static/bower_components') if self._init_sqla: # create engine self.config.ptah_init_sql() # create sql tables Base = ptah.get_base() Base.metadata.create_all() transaction.commit() if self._trusted_manage: def trusted(*args): return True ptah.manage.set_access_manager(trusted)
def init_ptah(self, *args, **kw): self.registry.settings.update(self._settings) self.config.include('ptah') for pkg in self._includes: # pragma: no cover self.config.include(pkg) pkg = package_name(sys.modules[self.__class__.__module__]) if pkg != 'ptah': packages = [] parts = self.__class__.__module__.split('.') for l in range(len(parts)): pkg = '.'.join(parts[:l+1]) if pkg == 'ptah' or pkg.startswith('ptah.') or \ pkg in self._includes: continue # pragma: no cover try: self.config.include(pkg) except: # pragma: no cover pass self.config.scan(self.__class__.__module__) self.config.commit() self.config.autocommit = self._auto_commit self.config.ptah_init_settings() ptah.reset_session() if self._init_sqla: # create engine self.config.ptah_init_sql() # create sql tables Base = ptah.get_base() Base.metadata.create_all() transaction.commit() if self._trusted_manage: def trusted(*args): return True ptah.manage.set_access_manager(trusted)
def test_jsonlist(self): import ptah Base = ptah.get_base() class Test(Base): __tablename__ = 'test15' id = sqla.Column('id', sqla.Integer, primary_key=True) data = sqla.Column(ptah.JsonListType()) Session = ptah.get_session() Base.metadata.create_all() transaction.commit() rec = Test() rec.data = ['test'] Session.add(rec) Session.flush() id = rec.id transaction.commit() rec = Session.query(Test).filter_by(id = id).one() self.assertEqual(rec.data, ['test']) rec.data[0] = 'test2' transaction.commit() rec = Session.query(Test).filter_by(id = id).one() self.assertEqual(rec.data, ['test2']) rec.data.append('test') transaction.commit() rec = Session.query(Test).filter_by(id = id).one() self.assertEqual(rec.data, ['test2', 'test']) del rec.data[rec.data.index('test2')] transaction.commit() rec = Session.query(Test).filter_by(id = id).one() self.assertEqual(rec.data, ['test'])
def test_jsonlist(self): import ptah Base = ptah.get_base() class Test(Base): __tablename__ = 'test15' id = sqla.Column('id', sqla.Integer, primary_key=True) data = sqla.Column(ptah.JsonListType()) Session = ptah.get_session() Base.metadata.create_all() transaction.commit() rec = Test() rec.data = ['test'] Session.add(rec) Session.flush() id = rec.id transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, ['test']) rec.data[0] = 'test2' transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, ['test2']) rec.data.append('test') transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, ['test2', 'test']) del rec.data[rec.data.index('test2')] transaction.commit() rec = Session.query(Test).filter_by(id=id).one() self.assertEqual(rec.data, ['test'])
class Photo(ptah.get_base()): __tablename__ = 'photos' id = sqla.Column(sqla.Integer, primary_key=True) gallery = sqla.Column(sqla.Integer, sqla.ForeignKey('gallery.id')) name = sqla.Column(sqla.Unicode(255)) description = sqla.Column(sqla.UnicodeText()) filename = sqla.Column(sqla.Unicode(255)) mimetype = sqla.Column(sqla.String(20)) created = sqla.Column(sqla.DateTime()) modified = sqla.Column(sqla.DateTime()) size = sqla.Column(sqla.Integer()) data = sqla.orm.deferred(sqla.Column(sqla.LargeBinary)) def __init__(self, **kw): self.created = datetime.utcnow() self.modified = datetime.utcnow() super(Photo, self).__init__(**kw)
def initialize_sql(cfg, prefix='sqlalchemy.'): def action(cfg, cache): PTAH = cfg.ptah_get_settings(ptah.CFG_ID_PTAH) PTAH['sqlalchemy_cache'] = {} PTAH['sqlalchemy_initialized'] = True cache = {} engine = sqlalchemy.engine_from_config( cfg.registry.settings, prefix, execution_options = {'compiled_cache': cache, 'echo': True}) ptah.get_session().configure(bind=engine) ptah.get_session_maker().configure(bind=engine) ptah.get_base().metadata.bind = engine cfg.action('ptah.initalize_sql', action, (cfg, cache)) # check_version from ptah import migrate cfg.add_subscriber(migrate.check_version, ApplicationCreated)
def create_db_schema(registry, update=True): registry.notify(ptah.events.BeforeCreateDbSchema(registry)) skip_tables = ptah.get_settings(ptah.CFG_ID_PTAH)['db_skip_tables'] Base = ptah.get_base() log = logging.getLogger('ptah') tables = [] for name, table in Base.metadata.tables.items(): if name not in skip_tables and not table.exists(): log.info("Creating db table `%s`.", name) tables.append(table) if tables: Base.metadata.create_all(tables=tables) transaction.commit() # update db versions if update: update_versions(registry)
def current(pkg): """Display the current revision.""" def display_version(rev, context): rev = script._get_rev(rev) if rev is None: print("Package '{0}' rev: None".format(pkg)) else: print("Package '{0}' rev: {1}{2} {3}".format( pkg, rev.revision, '(head)' if rev.is_head else "", rev.doc)) return [] conn = ptah.get_base().metadata.bind.connect() script = ptah.migrate.ScriptDirectory(pkg) env = EnvironmentContext(Config(''), script) env.configure(connection=conn, fn=display_version) mc = env._migration_context env._migration_context = MigrationContext(pkg, conn.dialect, conn, mc.opts) with env.begin_transaction(): env.run_migrations()
def current(pkg): """Display the current revision.""" def display_version(rev, context): rev = script._get_rev(rev) if rev is None: print("Package '{0}' rev: None".format(pkg)) else: print("Package '{0}' rev: {1}{2} {3}".format(pkg, rev.revision, "(head)" if rev.is_head else "", rev.doc)) return [] conn = ptah.get_base().metadata.bind.connect() script = ptah.migrate.ScriptDirectory(pkg) env = EnvironmentContext(Config(""), script) env.configure(connection=conn, fn=display_version) mc = env._migration_context env._migration_context = MigrationContext(pkg, conn.dialect, conn, mc.opts) with env.begin_transaction(): env.run_migrations()
def setUp(self): global TestSqlaModuleContent Base = ptah.get_base() ptah.get_session() table = Base.metadata.tables['test_sqla_table'] if not table.exists(): Base.metadata.create_all(tables=(table,)) @ptah.tinfo('Test') class TestSqlaModuleContent(TestSqlaModuleBase): __tablename__ = 'test_sqla_content' __table_args__ = {'extend_existing': True} __mapper_args__ = {'polymorphic_identity': 'nodes'} id = sqla.Column( sqla.Integer(), sqla.ForeignKey('ptah_nodes.id'), primary_key=True) name = sqla.Column(sqla.Unicode()) title = sqla.Column(sqla.Unicode()) super(TestSqlaModule, self).setUp()
def test_skip_tables(self): from ptah.populate import create_db_schema base = ptah.get_base() class test_populate_TestTable(base): __tablename__ = 'test_populate_TestTable' id = sqla.Column('id', sqla.Integer, primary_key=True) cfg = ptah.get_settings(ptah.CFG_ID_PTAH) cfg['db_skip_tables'] = ('test_populate_TestTable',) create_db_schema(self.registry) self.assertFalse( base.metadata.tables['test_populate_TestTable'].exists()) cfg['db_skip_tables'] = () create_db_schema(self.registry) self.assertTrue( base.metadata.tables['test_populate_TestTable'].exists())
def test_skip_tables(self): from ptah.populate import create_db_schema base = ptah.get_base() class test_populate_TestTable(base): __tablename__ = 'test_populate_TestTable' id = sqla.Column('id', sqla.Integer, primary_key=True) cfg = ptah.get_settings(ptah.CFG_ID_PTAH) cfg['db_skip_tables'] = ('test_populate_TestTable', ) create_db_schema(self.registry) self.assertFalse( base.metadata.tables['test_populate_TestTable'].exists()) cfg['db_skip_tables'] = () create_db_schema(self.registry) self.assertTrue( base.metadata.tables['test_populate_TestTable'].exists())
# render form myform.update() return {'view': myform} if __name__ == '__main__': """ ... """ from pyramid.config import Configurator from pyramid.scripts.pserve import wsgiref_server_runner from pyramid.session import UnencryptedCookieSessionFactoryConfig config = Configurator( settings={'sqlalchemy.url': 'sqlite://'}, session_factory=UnencryptedCookieSessionFactoryConfig('secret')) config.include('ptah') config.scan(__name__) config.ptah_init_sql() # create sql tables Base = ptah.get_base() Base.metadata.create_all() config.commit() app = config.make_wsgi_app() wsgiref_server_runner(app, {})
def main(global_config, **settings): """ themes app """ APP_FACTORY = ptah.cms.ApplicationFactory( ThemeGallery, '/', policy=ThemeGalleryPolicy, name='themes', title='Ploud theme gallery') config = Configurator(root_factory=APP_FACTORY, settings=settings) config.include('ploud.themegallery') # init sqlalchemy engine config.ptah_init_sql() # init ptah settings config.ptah_init_settings() # enable rest api config.ptah_init_rest() # enable ptah manage config.ptah_init_manage(manager_role=Manager.id) # standalone layouts config.ptah_layout( 'page', context=ThemeGallery, view=WorkspaceLayout, renderer='ploud.themegallery:templates/layout-page.pt') config.ptah_layout( 'ptah-page', ThemeGallery, parent='page', renderer="ploud.themegallery:templates/layout-ptahpage.pt") # populate database config.commit() config.begin() # create sql tables Base = ptah.get_base() Base.metadata.create_all() # your application configuration ptah.auth_service.set_userid(ptah.SUPERUSER_URI) root = APP_FACTORY() # admin user from ptah_crowd import CrowdUser, CrowdFactory Session = ptah.get_session() user = Session.query(CrowdUser).first() if user is None: user = CrowdUser(title='Admin', login='******', email='*****@*****.**', password='******') CrowdFactory().add(user) # give manager role to admin if user.__uri__ not in root.__local_roles__: root.__local_roles__[user.__uri__] = [Manager.id] # We are not in a web request; we need to manually commit. transaction.commit() return config.make_wsgi_app()
except: raise KeyError(key) md = self.metadata[id][0] return Table(md.tables[table], self, self.request) def available(self): PTAH = ptah.get_settings(ptah.CFG_ID_PTAH, self.request.registry) return PTAH.get('sqlalchemy_initialized', False) @classmethod def addMetadata(cls, md, id, title=''): cls.metadata[id] = [md, title or id.capitalize()] addMetadata = SQLAModule.addMetadata addMetadata(ptah.get_base().metadata, 'psqla', 'Pyramid sqla') class Table(object): def __init__(self, table, mod, request): self.__name__ = 'psqla-%s' % table.name self.__parent__ = mod self.table = table self.request = request self.title = table.name def __getitem__(self, key): if key == 'add.html':