def __call__(self, environ, start_response):
        request = Request(environ)
        lang = request.values.get('_lang')
        if lang is None:
            lang = (request.accept_languages.best or 'en').split('-')[0].lower()
        if not has_language(lang):
            lang = 'en'
        request.translations = load_translations(lang)
        request.translations.language = lang
        request.gettext = request.translations.gettext
        request.timezone = request.values.get('_timezone', 'UTC')
        response = None

        if request.path == '/':
            view = request.values.get('_current', 'start')
            if request.values.get('_startsetup'):
                response = self.start_setup(request)
            elif view in self.views:
                handler = self.views[view]
                if handler is not None and \
                   request.values.get('_next'):
                    ctx = handler(request)
                    if ctx is not None:
                        response = self.handle_view(request, view, ctx)

                if response is None:
                    if request.values.get('_next'):
                        view = self.next[view]
                    elif request.values.get('_prev'):
                        view = self.prev[view]
                    response = self.handle_view(request, view)

        if response is None:
            response = redirect('')
        return response(environ, start_response)

    def wsgi_app(self, environ, start_response):
        """Execute this instance as a WSGI application.

        See the PEP for the meaning of parameters. The separation of
        __call__ and wsgi_app eases the insertion of middlewares.

        """
        urls = self._url_map.bind_to_environ(environ)
        try:
            endpoint, args = urls.match()
        except HTTPException as exc:
            return exc

        assert endpoint == "get"

        request = Request(environ)
        request.encoding_errors = "strict"

        response = Response()

        result = dict()
        for task_type in self._task_types:
            result[task_type.__name__] = \
                list(p.describe() for p in task_type.ACCEPTED_PARAMETERS)

        response.status_code = 200
        response.mimetype = "application/json"
        response.data = json.dumps(result)

        return response

    def __init__(self, environ, app=None):
        RequestBase.__init__(self, environ)
        self.queries = []
        self.metanav = []
        self.navbar = []
        self.ctxnavbar = {}

        if app is None:
            app = get_application()
        self.app = app

        engine = self.app.database_engine

        # get the session and try to get the user object for this request.
        from ilog.database import db, User
        user = None
        cookie_name = app.cfg['cookie_name']
        session = SecureCookie.load_cookie(self, cookie_name, app.secret_key)
        user_id = session.get('uid')
        if user_id:
            user = User.query.options(
                db.eagerload('groups'), db.eagerload('groups', 'privileges')
            ).get(user_id)
        if user is None:
            self.locale = self.app.default_locale
            self.translations = self.app.default_translations
            user = User.query.get_nobody()
        else:
            self.locale = Locale(user.locale)
            self.translations = i18n.load_translations(self.locale)
        self.user = user
        self.user.update_last_login()
        db.commit()
        self.session = session

    def application(environ, start_response):
        # The WSGI server puts content length and type in the environment
        # even when not provided with the request. Drop them if they are empty.
        if environ.get('CONTENT_LENGTH') == '':
            del environ['CONTENT_LENGTH']
        if environ.get('CONTENT_TYPE') == '':
            del environ['CONTENT_TYPE']

        wrequest = WerkzeugRequest(environ)
        data = wrequest.get_data()
        request = Request(
            method=wrequest.method,
            url=wrequest.url,
            headers=wrequest.headers,
            data=data,
        )
        prepared = request.prepare()

        stream = streams.build_output_stream(
            args, env, prepared, response=None,
            output_options=args.output_options)
        streams.write_stream(stream, env.stdout, env.stdout_isatty)

        # When there is data in the request, give the next one breathing room.
        if data:
            print("\n", file=env.stdout)

        # Make dreams come true.
        response = Response(headers={'Server': server})
        return response(environ, start_response)

    def wsgi_app(self, environ, start_response):
        """Execute this instance as a WSGI application.

        See the PEP for the meaning of parameters. The separation of
        __call__ and wsgi_app eases the insertion of middlewares.

        """
        urls = self._url_map.bind_to_environ(environ)
        try:
            endpoint, args = urls.match()
        except HTTPException as exc:
            return exc

        assert endpoint == "rpc"

        response = Response()

        if self._auth is not None and not self._auth(environ):
            response.status_code = 403
            response.mimetype = "plain/text"
            response.data = "Request not allowed."
            return response

        request = Request(environ)
        request.encoding_errors = "strict"

        remote_service = ServiceCoord(args['service'], args['shard'])

        if remote_service not in self._service.remote_services:
            return NotFound()

        # TODO Check content_encoding and content_md5.

        if request.mimetype != "application/json":
            return UnsupportedMediaType()

        if request.accept_mimetypes.quality("application/json") <= 0:
            return NotAcceptable()

        try:
            data = json.load(request.stream, encoding='utf-8')
        except ValueError:
            return BadRequest()

        if not self._service.remote_services[remote_service].connected:
            return ServiceUnavailable()

        result = self._service.remote_services[remote_service].execute_rpc(
            args['method'], data)

        # XXX We could set a timeout on the .wait().
        result.wait()

        response.status_code = 200
        response.mimetype = "application/json"
        response.data = json.dumps({
            "data": result.value,
            "error": None if result.successful() else "%s" % result.exception})

        return response

