def test_i18n( self ):
     from camelot.model.i18n import Translation, ExportAsPO
     session = Session()
     session.execute( Translation.__table__.delete() )
     self.assertEqual( Translation.translate( 'bucket', 'nl_BE' ), None )
     # run twice to check all branches in the code
     Translation.translate_or_register( 'bucket', 'nl_BE' )
     Translation.translate_or_register( 'bucket', 'nl_BE' )
     self.assertEqual( Translation.translate( 'bucket', 'nl_BE' ), 'bucket' )
     self.assertEqual( Translation.translate( '', 'nl_BE' ), '' )
     self.assertEqual( Translation.translate_or_register( '', 'nl_BE' ), '' )
     # clear the cache
     Translation._cache.clear()
     # fill the cache again
     translation = Translation( language = 'nl_BE', source = 'bucket',
                                value = 'emmer', uid=1 )
     orm.object_session( translation ).flush()
     self.assertEqual( Translation.translate( 'bucket', 'nl_BE' ), 'emmer' )
     export_action = ExportAsPO()
     model_context = MockModelContext()
     model_context.obj = translation
     try:
         generator = export_action.model_run( model_context )
         file_step = generator.next()
         generator.send( ['/tmp/test.po'] )
     except StopIteration:
         pass

    def longslit_calibrate_to_database(self, gmos_long_slit_arc_calibration=None, destination_dir='.', force=False):

        session = object_session(self)

        if self.wave_cal is not None:
            if not force:
                raise GMOSDatabaseDuplicate('This arc already has a wavelength calibration {0}. '
                                            'Use force=True to override'.format(self.wave_cal))
            else:
                session.delete(self.wave_cal)
                session.commit()

        arctab, linesall, shift, fake = self.longslit_calibrate(gmos_long_slit_arc_calibration=gmos_long_slit_arc_calibration)

        wavecal_store_fname = 'arccal-{}.h5'.format(self.raw.fits.fname.replace('.fits',''))
        wavecal_store_full_path = os.path.join(destination_dir, wavecal_store_fname)
        arctab.write(wavecal_store_full_path, path='arc', overwrite=True, format='hdf5')
        #linesall.write(wavecal_store_full_path, path='lines', append=True, format='hdf5')

        session = object_session(self)

        gmos_long_slit_wavecal = GMOSLongSlitArcWavelengthSolution(id = self.id, fname=wavecal_store_fname,
                                                                   path=os.path.abspath(destination_dir))

        session.add(gmos_long_slit_wavecal)
        session.commit()

        return gmos_long_slit_wavecal

    def last_modified(self):
        """ Returns last change of the elections. """

        changes = [self.last_change, self.last_result_change]
        session = object_session(self)
        election_ids = [election.id for election in self.elections]

        # Get the last election change
        result = object_session(self).query(Election.last_change)
        result = result.order_by(desc(Election.last_change))
        result = result.filter(Election.id.in_(election_ids))
        changes.append(result.first()[0] if result.first() else None)

        # Get the last candidate change
        result = object_session(self).query(Candidate.last_change)
        result = result.order_by(desc(Candidate.last_change))
        result = result.filter(Candidate.election_id.in_(election_ids))
        changes.append(result.first()[0] if result.first() else None)

        # Get the last list connection change
        result = session.query(ListConnection.last_change)
        result = result.order_by(desc(ListConnection.last_change))
        result = result.filter(ListConnection.election_id.in_(election_ids))
        changes.append(result.first()[0] if result.first() else None)

        # Get the last list change
        result = session.query(List.last_change)
        result = result.order_by(desc(List.last_change))
        result = result.filter(List.election_id == self.id)
        changes.append(result.first()[0] if result.first() else None)

        changes = [change for change in changes if change]
        return max(changes) if changes else None

 def __getattr__( self, name ):
     if name in self.spec:
         if name in self.parent._metadata:
             return self.spec[name].wrap( self.parent._metadata[name], object_session( self.parent ) )
         return self.spec[name].wrap( self.spec[name].default, object_session( self.parent ) )
     if name in self.parent._metadata:
         return self.parent._metadata[name]

