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_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 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':
