def get_census_profile(geo_code, geo_level):
    session = get_session()

    try:
        geo_summary_levels = get_summary_geo_info(geo_code, geo_level, session)
        data = {}

        for section in PROFILE_SECTIONS:
            function_name = 'get_%s_profile' % section
            if function_name in globals():
                func = globals()[function_name]
                data[section] = func(geo_code, geo_level, session)

                # get profiles for province and/or country
                for level, code in geo_summary_levels:
                    # merge summary profile into current geo profile
                    merge_dicts(data[section], func(code, level, session), level)

        # tweaks to make the data nicer
        # show X largest groups on their own and group the rest as 'Other'
        group_remainder(data['households']['roofing_material_distribution'], 5)
        group_remainder(data['households']['wall_material_distribution'], 5)

        return data

    finally:
        session.close()

def get_census_profile(geo_code, geo_level):
    session = get_session()

    try:
        geo_summary_levels = get_summary_geo_info(geo_code, geo_level, session)
        data = {}

        for section in PROFILE_SECTIONS:
            function_name = 'get_%s_profile' % section
            if function_name in globals():
                func = globals()[function_name]
                data[section] = func(geo_code, geo_level, session)

                # get profiles for province and/or country
                for level, code in geo_summary_levels:
                    # merge summary profile into current geo profile
                    merge_dicts(data[section], func(code, level, session), level)

        # tweaks to make the data nicer
        # show 3 largest groups on their own and group the rest as 'Other'
        group_remainder(data['service_delivery']['water_source_distribution'])
        group_remainder(data['service_delivery']['refuse_disposal_distribution'])
        group_remainder(data['service_delivery']['toilet_facilities_distribution'], 5)
        group_remainder(data['demographics']['language_distribution'], 7)
        
        return data

    finally:
        session.close()

 def _initMappers(self, version = None):
     """
     Init database mappers.
     """
     if version == None:
         version = self.getUptodateVersion()
     func = getattr(self, "_initMappers" + self.config.auditdbdriver + "V" + str(version))
     func()

 def wrapper(self, *args, **kwArgs):
     try:
         return func(self, *args, **kwArgs)
     except (MPDError, OSError) as ex:
         logger.warning('Detect MPD connection error; reconnecting...')
         logger.debug(ex)
         self._mpd = initialize_mpd(self.conf)
         return func(self, *args, **kwArgs)

 def _populateTables(self, version = None):
     """
     Populate tables before the first use.
     """
     if version == None:
         version = self.getUptodateVersion()
     func = getattr(self, "_populateTables" + self.config.auditdbdriver + "V" + str(version))
     func()

 def decorated_function(*args, **kwargs):
     callback = request.args.get('callback', False)
     if callback:
         data = str(func(*args, **kwargs).data)
         content = str(callback) + '(' + data + ')'
         mimetype = 'application/javascript'
         return current_app.response_class(content, mimetype=mimetype)
     else:
         return func(*args, **kwargs)

 def wrapper(*args, **kwargs):
     if not kwargs.get('session'):
         kwargs['session'] = Session(autoflush=True, expire_on_commit=False)
         try:
             result = func(*args, **kwargs)
             kwargs['session'].commit()
             return result
         finally:
             kwargs['session'].close()
     else:
         return func(*args, **kwargs)

        def call(db, *args, **kwargs):
            # if the Database has an active session, don't create a new one
            if db.session is not None:
                result = func(db, *args, **kwargs)
                if commit:
                    db.session.commit()
            else:
                # otherwise, use the session generator
                with db_session(db, commit=commit):
                    result = func(db, *args, **kwargs)

            return result

 def do_task(self, args):
     if args['func'] == 'seq':
         func = self._calculate_seq_stats
     elif args['func'] == 'clone':
         func = self._calculate_clone_stats
     self.info(('Processing {} for sample {}, include_outliers {}, '
                'only_full_reads {}').format(
                'sequences' if args['func'] == 'seq' else 'clones',
                args['sample_id'], args['include_outliers'],
                args['only_full_reads']))
     func(args['sample_id'], args['min_cdr3'], args['max_cdr3'],
          args['include_outliers'], args['only_full_reads'])
     self._session.commit()

    def wrapper(**kwargs):
        #Only track user id if they are authenticated
        if current_user.is_authenticated:
            user_id = current_user.id
        else:
            user_id = None

        #Get session id if it exists; Reminder, session id lasts 8 years or until cookies are deleted
        session_id = session.get('FVID')

        # Get To URL
        base_url = request.base_url

        # Get From Url
        referrer_url = request.referrer if request.referrer else 'None'

        # get user agent
        user_agent = request.headers.get('User-Agent')

        # If no session data, then create new session data
        if session.get('FVID') is None:
            session['FVID'] = secrets.token_hex(32)
            session_id = session.get('FVID')

        # If user is clicking an outbound link, track this instead out /outboundLinks
        to_url = request.args.get('url', default=None, type=None) if base_url == request.url_root + 'outboundLinks' else base_url
        pv = userPageView(session_id = session_id, from_page = referrer_url, to_page = to_url, user_id = user_id, user_agent = user_agent)
        if track_pageviews:
            db.session.add(pv)
            db.session.commit()
        else:
            print(pv)
        x = func(**kwargs)
        return x

 def with_group_checking(self, message):
     if message.chat.id < 0:
         self.bot.sendMessage(
             chat_id=message.chat.id, text="這個功能沒辦法在聊天室使用，請跟我私聊。", reply_to_message_id=message.message_id
         )
         return
     return func(self, message)

 def wrapper(*args, **kwargs):
     if not 'uid' in session:
         abort(403)
     user = request.user = User.query.filter_by(name=session['uid']).first()
     if getattr(Perms, kwargs.get(request.method, defaccess_or_fn)) not in user.role:
         abort(403)
     return func(*args, **kwargs)

 def _execute_async_action(self, func, *args):
     self.log.info('Scheduling syncback action', func=func, args=args)
     g = gevent.Greenlet(retry_with_logging, lambda: func(*args),
                         logger=self.log)
     g.link_value(lambda _: self.log.info('Syncback action completed',
                                          func=func, args=args))
     self.worker_pool.start(g)

    def run_hash():
        # Timestamp is the key
        # Because it is better than pure integers
        now = datetime.datetime.now()
        # Generate salt
        salt = os.urandom(1024)
        salt = base64.b64encode(salt)
        # The final key
        combination = str(now) + str(salt)

        # Use corresponding algorithm for specified required length
        # Provides better hash and avoid collisions
        if length == 32:
            func = hashlib.md5
        elif length == 40:
            func = hashlib.sha1
        elif length == 56:
            func = hashlib.sha224
        elif length == 64:
            func = hashlib.sha256
        elif length == 96:
            func = hashlib.sha384
        else:
            func = hashlib.sha512
        hashid = func(combination).hexdigest()
        return unicode(hashid[:length])

 def inner(env, *a, **kw):
     key = env.request.full_path
     value = cache.get(key)
     if value is None:
         value = func(env, *a, **kw)
         cache.set(key, value, timeout=timeout)
     return value

 def _(user_obj, *args, **kwargs):
     if not user_obj.is_active:
         return False
     elif user_obj.is_superuser:
         return True
     else:
         return func(user_obj, *args, **kwargs)

 def get_user_list_info(self, listof_screen_name=None, listof_user_id=None, **kwargs):
     process_name = "/users/show/:id"
     try:
         user_list = list()
         if listof_screen_name is None:
             for item in listof_user_id:
                 user_id = self.get_user_info(user_id=item)[0]
                 user_list.append(user_id)
         elif listof_user_id is None:
             raise Exception('Unknown Input')
         else:
             for item in listof_screen_name:
                 user_id = self.get_user_info(screen_name=item)[0]
                 user_list.append(user_id)
     except TwitterError as e:
         """ Error처리는 다른 함수와 동일
         """
         sess = Session()
         t = TweetErrorHandler(e)
         t.add_handler(ErrorNumbers.RATE_LIMIT_ERROR, self.rate_limit_handler)
         result = t.invoke(process_name=process_name)
         sess.commit()
         sess.close()
         return result 
     return func(self, user_list, **kwargs)

 def wrapper(*args, **kwargs):
     if not "user_id" in flask.session:
         flask.flash("Sorry, you are not allowed to do that. "
                     "Please log in first.")
         flask.session["real_url"] = flask.request.url
         return flask.redirect(flask.url_for("login"))
     return func(*args, **kwargs)

 def wrapper(*args, **kwargs):
     result = json.dumps(func(*args, **kwargs) or {"error": "No data found for your request"},
                         default=serialize_to_json)
     headers = [
         ("Content-Type", "application/json"),
         ("Content-Length", str(len(result)))
     ]
     return Response(result, status=200, headers=headers)

 def wrapper(*args, **kwargs):
     html = func(*args, **kwargs)
     if request.args.get('download'):
         page = kwargs.get('page')
         dataset_id = kwargs.get('dataset_id')
         report_name = get_report_name(page, dataset_id)
         return get_excel_document(html, report_name)
     return html