def set_session_profile(survey, survey_session, profile):
    """Set up the survey session using a given profile.

    :param survey: the survey to use
    :type survey: :py:class:`euphorie.content.survey.Survey`
    :param survey_session: survey session to update
    :type survey_session: :py:class:`euphorie.client.model.SurveySession`
    :param dict profile: desired profile
    :rtype: :py:class:`euphorie.client.model.SurveySession`
    :return: the update session (this might be a new session)

    This will rebuild the survey session tree if the profile has changed.
    """
    if not survey_session.hasTree():
        BuildSurveyTree(survey, profile, survey_session)
        return survey_session

    current_profile = extractProfile(survey, survey_session)
    if current_profile == profile and not treeChanges(survey_session, survey):
        survey_session.touch()
        return survey_session

    new_session = create_survey_session(
            survey_session.title, survey, survey_session.account)
    BuildSurveyTree(survey, profile, new_session, survey_session)
    new_session.copySessionData(survey_session)
    object_session(survey_session).delete(survey_session)
    return new_session

def test_invalid_token_during_connect(db, patch_access_token_getter,
                                      account_with_single_auth_creds):
    account_id = account_with_single_auth_creds.id

    patch_access_token_getter.revoke_refresh_token(
        account_with_single_auth_creds.auth_credentials[0].refresh_token)
    account_with_single_auth_creds.verify_all_credentials()
    assert len(account_with_single_auth_creds.valid_auth_credentials) == 0
    g_token_manager.clear_cache(account_with_single_auth_creds)

    # connect_account() takes an /expunged/ account object
    # that has the necessary relationships eager-loaded
    object_session(account_with_single_auth_creds).expunge(
        account_with_single_auth_creds)
    assert not object_session(account_with_single_auth_creds)

    account = db.session.query(GmailAccount).options(
        joinedload(GmailAccount.auth_credentials)).get(
        account_id)
    db.session.expunge(account)
    assert not object_session(account)

    g = GmailAuthHandler('gmail')

    with pytest.raises(OAuthError):
        g.connect_account(account)

    invalid_account = db.session.query(GmailAccount).get(account_id)
    for auth_creds in invalid_account.auth_credentials:
        assert not auth_creds.is_valid

def on_after_update(mapper, connection, target):
    request = getattr(target, '_request', None)
    from .documents import BaseDocument

    # Reindex old one-to-one related object
    committed_state = attributes.instance_state(target).committed_state
    columns = set()
    for field, value in committed_state.items():
        if isinstance(value, BaseDocument):
            obj_session = object_session(value)
            # Make sure object is not updated yet
            if not obj_session.is_modified(value):
                obj_session.expire(value)
            index_object(value, with_refs=False,
                         request=request)
        else:
            id_pos = field.rfind('_id')
            if id_pos >= 0:
                rel_name = field[:id_pos]
                rel = mapper.relationships.get(rel_name, False)
                if rel and any(c.name == field for c in rel.local_columns):
                    columns.add(rel_name)

    # Reload `target` to get access to processed fields values
    columns = columns.union([c.name for c in class_mapper(target.__class__).columns])
    object_session(target).expire(target, attribute_names=columns)
    index_object(target, request=request, with_refs=False, nested_only=True)

    # Reindex the item's parents. This must be done after the child has been processes
    for parent, children_field in target.get_parent_documents(nested_only=True):
        columns = [c.name for c in class_mapper(parent.__class__).columns]
        object_session(parent).expire(parent, attribute_names=columns)
        ES(parent.__class__.__name__).index_nested_document(parent, children_field, target)

    def __init__(self, namespace_id=None, subject=None, thread_public_id=None,
                 started_before=None, started_after=None,
                 last_message_before=None, last_message_after=None,
                 any_email=None, to_addr=None, from_addr=None, cc_addr=None,
                 bcc_addr=None, filename=None, tag=None, detached=True):

        self.namespace_id = namespace_id
        self.subject = subject
        self.thread_public_id = thread_public_id
        self.started_before = started_before
        self.started_after = started_after
        self.last_message_before = last_message_before
        self.last_message_after = last_message_after
        self.any_email = any_email
        self.to_addr = to_addr
        self.from_addr = from_addr
        self.cc_addr = cc_addr
        self.bcc_addr = bcc_addr
        self.filename = filename
        self.tag = tag

        if detached and object_session(self) is not None:
            s = object_session(self)
            s.expunge(self)
            # Note, you can later add this object to a session by doing
            # session.merge(detached_objecdt)

        # For transaction filters
        self.filters = []
        self.setup_filters()

    def test_explicit_expunge_deleted(self):
        users, User = self.tables.users, self.classes.User

        mapper(User, users)
        sess = Session()
        sess.add(User(name='x'))
        sess.commit()

        u1 = sess.query(User).first()
        sess.delete(u1)

        sess.flush()

        assert was_deleted(u1)
        assert u1 not in sess
        assert object_session(u1) is sess

        sess.expunge(u1)
        assert was_deleted(u1)
        assert u1 not in sess
        assert object_session(u1) is None

        sess.rollback()
        assert was_deleted(u1)
        assert u1 not in sess
        assert object_session(u1) is None

