try:

            with open(self._conf_name, 'rb') as conf:

                config = json.load(conf)

            sys.stderr.write(str(e) + '\n')

        config.update(new_config)

        try:

            with open(self._conf_name, 'rb') as conf:

                return  json.load(conf)

            #sys.stderr.write(str(e) + '\n')

            pass

    try:

        return _run(argv)

        print e

        return 1

            t = metadata.tables[old_ui_name]

            print 'Renaming', t, 'to', new_ui_name

            migrate.changeset.rename_table(t, new_ui_name)

            print 'Not renaming ui:', e

    if new_settings_name == old_settings_name:

            t = metadata.tables[old_settings_name]

            print 'Renaming', t, 'to', new_settings_name

            migrate.changeset.rename_table(t, new_settings_name)

            print 'Not renaming settings:', e

    old_auth_name = 'internal' if old == 'kallithea' else old

            Session().commit()

            h.flash(_('Auth settings updated successfully'),

                       category='success')

            log.error(traceback.format_exc())

            e = errors.error_dict or {}

            return self.__render(

            h.flash(_('Default settings updated successfully'),

                    category='success')

            defaults = errors.value

            return htmlfill.render(

            )

            Session().commit()

            new_gist_id = gist.gist_access_id

            defaults = errors.value

            return formencode.htmlfill.render(

                encoding="UTF-8",

                force_defaults=False)

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during gist creation'), category='error')

            return redirect(url('new_gist'))

                Session().commit()

                update = True

                return htmlfill.render(

                    render('admin/my_account/my_account.html'),

                    defaults=errors.value,

            UserModel().add_extra_email(self.authuser.user_id, email)

            Session().commit()

            h.flash(_("Added email %s to user") % email, category='success')

            msg = error.error_dict['email']

            h.flash(msg, category='error')

        except Exception:

                h.flash(_('Global permissions updated successfully'),

                        category='success')

                defaults = errors.value

                return htmlfill.render(

            )

            Session().commit()

            #TODO: in futureaction_logger(, '', '', '', self.sa)

            return htmlfill.render(

                render('admin/repo_groups/repo_group_add.html'),

                defaults=errors.value,

            # we now have new name !

            group_name = new_gr.group_name

            #TODO: in future action_logger(, '', '', '', self.sa)

            return htmlfill.render(

                render('admin/repo_groups/repo_group_edit.html'),

            from celery.result import BaseAsyncResult

            if isinstance(task, BaseAsyncResult):

                task_id = task.task_id

            log.info(errors)

            return htmlfill.render(

                render('admin/repos/repo_add.html'),

            action_logger(self.authuser, 'admin_updated_repo',

                              changed_name, self.ip_addr, self.sa)

            Session().commit()

            log.info(errors)

            defaults = self.__load_data(repo_name)

            defaults.update(errors.value)

            new_field.field_label = form_result['new_field_label']

            Session().add(new_field)

            Session().commit()

            log.error(traceback.format_exc())

            msg = _('An error occurred during creation of field')

            if isinstance(e, formencode.Invalid):

        try:

            Session().delete(field)

            Session().commit()

            log.error(traceback.format_exc())

            msg = _('An error occurred during removal of field')

            h.flash(msg, category='error')

            Session().commit()

            h.flash(_('Marked repo %s as fork of %s') % (repo_name, fork),

                    category='success')

            log.error(traceback.format_exc())

            h.flash(str(e), category='error')

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during this operation'),

                    category='error')

            elif request.POST.get('set_unlock'):

                Repository.unlock(repo)

                h.flash(_('Unlocked repository'), category='success')

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during unlocking'),

                    category='error')

                h.flash(_('Repository has been %s') % action,

                        category='success')

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during unlocking'),

                    category='error')

                Session().commit()

                h.flash(_('Cache invalidation successful'),

                        category='success')

                log.error(traceback.format_exc())

                h.flash(_('An error occurred during cache invalidation'),

                        category='error')

            try:

                ScmModel().pull_changes(repo_name, self.authuser.username)

                h.flash(_('Pulled from remote location'), category='success')

                log.error(traceback.format_exc())

                h.flash(_('An error occurred during pull from remote location'),

                        category='error')

            try:

                RepoModel().delete_stats(repo_name)

                Session().commit()

                log.error(traceback.format_exc())

                h.flash(_('An error occurred during deletion of repository stats'),

                        category='error')

            application_form = ApplicationUiSettingsForm()()

            try:

                form_result = application_form.to_python(dict(request.POST))

                return htmlfill.render(

                     render('admin/settings/settings.html'),

                     defaults=errors.value,

            application_form = ApplicationSettingsForm()()

            try:

                form_result = application_form.to_python(dict(request.POST))

                return htmlfill.render(

                    render('admin/settings/settings.html'),

                    defaults=errors.value,

            application_form = ApplicationVisualisationForm()()

            try:

                form_result = application_form.to_python(dict(request.POST))

                return htmlfill.render(

                    render('admin/settings/settings.html'),

                    defaults=errors.value,

            response = opener.open(_update_url)

            response_data = response.read()

            data = json.loads(response_data)

            log.error(traceback.format_exc())

            return _err('Failed to contact upgrade server: %r' % e)

            log.error(traceback.format_exc())

            return _err('Bad data sent from update server')

            h.flash(h.literal(_('Created user group %s') % h.link_to(h.escape(gr), url('edit_users_group', id=ug.users_group_id))),

                category='success')

            Session().commit()

            return htmlfill.render(

                render('admin/user_groups/user_group_add.html'),

                defaults=errors.value,

                          None, self.ip_addr, self.sa)

            h.flash(_('Updated user group %s') % gr, category='success')

            Session().commit()

            ug_model = UserGroupModel()

            defaults = errors.value

            e = errors.error_dict or {}

            UserGroupModel().delete(usr_gr)

            Session().commit()

            h.flash(_('Successfully deleted user group'), category='success')

            h.flash(e, category='error')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(h.literal(_('Created user %s') % h.link_to(h.escape(usr), url('edit_user', id=user.user_id))),

                    category='success')

            Session().commit()

            return htmlfill.render(

                render('admin/users/user_add.html'),

                defaults=errors.value,

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

            h.flash(e, 'error')

        except Exception:

            log.error(traceback.format_exc())

                          None, self.ip_addr, self.sa)

            h.flash(_('User updated successfully'), category='success')

            Session().commit()

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

            UserModel().delete(usr)

            Session().commit()

            h.flash(_('Successfully deleted user'), category='success')

            h.flash(e, category='warning')

        except Exception:

            log.error(traceback.format_exc())

            user_model.add_extra_email(id, email)

            Session().commit()

            h.flash(_("Added email %s to user") % email, category='success')

            msg = error.error_dict['email']

            h.flash(msg, category='error')

        except Exception:

            user_model.add_extra_ip(id, ip)

            Session().commit()

            h.flash(_("Added IP address %s to user whitelist") % ip, category='success')

            msg = error.error_dict['ip']

            h.flash(msg, category='error')

        except Exception:

        try:

            json_body = json.loads(raw_body)

            # catch JSON errors Here

            return jsonrpc_error(retid=self._req_id,

                                 message="JSON parse error ERR:%s RAW:%r"

                'method: %s, params: %s' % (self._req_method,

                                            self._request_params)

            )

            return jsonrpc_error(retid=self._req_id,

                                 message='Incorrect JSON query missing %s' % e)

            else:

                log.info('Access for IP:%s allowed' % (ip_addr,))

            return jsonrpc_error(retid=self._req_id,

                                 message='Invalid API key')

        self._error = None

        try:

            self._func = self._find_method()

            return jsonrpc_error(retid=self._req_id,

                                 message=str(e))

            raw_response = self._inspect_call(self._func)

            if isinstance(raw_response, HTTPError):

                self._error = str(raw_response)

            self._error = safe_str(e)

            log.error('Encountered unhandled exception: %s'

                      % (traceback.format_exc(),))

            json_exc = JSONRPCError('Internal server error')

        response = dict(id=self._req_id, result=raw_response, error=self._error)

        try:

            return json.dumps(response)

            log.error('API FAILED. Error encoding response: %s' % e)

            return json.dumps(

                dict(

                    (user_group.users_group_id, user_group.users_group_name),

                user_group=None

            )

            log.error(traceback.format_exc())

            raise JSONRPCError(str(e))

        except Exception:

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

            h.flash(h.literal(_('There are no changesets yet')),

                    category='error')

            log.error(traceback.format_exc())

            h.flash(safe_str(e), category='error')

        raise HTTPBadRequest()

                    try:

                        cs = self.__get_cs(revision, repo_name)

                        collection = cs.get_file_history(f_path)

                        h.flash(safe_str(e), category='warning')

                        redirect(h.url('changelog_home', repo_name=repo_name))

                collection = list(reversed(collection))

            page_revisions = [x.raw_id for x in c.pagination]

            c.comments = c.db_repo.get_comments(page_revisions)

            c.statuses = c.db_repo.statuses(page_revisions)

            h.flash(safe_str(e), category='warning')

            return redirect(url('summary_home', repo_name=c.repo_name))

            log.error(traceback.format_exc())

            h.flash(safe_str(e), category='error')

            return redirect(url('changelog_home', repo_name=c.repo_name))

        if request.is_xhr:

            try:

                return c.db_repo_scm_instance.get_changeset(revision)

                return EmptyChangeset(message=str(e))

        else:

            raise HTTPBadRequest()

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

            if silent_empty:

                return None

            url_ = url('files_add_home',

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

                    c.authors.append((h.email(a), h.person(a)))

            else:

                c.authors = c.file_history = []

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

                h.flash(_('Successfully committed to %s') % node_path,

                        category='success')

                h.flash(_('Location must be relative path and must not '

                          'contain .. in path'), category='warning')

                return redirect(url('changeset_home', repo_name=c.repo_name,

                                    revision='tip'))

                h.flash(_(e), category='error')

            except Exception:

                log.error(traceback.format_exc())

            from celery.result import BaseAsyncResult

            if isinstance(task, BaseAsyncResult):

                task_id = task.task_id

            return htmlfill.render(

                render('forks/fork.html'),

                defaults=errors.value,

                # form checks for username/password, now we're authenticated

                username = c.form_result['username']

                user = User.get_by_username(username, case_insensitive=True)

                defaults = errors.value

                # remove password from filling in form again

                del defaults['password']

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

                # container auth or other auth functions that create users on

                # the fly can throw this exception signaling that there's issue

                # with user creation, explanation should be provided in

                Session().commit()

                return redirect(url('login_home'))

                return htmlfill.render(

                    render('/register.html'),

                    defaults=errors.value,

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

                # container auth or other auth functions that create users on

                # the fly can throw this exception signaling that there's issue

                # with user creation, explanation should be provided in

                            category='success')

                return redirect(url('login_home'))

                return htmlfill.render(

                    render('/password_reset.html'),

                    defaults=errors.value,

                h.flash(_('Your password reset was successful, '

                          'new password has been sent to your email'),

                            category='success')

                log.error(e)

                return redirect(url('reset_password'))

        org_scm_instance = org_repo.scm_instance

        try:

            org_scm_instance.get_changeset()

            h.flash(h.literal(_('There are no changesets yet')),

                    category='warning')

            redirect(url('summary_home', repo_name=org_repo.repo_name))

        repo = RepoModel()._get_repo(repo_name)

        try:

            _form = PullRequestForm(repo.repo_id)().to_python(request.POST)

            log.error(traceback.format_exc())

            log.error(str(errors))

            msg = _('Error creating pull request: %s') % errors.msg

            Session().commit()

            h.flash(_('Successfully opened new pull request'),

                    category='success')

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        except Exception:

                old_pull_request.other_repo.repo_name, new_other_ref,

                revisions, reviewers_ids, title, description

            )

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        except Exception:

        try:

            PullRequestModel().mention_from_description(pull_request, old_description)

            PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        wk_dir = repo.workdir

        cur_rev = wk_dir.get_changeset()

        return (cur_rev.revision, cur_rev.short_id)

        if not quiet:

            print ("WARNING: Cannot retrieve kallithea's revision. "

                   "disregard this if you don't know what that means. "

    for module in auth_plugins:

        try:

            plugin = loadplugin(module)

            raise ImportError('Failed to load authentication module %s : %s'

                              % (module, str(e)))

        log.debug('Trying authentication using ** %s **' % (module,))

                rval["status"] = True

            else:

                rval = "".join(rdoc.readlines())

            if not noformat:

                rval = {"status": False,

                        "body": body,

            log.info('running task %s:%s' % (t.task_id, task))

            return t

            if isinstance(e, IOError) and e.errno == 111:

                log.debug('Unable to connect to celeryd. Sync execution')

                CELERY_ON = False

            else:

                log.error(traceback.format_exc())

                log.debug('Unable to connect to celeryd. Sync execution')

            log.error(traceback.format_exc())

    log.debug('executing task %s in sync mode' % task)

        # set new created state

        repo.set_state(Repository.STATE_CREATED)

        DBS.commit()

        log.warning('Exception %s occurred when forking repository, '

                    'doing cleanup...' % e)

        # rollback things manually !

        # set new created state

        repo.set_state(Repository.STATE_CREATED)

        DBS.commit()

        log.warning('Exception %s occurred when forking repository, '

                    'doing cleanup...' % e)

        #rollback things manually !

            cls.require_found(path)

            cls.require_found(os.path.join(path, cls._config))

            cls.require_found(os.path.join(path, cls._versions))

            raise exceptions.InvalidRepositoryError(path)

    @classmethod

        module = import_path(path)

        try:

            assert callable(module.upgrade)

            raise InvalidScriptError(path + ': %s' % str(e))

        return module

        ret = command_func(**kwargs)

        if ret is not None:

            log.info(ret)

        parser.error(e.args[0])

if __name__ == "__main__":

    try:

        return f(*a, **kw)

        raise exceptions.KnownError("The path %s already exists" % e.args[0])

def construct_engine(engine, **opts):

    if old_cons:

        try:

            old_cons.drop()

            # we don't care if this fails really... better to pass migration than

            # leave this in intermidiate state

            print 'Failed to remove Unique for user_id, repository_id reason %s' % e

    if old_cons:

        try:

            old_cons.drop()

            # we don't care if this fails really... better to pass migration than

            # leave this in intermidiate state

            print 'Failed to remove Unique for user_id, repository_id reason %s' % e

                        _rev_type = 'branch'

                    elif _rev in known_bookmarks:

                        _rev_type = 'book'

                print e

                print 'continue...'

                #we don't want any error to break the process

            out = subprocessio.SubprocessIOChunker(cmd,

                starting_values=[packet_len + server_advert + '0000']

            )