def run_from_argv(self, argv): """ Set up any environment changes requested (e.g., Python path and Django settings), then run this command. If the command raises a ``CommandError``, intercept it and print it sensibly to stderr. """ parser = self.create_parser(argv[0], argv[1]) options, args = parser.parse_args(argv[2:]) handle_default_options(options) try: self.execute(*args, **options.__dict__) except Exception as e: raise # self.stderr is not guaranteed to be set here stderr = getattr(self, 'stderr', OutputWrapper(sys.stderr, self.style.ERROR)) if options.traceback: stderr.write(traceback.format_exc()) else: stderr.write('%s: %s' % (e.__class__.__name__, e)) sys.exit(1) finally: orm = ORM.get() try: session = orm.sessionmaker() session.rollback() session.close() except: pass
def register(self, request, oauth_token, oauth_verifier, given_name, family_name, email): if hasattr(request, 'orm'): session = request.orm.sessionmaker() else: from baph.db.orm import ORM session = ORM.get().sessionmaker() request_token = request.session.pop(SESSION_KEY, None) if request_token and request_token.key == oauth_token: twitter = Twitter(request_token) access_token = twitter.get_access_token(oauth_verifier) if not access_token: return False profile = session.query(TwitterProfile) \ .filter_by(key=access_token.key, secret=access_token.secret) \ .first() if profile: user_obj = profile.user else: # Check that the username is unique, and if so, create a user # and profile twitter_user = twitter.user username = '******' % twitter_user.id user_ct = session.query(User) \ .filter_by(username=username) \ .count() if user_ct == 0: user_obj = User.create_user(username=username, email=email, password=None, session=session) user_obj.first_name = given_name user_obj.last_name = family_name profile = TwitterProfile(user=user_obj, uid=twitter_user.id, username=twitter.username, access_token=access_token) session.add(profile) session.commit() else: # Should we redirect here, or return False and redirect in # post_registration_redirect? return False signals.user_registered.send(sender=self.__class__, user=user_obj, request=request) user = authenticate(oauth_token=access_token.key, uid=twitter_user.id, session=session) login(request, user) elif request.user.is_authenticated(): user_obj = request.user else: # Perhaps we should handle this differently? user_obj = AnonymousUser() return user_obj
def test_readonly_orm_creation(self): orm = ORM.get() session = orm.sessionmaker() result = session.execute('SELECT 1').fetchone() self.assertEqual(result, (1,)) session = orm.sessionmaker(readonly=True) result = session.execute('SELECT 1').fetchone() self.assertEqual(result, (1,))
def test_readonly_orm_creation(self): orm = ORM.get() session = orm.sessionmaker() result = session.execute('SELECT 1').fetchone() self.assertEqual(result, (1, )) session = orm.sessionmaker(readonly=True) result = session.execute('SELECT 1').fetchone() self.assertEqual(result, (1, ))
def register(self, request, **kwargs): if hasattr(request, 'orm'): session = request.orm.sessionmaker() else: from baph.db.orm import ORM session = ORM.get().sessionmaker() params = get_user_from_cookie(request.COOKIES, settings.FACEBOOK_APP_ID, settings.FACEBOOK_SECRET_KEY) if params and 'uid' in params: uid = params['uid'] profile = session.query(FacebookProfile) \ .filter_by(uid=uid) \ .first() if profile: user_obj = profile.user else: # Check that the username is unique, and if so, create a user # and profile username = '******' % uid user_ct = session.query(User) \ .filter_by(username=username) \ .count() if user_ct == 0: fb = Facebook(params['access_token']) fb_user = fb.user user_obj = User.create_user(username=username, email=fb_user['email'], password=None, session=session) user_obj.first_name = fb_user['first_name'] user_obj.last_name = fb_user['last_name'] profile = FacebookProfile( user=user_obj, uid=uid, access_token=params['access_token'], expires_in=params['expires'], ) session.add(profile) session.commit() else: # Should we redirect here, or return False and redirect in # post_registration_redirect? return False signals.user_registered.send(sender=self.__class__, user=user_obj, request=request) user = authenticate(uid=uid, session=session) login(request, user) elif request.user.is_authenticated(): user_obj = request.user else: # Perhaps we should handle this differently? user_obj = AnonymousUser() return user_obj
def test_readonly_session_rollback(self): orm = ORM.get() session = orm.sessionmaker(readonly=True) sql = 'SELECT col FROM nonexistent_baph_table' try: result = session.execute(sql).fetchone() except SQLAlchemyError: orm.sessionmaker_rollback() result = session.execute('SELECT 1').fetchone() self.assertEqual(result, (1, ))
def test_readonly_session_rollback(self): orm = ORM.get() session = orm.sessionmaker(readonly=True) sql = 'SELECT col FROM nonexistent_baph_table' try: result = session.execute(sql).fetchone() except SQLAlchemyError: orm.sessionmaker_rollback() result = session.execute('SELECT 1').fetchone() self.assertEqual(result, (1,))
def setUpClass(cls): super(RegistrationModelTests, cls).setUpClass() Site.__table__.create() User.__table__.create() orm = ORM.get() cls.session = orm.sessionmaker() cls.user_info['session'] = cls.session site = Site(id=settings.SITE_ID, domain='example.com', name=u'example.com') cls.session.add(site) cls.session.commit()
def key_to_value(obj, key, raw=False): """ Evaluate chained relations against a target object """ from baph.db.orm import ORM frags = key.split('.') if not raw: col_key = frags.pop() current_obj = obj while frags: if not current_obj: # we weren't able to follow the chain back, one of the # fks was probably optional, and had no value return None attr_name = frags.pop(0) previous_obj = current_obj previous_cls = type(previous_obj) current_obj = getattr(previous_obj, attr_name) if current_obj: # proceed to next step of the chain continue # relation was empty, we'll grab the fk and lookup the # object manually attr = getattr(previous_cls, attr_name) prop = attr.property related_cls = class_resolver(prop.argument) related_col = prop.local_remote_pairs[0][0] attr_ = column_to_attr(previous_cls, related_col) related_key = attr_.key related_val = getattr(previous_obj, related_key) if related_val is None: # relation and key are both empty: no parent found return None orm = ORM.get() session = orm.sessionmaker() current_obj = session.query(related_cls).get(related_val) if raw: return current_obj value = getattr(current_obj, col_key, None) if value: return str(value).strip() return None
def setUpClass(cls): ORM._database = None cls.orm = ORM.get() cls.session = cls.orm.sessionmaker() cls.session.execute('''\ CREATE TABLE test_baph_mapify ( id INTEGER PRIMARY KEY, string VARCHAR(16), number_with_decimal_point REAL(10) );''') cls.session.execute('''\ CREATE TABLE test_baph_mapify_join ( foreign_key INTEGER PRIMARY KEY REFERENCES test_baph_mapify(id), other_string VARCHAR(16) );''')
def facebook_login(request): if hasattr(request, 'orm'): session = request.orm.sessionmaker() else: from baph.db.orm import ORM session = ORM.get().sessionmaker() params = get_user_from_cookie(request.COOKIES, settings.FACEBOOK_APP_ID, settings.FACEBOOK_SECRET_KEY) if params: user = authenticate(uid=params['uid'], session=session) if user is not None: if user.is_active: login(request, user) return redirect(settings.LOGIN_REDIRECT_URL, {}, ()) else: # Disabled account, redirect and notify? return redirect('/', {}, ()) else: # Invalid user, redirect and notify? return redirect('/', {}, ()) elif request.user.is_authenticated(): return redirect(settings.LOGIN_REDIRECT_URL, {}, ()) else: return redirect('/account/register/', {}, ())
def handle_noargs(self, **options): verbosity = int(options.get('verbosity')) interactive = options.get('interactive') show_traceback = options.get('traceback') load_initial_data = options.get('load_initial_data') self.style = no_style() # Import the 'management' module within each installed app, to register # dispatcher events. for app_name in settings.INSTALLED_APPS: try: import_module('.management', app_name) except ImportError as exc: # This is slightly hackish. We want to ignore ImportErrors # if the "management" module itself is missing -- but we don't # want to ignore the exception if the management module exists # but raises an ImportError for some reason. The only way we # can do this is to check the text of the exception. Note that # we're a bit broad in how we check the text, because different # Python implementations may not use the same text. # CPython uses the text "No module named management" # PyPy uses "No module named myproject.myapp.management" msg = exc.args[0] if not msg.startswith( 'No module named') or 'management' not in msg: raise db = options.get('database') orm = ORM.get(db) engine = orm.engine default_schema = engine.url.database # the default db may not exist yet, so we remove it before connecting engine.url.database = None frags = str(engine.url).split('?') tmp_url = frags[0] if len(frags) == 2: if not tmp_url.endswith('/'): # query strings will break this if it doesn't end with a / tmp_url += '/' tmp_url += '?%s' % frags[1] engine.url.database = default_schema tmp_engine = create_engine(tmp_url) tmp_conn = tmp_engine.connect() existing_schemas = set( [s[0] for s in tmp_conn.execute('show databases')]) if not default_schema in existing_schemas: tmp_engine.execute(CreateSchema(default_schema)) existing_schemas.add(default_schema) orm = ORM.get(db) # now reconnect with the default_db provided conn = engine.connect() Base.metadata.bind = engine if verbosity >= 3: self.stdout.write("Getting existing schemas...\n") for schema in existing_schemas: self.stdout.write("\t%s\n" % schema) else: self.stdout.write("\tNone\n") existing_tables = [] if verbosity >= 1: self.stdout.write("Getting existing tables...\n") for schema in existing_schemas: for name in engine.engine.table_names(schema, connection=conn): existing_tables.append('%s.%s' % (schema, name)) if verbosity >= 3: self.stdout.write("\t%s.%s\n" % (schema, name)) existing_models = [] if verbosity >= 1: self.stdout.write("Getting existing models...\n") for cls_name, cls in Base._decl_class_registry.items(): tablename = get_tablename(cls) if tablename and tablename in existing_tables: existing_models.append(cls) if verbosity >= 3: self.stdout.write("\t%s\n" % cls) all_tables = [] if verbosity >= 1: self.stdout.write("Getting required tables...\n") for table in Base.metadata.sorted_tables: tablename = get_tablename(table) all_tables.append(tablename) if verbosity >= 3: self.stdout.write("\t%s\n" % tablename) all_models = [] if verbosity >= 1: self.stdout.write("Getting required models...\n") for app in get_apps(): for model in get_models(app, include_auto_created=True): app_name = app.__name__.rsplit('.', 1)[0] all_models.append((app_name, model)) if verbosity >= 3: self.stdout.write("\t%s.%s\n" % (app_name, model)) schema_manifest = set() table_manifest = set() if verbosity >= 1: self.stdout.write('Building manifest...\n') for app_name, model in all_models: tablename = get_tablename(model) if tablename in existing_tables: continue table_manifest.add((app_name, model)) schema = tablename.rsplit('.', 1)[0] if schema not in existing_schemas: schema_manifest.add(schema) table_manifest = sorted( table_manifest, key=lambda x: all_tables.index(get_tablename(x[1]))) if verbosity >= 3: print 'Schema Manifest:\n' for schema in schema_manifest: print '\t%s\n' % schema print 'Model/Table Manifest\n' for app_name, model in table_manifest: print '\t%s.%s (%s)\n' % (app_name, model._meta.object_name, get_tablename(model)) # create any missing schemas if verbosity >= 1: self.stdout.write("Creating schemas ...\n") for schema in schema_manifest: if verbosity >= 3: self.stdout.write("\t%s\n" % schema) engine.execute(CreateSchema(schema)) existing_schemas.add(schema) # create any missing tables created_models = set() to_create = [] if verbosity >= 1: self.stdout.write("Creating tables ...\n") for app_name, model in table_manifest: if verbosity >= 3: self.stdout.write("\tCreating table for model %s.%s\n" % (app_name, model._meta.object_name)) tablename = get_tablename(model) if tablename not in existing_tables: table = model.__table__ to_create.append(table) existing_tables.append(tablename) existing_models.append(model) created_models.add(model) orm.Base.metadata.create_all(bind=engine, tables=to_create) # Send the post_syncdb signal emit_post_sync_signal(created_models, verbosity, interactive, db) # Load initial_data fixtures (unless that has been disabled) if load_initial_data: call_command('loaddata', 'initial_data', verbosity=verbosity, database=db, skip_validation=True)
def setUpClass(cls): cls.orm = ORM.get()
def test_readonly_session_remove(self): # Please fix...this is not very useful IMO. -Mark orm = ORM.get() session = orm.sessionmaker(readonly=True) session.execute('SELECT 1') orm.sessionmaker_remove()
def handle_noargs(self, **options): verbosity = int(options.get('verbosity')) interactive = options.get('interactive') show_traceback = options.get('traceback') load_initial_data = options.get('load_initial_data') self.style = no_style() # Import the 'management' module within each installed app, to register # dispatcher events. for app_name in settings.INSTALLED_APPS: try: import_module('.management', app_name) except ImportError as exc: # This is slightly hackish. We want to ignore ImportErrors # if the "management" module itself is missing -- but we don't # want to ignore the exception if the management module exists # but raises an ImportError for some reason. The only way we # can do this is to check the text of the exception. Note that # we're a bit broad in how we check the text, because different # Python implementations may not use the same text. # CPython uses the text "No module named management" # PyPy uses "No module named myproject.myapp.management" msg = exc.args[0] if not msg.startswith('No module named') or 'management' not in msg: raise db = options.get('database') orm = ORM.get(db) engine = orm.engine default_schema = engine.url.database # the default db may not exist yet, so we remove it before connecting engine.url.database = None frags = str(engine.url).split('?') tmp_url = frags[0] if len(frags) == 2: if not tmp_url.endswith('/'): # query strings will break this if it doesn't end with a / tmp_url += '/' tmp_url += '?%s' % frags[1] engine.url.database = default_schema tmp_engine = create_engine(tmp_url) tmp_conn = tmp_engine.connect() existing_schemas = set([s[0] for s in tmp_conn.execute('show databases')]) if not default_schema in existing_schemas: tmp_engine.execute(CreateSchema(default_schema)) existing_schemas.add(default_schema) orm = ORM.get(db) # now reconnect with the default_db provided conn = engine.connect() Base.metadata.bind = engine if verbosity >= 3: self.stdout.write("Getting existing schemas...\n") for schema in existing_schemas: self.stdout.write("\t%s\n" % schema) else: self.stdout.write("\tNone\n") existing_tables = [] if verbosity >= 1: self.stdout.write("Getting existing tables...\n") for schema in existing_schemas: for name in engine.engine.table_names(schema, connection=conn): existing_tables.append('%s.%s' % (schema,name)) if verbosity >= 3: self.stdout.write("\t%s.%s\n" % (schema,name)) existing_models = [] if verbosity >= 1: self.stdout.write("Getting existing models...\n") for cls_name, cls in Base._decl_class_registry.items(): tablename = get_tablename(cls) if tablename and tablename in existing_tables: existing_models.append(cls) if verbosity >= 3: self.stdout.write("\t%s\n" % cls) all_tables = [] if verbosity >= 1: self.stdout.write("Getting required tables...\n") for table in Base.metadata.sorted_tables: tablename = get_tablename(table) all_tables.append(tablename) if verbosity >= 3: self.stdout.write("\t%s\n" % tablename) all_models = [] if verbosity >= 1: self.stdout.write("Getting required models...\n") for app in get_apps(): for model in get_models(app, include_auto_created=True): app_name = app.__name__.rsplit('.',1)[0] all_models.append( (app_name, model) ) if verbosity >= 3: self.stdout.write("\t%s.%s\n" % (app_name,model)) schema_manifest = set() table_manifest = set() if verbosity >= 1: self.stdout.write('Building manifest...\n') for app_name, model in all_models: tablename = get_tablename(model) if tablename in existing_tables: continue table_manifest.add( (app_name, model) ) schema = tablename.rsplit('.',1)[0] if schema not in existing_schemas: schema_manifest.add(schema) table_manifest = sorted(table_manifest, key=lambda x: all_tables.index(get_tablename(x[1]))) if verbosity >= 3: print 'Schema Manifest:\n' for schema in schema_manifest: print '\t%s\n' % schema print 'Model/Table Manifest\n' for app_name, model in table_manifest: print '\t%s.%s (%s)\n' % (app_name, model._meta.object_name, get_tablename(model)) # create any missing schemas if verbosity >= 1: self.stdout.write("Creating schemas ...\n") for schema in schema_manifest: if verbosity >= 3: self.stdout.write("\t%s\n" % schema) engine.execute(CreateSchema(schema)) existing_schemas.add(schema) # create any missing tables created_models = set() to_create = [] if verbosity >= 1: self.stdout.write("Creating tables ...\n") for app_name, model in table_manifest: if verbosity >= 3: self.stdout.write("\tCreating table for model %s.%s\n" % (app_name, model._meta.object_name)) tablename = get_tablename(model) if tablename not in existing_tables: table = model.__table__ to_create.append(table) existing_tables.append(tablename) existing_models.append(model) created_models.add(model) orm.Base.metadata.create_all(bind=engine, tables=to_create) # Send the post_syncdb signal emit_post_sync_signal(created_models, verbosity, interactive, db) # Load initial_data fixtures (unless that has been disabled) if load_initial_data: call_command('loaddata', 'initial_data', verbosity=verbosity, database=db, skip_validation=True)
def handle_noargs(self, **options): verbosity = 1 #int(options.get('verbosity')) interactive = options.get('interactive') show_traceback = options.get('traceback') self.style = no_style() # Import the 'management' module within each installed app, to register # dispatcher events. for app_name in settings.INSTALLED_APPS: try: import_module('.management', app_name) except ImportError as exc: # This is slightly hackish. We want to ignore ImportErrors # if the "management" module itself is missing -- but we don't # want to ignore the exception if the management module exists # but raises an ImportError for some reason. The only way we # can do this is to check the text of the exception. Note that # we're a bit broad in how we check the text, because different # Python implementations may not use the same text. # CPython uses the text "No module named management" # PyPy uses "No module named myproject.myapp.management" msg = exc.args[0] if not msg.startswith('No module named') or 'management' not in msg: raise db = options.get('database') orm = ORM.get(db) db_info = orm.settings_dict is_test_db = db_info.get('TEST', False) if not is_test_db: print 'Database "%s" cannot be purged because it is not a test ' \ 'database.\nTo flag this as a test database, set TEST to ' \ 'True in the database settings.' % db sys.exit() if interactive: confirm = raw_input('\nYou have requested a purge of database ' \ '"%s" (%s). This will IRREVERSIBLY DESTROY all data ' \ 'currently in the database, and DELETE ALL TABLES AND ' \ 'SCHEMAS. Are you sure you want to do this?\n\n' \ 'Type "yes" to continue, or "no" to cancel: ' \ % (db, orm.engine.url)) else: confirm = 'yes' if confirm == 'yes': # get a list of all schemas used by the app default_schema = orm.engine.url.database app_schemas = set(orm.Base.metadata._schemas) app_schemas.add(default_schema) url = deepcopy(orm.engine.url) url.database = None engine = create_engine(url) inspector = inspect(engine) # get a list of existing schemas db_schemas = set(inspector.get_schema_names()) schemas = app_schemas.intersection(db_schemas) app_tables = set() for table in orm.Base.metadata.tables.values(): schema = table.schema or default_schema app_tables.add('%s.%s' % (schema, table.name)) metadata = MetaData() db_tables = [] all_fks = [] for schema in schemas: for table_name in inspector.get_table_names(schema): fullname = '%s.%s' % (schema, table_name) if fullname not in app_tables: continue fks = [] for fk in inspector.get_foreign_keys(table_name, schema=schema): if not fk['name']: continue fks.append(ForeignKeyConstraint((),(),name=fk['name'])) t = Table(table_name, metadata, *fks, schema=schema) db_tables.append(t) all_fks.extend(fks) session = Session(bind=engine) for fkc in all_fks: session.execute(DropConstraint(fkc)) for table in db_tables: session.execute(DropTable(table)) for schema in schemas: session.execute(DropSchema(schema)) session.commit() session.bind.dispose() else: self.stdout.write("Purge cancelled.\n")
def loaddata(self, fixture_labels): #connection = connections[self.using] connection = orm = ORM.get(self.using) # Keep a count of the installed objects and fixtures self.fixture_count = 0 self.loaded_object_count = 0 self.fixture_object_count = 0 self.models = set() self.serialization_formats = serializers.get_public_serializer_formats() # Forcing binary mode may be revisited after dropping Python 2 support (see #22399) self.compression_formats = { None: (open, 'rb'), 'gz': (gzip.GzipFile, 'rb'), 'zip': (SingleZipReader, 'r'), } if has_bz2: self.compression_formats['bz2'] = (bz2.BZ2File, 'r') ''' with connection.constraint_checks_disabled(): for fixture_label in fixture_labels: self.load_label(fixture_label) ''' session = orm.sessionmaker() session.close() for fixture_label in fixture_labels: self.load_label(fixture_label) session.commit() # Since we disabled constraint checks, we must manually check for # any invalid keys that might have been added # TODO: implement this ''' table_names = [model._meta.db_table for model in self.models] try: connection.check_constraints(table_names=table_names) except Exception as e: e.args = ("Problem installing fixtures: %s" % e,) raise ''' # If we found even one object in a fixture, we need to reset the # database sequences. # TODO: implement this ''' if self.loaded_object_count > 0: sequence_sql = connection.ops.sequence_reset_sql(no_style(), self.models) if sequence_sql: if self.verbosity >= 2: self.stdout.write("Resetting sequences\n") cursor = connection.cursor() for line in sequence_sql: cursor.execute(line) cursor.close() ''' if self.fixture_count == 0 and self.hide_empty: pass elif self.fixture_object_count == self.loaded_object_count: logger.info("Installed %d object(s) from %d fixture(s)" % (self.loaded_object_count, self.fixture_count)) else: logger.info("Installed %d object(s) (of %d) from %d fixture(s)" % (self.loaded_object_count, self.fixture_object_count, self.fixture_count))
from hashlib import sha1 as sha_constructor import random from django import forms from django.contrib.auth import authenticate from django.utils.translation import ugettext_lazy as _ from sqlalchemy.orm import joinedload from baph.auth.models import User, Organization from baph.auth.registration import settings from baph.auth.registration.managers import SignupManager from baph.auth.utils import generate_sha1 from baph.db.orm import ORM orm = ORM.get() attrs_dict = {'class': 'required'} def identification_field_factory(label, error_required): """ A simple identification field factory which enable you to set the label. :param label: String containing the label for this field. :param error_required: String containing the error message if the field is left empty. """
def setUpClass(cls): super(RegistrationViewTests, cls).setUpClass() User.__table__.create() orm = ORM.get() cls.session = orm.sessionmaker()
def test_session_close(self): # Please fix...this is not very useful IMO. -Mark orm = ORM.get() session = orm.sessionmaker() session.execute('SELECT 1') orm.sessionmaker_close()
def process_request(self, request): request.orm = ORM.get()
def setUpClass(cls): super(RegistrationFormTests, cls).setUpClass() User.__table__.create() orm = ORM.get() cls.session = orm.sessionmaker()
from django.utils.importlib import import_module from django.utils.translation import ugettext as _ from sqlalchemy import * from sqlalchemy.ext.associationproxy import association_proxy from sqlalchemy.ext.declarative import declared_attr, clsregistry from sqlalchemy.ext.declarative.base import _add_attribute from sqlalchemy.orm import synonym, relationship, backref, RelationshipProperty from baph.auth.mixins import UserPermissionMixin from baph.db.models import Model from baph.db.orm import ORM, Base from baph.db.types import UUID, Dict, List from baph.utils.strings import random_string import inspect orm = ORM.get() AUTH_USER_FIELD_TYPE = getattr(settings, 'AUTH_USER_FIELD_TYPE', 'UUID') AUTH_USER_FIELD = UUID if AUTH_USER_FIELD_TYPE == 'UUID' else Integer def _generate_user_id_column(): if AUTH_USER_FIELD_TYPE != 'UUID': return Column(AUTH_USER_FIELD, primary_key=True) return Column(UUID, primary_key=True, default=uuid.uuid4) def get_hexdigest(algorithm, salt, raw_password): '''Extends Django's :func:`django.contrib.auth.models.get_hexdigest` by adding support for all of the other available hash algorithms.