def answer_mode(survey_node: AnswerableSurveyNode):
    """Get the mode of the answers."""
    type_constraint = survey_node.the_type_constraint
    allowable_types = {
        'text', 'integer', 'decimal', 'date', 'time', 'timestamp', 'location',
        'facility', 'multiple_choice'
    }
    if type_constraint not in allowable_types:
        raise InvalidTypeForOperation((type_constraint, 'mode'))
    answer_cls = ANSWER_TYPES[survey_node.the_type_constraint]
    result = (
        object_session(survey_node)
        .execute(
            sa.text(
                'SELECT MODE() WITHIN GROUP (ORDER BY main_answer)'
                ' FROM {table} JOIN {answer_table} ON'
                ' {table}.id = {answer_table}.id'
                ' WHERE {answer_table}.survey_node_id = :sn_id'.format(
                    table=answer_cls.__table__,
                    answer_table=Answer.__table__,
                )
            ),
            {'sn_id': survey_node.id}
        )
        .scalar()
    )
    if type_constraint == 'multiple_choice' and result:
        result = object_session(survey_node).query(Choice).get(str(result))
    return result

def _create_object_in_session( obj ):
    session = object_session( obj ) if object_session is not None else None
    if session is not None:
        object_session( obj ).add( obj )
        object_session( obj ).flush()
    else:
        raise Exception( NO_SESSION_ERROR_MESSAGE )

 def should_suppress_transaction_creation(self):
     if (self in object_session(self).new or
             self in object_session(self).deleted):
         return False
     obj_state = inspect(self)
     return not (obj_state.attrs.name.history.has_changes() or
                 obj_state.attrs.description.history.has_changes() or
                 obj_state.attrs.read_only.history.has_changes())

 def __exit__( self, exc_type, exc_val, exc_tb ):
     if exc_type != None:
         self.add_exception_to_message( exc_type, exc_val, exc_tb )
         self.status = 'errors'
     elif self.status == 'running':
         self.status = 'success'
     orm.object_session( self ).commit()
     return True

    def fix(self, geolocation):
        if self.latitude == 0 or self.longitude == 0:
            position = geolocation.get_position_by_name(self.address)

            self.latitude = position[0]
            self.longitude = position[1]

            object_session(self).commit()
            object_session(self).flush()

  def log_activity(self, sender, actor, verb, object, target=None):
    assert self.running
    entry = ActivityEntry(actor=actor, verb=verb, object=object, target=target)
    entry.object_type = object.entity_type

    if target is not None:
        entry.target_type = target.entity_type

    object_session(object).add(entry)

 def _record(self, mapper, model, operation):
     pk = tuple(mapper.primary_key_from_instance(model))
     # FIXME: Some hack just to prevent from crashing when trying to look
     # for _model_changes attribute. Happens when loading fixutres with
     # the fixture library.
     if not hasattr(orm.object_session(model), '_model_changes'):
         orm.object_session(model)._model_changes = dict()
     orm.object_session(model)._model_changes[pk] = (model, operation)
     return EXT_CONTINUE

 def make_copy( self, value, target_context, source_context ):
     value = self.wrap( value, object_session( target_context.parent ) )
     if value:
         new_value = galaxy.model.MetadataFile( dataset = target_context.parent, name = self.spec.name )
         object_session( target_context.parent ).add( new_value )
         object_session( target_context.parent ).flush()
         shutil.copy( value.file_name, new_value.file_name )
         return self.unwrap( new_value )
     return None

    def test_current_authentication(self):
        from camelot.model.authentication import get_current_authentication

        authentication = get_current_authentication()
        # current authentication cache should survive
        # a session expire + expunge
        orm.object_session(authentication).expire_all()
        orm.object_session(authentication).expunge_all()
        authentication = get_current_authentication()
        self.assertTrue(authentication.username)

 def get_object_state(self):
     if object_session(self) is None and not has_identity(self):
         return 'transient'
     elif object_session(self) is not None and not has_identity(self):
         return 'pending'
     elif object_session(self) is None and has_identity(self):
         return 'detached'
     elif object_session(self) is not None and has_identity(self):
         return 'persistent'
     raise Exception

 def also_set_tag(self, key, folderitem, is_remove):
     # Also add or remove the associated tag whenever a folder is added or
     # removed.
     with object_session(self).no_autoflush:
         folder = folderitem.folder
         tag = folder.get_associated_tag(object_session(self))
         if is_remove:
             self.remove_tag(tag)
         else:
             self.apply_tag(tag)
     return folderitem