def build_request_obj(query_strings):
    print(query_strings)
    builder = EnvironBuilder()      # query_string=)
    env = builder.get_environ()
    request = Request(env)
    request.args = MultiDict(query_strings.items())
    return request

    def wsgi_app(self, environ, start_response):
        route = self.router.bind_to_environ(environ)
        try:
            endpoint, args = route.match()
        except HTTPException as exc:
            return exc(environ, start_response)

        if endpoint == "events":
            return self.event_handler(environ, start_response)
        elif endpoint == "logo":
            return self.logo_handler(environ, start_response)
        elif endpoint == "root":
            return self.root_handler(environ, start_response)
        else:
            request = Request(environ)
            request.encoding_errors = "strict"

            response = Response()

            if endpoint == "sublist":
                SubListHandler(request, response, args["user_id"])
            elif endpoint == "scores":
                ScoreHandler(request, response)
            elif endpoint == "history":
                HistoryHandler(request, response)

            return response(environ, start_response)

    def call_backend(self, environ, start_response):
        request = Request(environ)

        # Compatibility with django, use request.args preferrably
        request.GET = request.args

        # By using fcgi, mediagoblin can run under a base path
        # like /mediagoblin/. request.path_info contains the
        # path inside mediagoblin. If the something needs the
        # full path of the current page, that should include
        # the basepath.
        # Note: urlgen and routes are fine!
        request.full_path = environ["SCRIPT_NAME"] + request.path
        # python-routes uses SCRIPT_NAME. So let's use that too.
        # The other option would be:
        # request.full_path = environ["SCRIPT_URL"]

        # Fix up environ for urlgen
        # See bug: https://bitbucket.org/bbangert/routes/issue/55/cache_hostinfo-breaks-on-https-off
        if environ.get('HTTPS', '').lower() == 'off':
            environ.pop('HTTPS')

        ## Attach utilities to the request object
        with self.gen_context(request) as request:
            return self._finish_call_backend(request, environ, start_response)

 def _load_form_data(self):
     BaseRequest._load_form_data(self)
     if (self.debug
             and self.mimetype != 'multipart/form-data'
             and not self.files):
         from .debughelpers import attach_enctype_error_multidict
         attach_enctype_error_multidict(self)

    def wsgi_app(self, environ, start_response):
        route = self.router.bind_to_environ(environ)
        try:
            endpoint, args = route.match()
        except HTTPException as exc:
            return exc(environ, start_response)

        assert endpoint == "sublist"

        request = Request(environ)
        request.encoding_errors = "strict"

        if request.accept_mimetypes.quality("application/json") <= 0:
            raise NotAcceptable()

        result = list()
        for task_id in self.task_store._store.keys():
            result.extend(
                self.scoring_store.get_submissions(
                    args["user_id"], task_id
                ).values()
            )
        result.sort(key=lambda x: (x.task, x.time))
        result = list(a.__dict__ for a in result)

        response = Response()
        response.status_code = 200
        response.mimetype = "application/json"
        response.data = json.dumps(result)

        return response(environ, start_response)

    def _load_from_data(self):
        RequestBase._load_from_data(self)

        context = _requestContextStack.top

        if context is not None and context.app.debug \
           and self.mimetype != 'multipart/form-data' and not self.files:
            attachEnctypeErrorMultidict(self)

    def wsgi_app(self, environ, start_response):
        request = Request(environ)
        sid = request.cookies.get("expSession")

        request.sessionid = sid

        response = self.dispatch_request(request)
        return response(environ, start_response)

    def _load_form_data(self):
        RequestBase._load_form_data(self)

        # in debug mode we're replacing the files multidict with an ad-hoc
        # subclass that raises a different error for key errors.
        ctx = _request_ctx_stack.top
        if ctx is not None and ctx.app.debug and self.mimetype != "multipart/form-data" and not self.files:
            attach_enctype_error_multidict(self)

    def wsgi_app(self, environ, start_response):
        """Execute this instance as a WSGI application.

        See the PEP for the meaning of parameters. The separation of
        __call__ and wsgi_app eases the insertion of middlewares.

        """
        urls = self._url_map.bind_to_environ(environ)
        try:
            endpoint, args = urls.match()
        except HTTPException as exc:
            return exc

        assert endpoint == "rpc"

        request = Request(environ)
        request.encoding_errors = "strict"

        response = Response()

        remote_service = ServiceCoord(args['service'], args['shard'])

        if remote_service not in self._service.remote_services:
            return NotFound()

        # TODO Check content_encoding and content_md5.

        if request.mimetype != "application/json":
            return UnsupportedMediaType()

        if request.accept_mimetypes.quality("application/json") <= 0:
            return NotAcceptable()

        try:
            data = json.load(request.stream, encoding='utf-8')
        except ValueError:
            return BadRequest()

        if not self._service.remote_services[remote_service].connected:
            return ServiceUnavailable()

        value = AsyncResult()

        @rpc_callback
        def callback(service, data, plus=None, error=None):
            value.set({'data': data, 'error': error})

        self._service.remote_services[remote_service].execute_rpc(
            args['method'], data, callback)

        response.status_code = 200
        response.mimetype = "application/json"
        # XXX We could set a timeout on the .get().
        response.data = json.dumps(value.get())

        return response

 def __init__(self, environ, url_map, session_store = None, cookie_name = None):
     RequestBase.__init__(self, environ)
     self.url_adapter = url_map.bind_to_environ(environ)
     self.session_store = session_store
     self.cookie_name = cookie_name
     if session_store is not None and cookie_name is not None:
         if cookie_name in self.cookies:
             self.session = session_store.get(self.cookies[cookie_name])
         else:
             self.session = session_store.new()

 def _request_signature(self, environ, digest):
     h = hmac.new(
         self._secret_key.encode('utf8'),
         self.string_to_sign(environ).encode('utf8'),
         digest,
     )
     request = Request(environ)
     if 'wsgi.input' in environ:
         h.update(request.get_data())
     return digest().name + ' ' + base64.b64encode(h.digest()).decode('utf8')

 def wsgi_app(self, environ, start_response):
     script_name = environ.get('HTTP_X_SCRIPT_NAME', '')
     if script_name:
         environ['SCRIPT_NAME'] = script_name
         path_info = environ['PATH_INFO']
         if path_info.startswith(script_name):
             environ['PATH_INFO'] = path_info[len(script_name):]
     request = Request(environ)
     request.app = self
     response = self.dispatch_request(request)
     return response(environ, start_response)

 def __call__(self, environ, start_response):
     request = Request(environ)
     try:
         name, args, kwargs = loads(request.get_data(cache=True))
         debug('calling function: "%s"', name)
         result = self.rpc()(name, *args, **kwargs)
         execution_error = None
     except Exception, e:
         execution_error = ErrorMessage.from_exception(e, address=request.host_url)
         result = None
         error('error: %s, traceback: \n%s', e, traceback.format_exc())

 def _wsgi_app(environ, start_response):
     rq = Request(environ)
     environ['werkzeug.request'] = None
     cx = rq.context = factory()
     try:
         rsp = handler(rq)
     finally:
         rq.close()
         if hasattr(cx, 'close'):
             cx.close()
     return rsp(environ, start_response)

    def _load_form_data(self):
        RequestBase._load_form_data(self)

        # In debug mode we're replacing the files multidict with an ad-hoc
        # subclass that raises a different error for key errors.
        if (
            current_app
            and current_app.debug
            and self.mimetype != 'multipart/form-data'
            and not self.files
        ):
            from .debughelpers import attach_enctype_error_multidict
            attach_enctype_error_multidict(self)