Python Map.bind_to_environ方法代码示例

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class Shortly(object):
    def __init__(self, config):
        self.redis = redis.Redis(config['redis_host'], config['redis_port'])
        template_path = os.path.join(os.path.dirname(__file__), 'templates')
        self.jinja_env = Environment(loader=FileSystemLoader(template_path), autoescape=True)
        self.url_map = Map([
            Rule('/', endpoint='new_url'), 
            Rule('/<short_id>', endpoint='follow_short_link'), 
            Rule('/<short_id>+',endpoint='short_link_details')
        ])

    def insert_url(self, url):
        short_id = self.redis.get('reverse-url:' + url)
        if short_id is not None:
            return short_id
        url_num = self.redis.incr('last-url-id')
        short_id = base36_encode(url_num)
        self.redis.set('url-target:' + short_id, url)
        self.redis.set('reverse-url:' + url, short_id)
        return short_id

    def render_template(self, template_name, **context):
        t = self.jinja_env.get_template(template_name)
        return Response(t.render(context), mimetype='text/html')

    def dispatch_request(self, request):
        adapter = self.url_map.bind_to_environ(request.environ)
        try:
            endpoint, values = adapter.match()
            return getattr(self, 'on_' + endpoint)(request, **values)
        except HTTPException, e:
            return e 

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class Server(object):

	def __init__(self, config):
		self.url_map = Map([
			Rule('/', endpoint='generate_buy_list'),
		])
		self.magic_set_library = Magic_Set_Library()
	
	def generate_buy_list(self, request):
		params = self._parse_query_string(request.query_string)
		boosters = []
		for magic_set, booster_count in params.iteritems():
			for i in range(int(booster_count)):
				boosters.append(self.magic_set_library.make_booster(magic_set))
		card_map = {}
		for booster in boosters:
			for card in booster:
				card_map[card] = card_map.get(card, 0) + 1
		ret_str = ""
		for card, count in sorted(card_map.iteritems(), key=lambda x:x[0]):
			ret_str += "%s %s\n" %(count, card.name)
		return Response(ret_str)
	
	def _parse_query_string(self, query_string):
		if not query_string:
			return {}
		return dict(map(lambda x:(x.split('=')[0], x.split('=')[1]), query_string.strip().split('&')))

	def dispatch_request(self, request):
		adapter = self.url_map.bind_to_environ(request.environ)
		try:
			endpoint, values = adapter.match()
			return getattr(self, endpoint)(request, **values)
		except HTTPException, e:
			return e

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
def test_external_building_with_port_bind_to_environ_wrong_servername():
    """Test external URL building with port number (map.bind_to_environ) with wrong server name raises ValueError"""
    map = Map([
        Rule('/', endpoint='index'),
    ])
    environ = create_environ('/', 'http://example.org:5000/')
    assert_raises(ValueError, lambda: map.bind_to_environ(environ, server_name="example.org"))

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class Shortly(object):

	def __init__(self, config):
		self.redis = redis.Redis(config['redis_host'], config['redis_port'])
		template_path = os.path.join(os.path.dirname(__file__), 'templates')
		self.jinja_env = Environment(loader=FileSystemLoader(template_path), 
										autoescape=True)
		self.url_map = Map([
			Rule('/', endpoint='new_url'),
			Rule('/<short_id>', endpoint='follow_short_link'),
			Rule('/<short_id>+', endpoint='short_link_details')
		])

	def __call__(self, environ, start_response):
		return self.wsgi_app(environ, start_response)

	def render_template(self, template_name, **context):
		t = self.jinja_env.get_template(template_name)
		return Response(t.render(context), mimetype='text/html')

	def dispatch_request(self, request):
		adapter = self.url_map.bind_to_environ(request.environ)
		try:
			endpoint, values = adapter.match()
			return getattr(self, 'on_' + endpoint)(request, **values)
		except HTTPException, e:
			return e

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class App(object):

    def __init__(self, name=__name__):
        modules = import_all_module(name)
        self.rules = []
        self.views = []
        for module in modules:
            for k, v in module.__dict__.items():
                if inspect.isclass(v) and issubclass(v, Resource)\
                        and v is not Resource:
                    self.rules.extend(v.rules)
                    if module not in self.views:
                        self.views.append(module)
        self.url_map = Map(self.rules)

    def dispatch_request(self, request):
        adapter = self.url_map.bind_to_environ(request.environ)
        endpoint, values = adapter.match()
        for view in self.views:
            if hasattr(view, endpoint):
                return getattr(view, endpoint)(request, endpoint, values)

    def __call__(self, environ, start_response):
        request = Request(environ)
        response = self.dispatch_request(request)
        return response(environ, start_response)

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class KeyProtectedApp(object):
    '''
    Base class for a WSGI-app with a GET paramter based auhtentication.
    '''
    @property
    def routing(self):
        '''
        Must return a dict like {'url':'endpoint'}
        '''
        raise NotImplementedError
    
    def __init__(self):
        self.url_map = Map(
            [Rule(k, endpoint=v) for k, v in self.routing.iteritems()])

    def dispatch_request(self, request):
        if not validate_key(request.args.get('key', '')):
            raise Forbidden
        endpoint, kw = self.url_map.bind_to_environ(request.environ).match()
        return getattr(self, endpoint)(request, **kw)

    def __call__(self, environ, start_response):
        request = Request(environ)
        try:
            response = self.dispatch_request(request)
        except HTTPException, e:
            response = e
        return response(environ, start_response)

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class App():
    def __init__(self, work_dir):
        self.work_dir = work_dir
        self.admin = adm_server.create_admin(self)
        self.task = None
        self.task_lock = Lock()
        self.users = {}
        self.roles = None
        self._busy = 0
        self.pid = os.getpid()
        self.task_server_modified = False
        self.task_client_modified = True
        self.under_maintenance = False
        self.work_dir = self.admin.work_dir
        self.jam_dir = os.path.dirname(jam.__file__)
        self.jam_version = jam.version()
        self.application_files = {
            '/': self.work_dir,
            '/jam/': self.jam_dir,
            '/static/': os.path.join(self.jam_dir, 'static'            )
        }
        self.fileserver = SharedDataMiddleware(None, self.application_files, cache_timeout=0.1)
        self.url_map = Map([
            Rule('/', endpoint='root_file'),
            Rule('/<file_name>', endpoint='root_file'),
            Rule('/js/<file_name>', endpoint='file'),
            Rule('/css/<file_name>', endpoint='file'),
            Rule('/jam/js/<file_name>', endpoint='file'),
            Rule('/jam/js/ace/<file_name>', endpoint='file'),
            Rule('/jam/css/<file_name>', endpoint='file'),
            Rule('/jam/img/<file_name>', endpoint='file'),
            Rule('/api', endpoint='api'),
            Rule('/upload', endpoint='upload')
        ])

    def get_task(self):
        if self.task is None:
            with self.task_lock:
                if self.task is None:
                    adm_server.create_task(self)
        return self.task

    def __call__(self, environ, start_response):
        return self.wsgi_app(environ, start_response)

    def wsgi_app(self, environ, start_response):
        request = Request(environ)
        adapter = self.url_map.bind_to_environ(request.environ)
        try:
            endpoint, values = adapter.match()
            if endpoint in ['file', 'root_file']:
                return self.serve_file(environ, start_response, endpoint, **values)
            elif endpoint in ['api', 'upload']:
                response = getattr(self, 'on_' + endpoint)(request, **values)
        except HTTPException, e:
            if peek_path_info(environ) == 'ext':
                response = self.on_ext(request)
            else:
                response = e
        return response(environ, start_response)

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class holla_base_app(object):


    """
        This Class provide a Response Obj as an alias of HTTP_Resp.Response
        Usage: Let get_resp obj return a Response obj, and you don't need to do anything else 
    """
    
    def __init__(self):
        self.Response = Response  # Just an alias of Response Class
        self.url_map = Map([])
        pass
        
    def route(self, url, methods = None):
        def decorator(callback):
            add_Route(url, callback, self.url_map, methods)
            return callback
        return decorator

    def get_resp(self, env):
        self.env = env
        adapter = self.url_map.bind_to_environ(self.env)
        try:
            endpoint, values = adapter.match()
            return Response(endpoint(**values))
        except NotFound, e:
            return Response(status = 404)
        except HTTPException, e:
            return Response(status = 500)

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class RpcServer(object):

        def __init__(self, callbacks=None, host='', port=8000, ):
            self.host = host
            self.port = port

            self.views = {'get_rpc': self.get_rpc,
                          'images': self.get_file,
                          'save_file': self.save_file,
                          'get_log' : self.get_log}

            self.url_map = Map([Rule('/', endpoint='get_rpc'),
                                Rule('/jsonrpc', endpoint='get_rpc'),
                                Rule('/images', endpoint='images'),
                                Rule('/upload', endpoint='save_file'),
                                Rule('/log', endpoint='get_log')])


            # add the method names and the handlers to the dispatcher methods.
            if callbacks:
                for keys in callbacks.keys():
                    dispatcher[keys] = callbacks[keys]

        def get_rpc(self, environ, request):
             response = JSONRPCResponseManager.handle(request.data, dispatcher)
             return Response(response.json, mimetype="application/json")

        def get_file(self, environ, request):
            try:
                file = open('images/'+request.query_string.decode(), 'rb')
            except Exception as e:
                debug_logger.debug("could not read file" + str(e))
                raise NotFound()
            return Response(wrap_file(environ, file), direct_passthrough=True)

        def save_file(self, environ, request):
            try:
                file = request.files['image']
                filename = 'images/'+request.form["btn_name"].strip('"')+".jpg"
                id = request.form['btn_id']
                txt = request.form['btn_text'].strip('"')
                file.save(filename)
                dispatcher['update_image'](id, txt, filename)
            except Exception:
                return NotFound()
            return Response("Ok")

        def get_log(self, environ, request):
            response = dispatcher['get_log_data']()
            return Response(response, mimetype="application/json")

        @responder
        def application(self, environ, start_response):
            request = Request(environ)
            urls = self.url_map.bind_to_environ(environ)
            return urls.dispatch(lambda e, v: self.views[e](environ, request, **v),
                         catch_http_exceptions=True)

        def start(self):
            self.app = run_simple(self.host, self.port, self.application)

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class NovoMapia(object):
    
    def __init__(self, config):
        template_path = os.path.join(os.path.dirname(__file__), 'templates')
        self.jinja_env = Environment(loader=FileSystemLoader(template_path),autoescape=True)
        self.url_map = Map([
            Rule('/', endpoint='index'),
            Rule('/index.html', endpoint='index'),
            Rule('/<source>', endpoint='index'),
            Rule('/json/<source>', endpoint='json'),
            Rule('/json/<source>/', endpoint='json'),
        ])
    
    def render_template(self, template_name, **context):
        t = self.jinja_env.get_template(template_name)
        return Response(t.render(context), mimetype='text/html')

    def dispatch_request(self, request):
        return Response('Hello World!')
        
    def dispatch_request(self, request):
        adapter = self.url_map.bind_to_environ(request.environ)
        try:
            endpoint, values = adapter.match()
            return getattr(self, 'on_' + endpoint)(request, **values)
        except HTTPException, e:
            return e

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class Cup(object):
    def __init__(self, with_static=True):
        if with_static:
            self.wsgi_app = SharedDataMiddleware(self.wsgi_app, {
                '/static':  os.path.join(os.path.dirname(__file__), 'static')
            })
        self.url_map = Map()
        self.views = {}

    def add_url_rule(self, url, endpt, func):
        self.url_map.add(Rule(url, endpoint=endpt))
        self.views[endpt] = func

    def getView(self, endpoint):
        return self.views[endpoint]
    
    def route(self, url):
        def decorator(func):
            self.add_url_rule(url, func.__name__, func)
            def decorated(*args, **kwargs):
                func(*args, **kwargs)
            return decorated
        return decorator

    def dispatch_request(self, request):
        adapter = self.url_map.bind_to_environ(request.environ)
        try:
            endpoint, values = adapter.match()
            data = self.getView(endpoint)(request, **values)
            return Response(data, mimetype="text/html")
        except HTTPException, e:
            print "e"
            return e

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
def application(environ, start_response):
    request = Request(environ)

    if os.path.exists(PATH):
        with open(PATH) as yaml:
            data = load(yaml)
    else:
        data = {}

    urls = {}

    for reference in data.get("references", []):
        urls[reference.get("alias")] = reference.get("url")

    url_map = Map([
        Rule('/<alias>', endpoint='shortener'),
    ])

    adapter = url_map.bind_to_environ(request.environ)

    endpoint, values = adapter.match()

    alias = values["alias"]

    if alias not in urls:
        raise NotFound()

    response = redirect(urls[alias])
    return response(environ, start_response)

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
def handle_url(aConfig, environ, session):
    def handle_index(environ, session):
        statuscode, mimetype, body = handle_static(
            aConfig, environ, aConfig["gConfig"]["applications"][app]["static"]["page"]["indexpage"]
        )
        return statuscode, mimetype, body

    statuscode, mimetype, body = 200, "text/json", "{}"
    app = aConfig["gConfig"]["wsgi"]["application"]
    urllist = []
    for key in aConfig["gConfig"]["applications"][app]["url_mapping"].keys():
        urllist.append(Rule(key, endpoint=aConfig["gConfig"]["applications"][app]["url_mapping"][key]))
    urlmap = Map(urllist, converters={"bool": BooleanConverter})
    urls = urlmap.bind_to_environ(environ)
    try:
        endpoint, args = urls.match()
        if endpoint == "handle_index":
            statuscode, mimetype, body = handle_index(environ, session)
        else:
            body = json.dumps({"result": u"access_deny"}, ensure_ascii=True, indent=4)

    # except HTTPException, e:
    except Exception as e:
        traceback.print_exc()
        body = json.dumps({"result": u"error:%s" % e.message}, ensure_ascii=True, indent=4)

    return statuscode, mimetype, body

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class NichtParasoup(object):

    # init webserver with routing
    def __init__(self):
        self.url_map = Map([
            Rule('/', endpoint='root'),
            Rule('/status', endpoint='cache_status'),
            Rule('/get', endpoint='cache_get'),
            Rule('/imagelist', endpoint='show_imagelist'),
            Rule('/blacklist', endpoint='show_blacklist'),
            Rule('/flush', endpoint='flush'),
            Rule('/reset', endpoint='reset'),
        ])

    # proxy call to the wsgi_app
    def __call__(self, environ, start_response):
        return self.wsgi_app(environ, start_response)

    # calculate the request and use the defined map to route
    def dispatch_request(self, request):
        adapter = self.url_map.bind_to_environ(request.environ)
        try:
            endpoint, values = adapter.match()
            return getattr(self, 'on_' + endpoint)(request, **values)
        except HTTPException as e:
            return e

    # the wsgi app itself
    def wsgi_app(self, environ, start_response):
        request = Request(environ)
        response = self.dispatch_request(request)
        return response(environ, start_response)

    # start page with js and scroll
    def on_root(self, request):
        return Response(tmpl.root, mimetype='text/html')

    # map function for print the status
    def on_cache_status(self, request):
        return Response(cache_status())

    # map function for getting an image url
    def on_cache_get(self, request):
        return Response(cache_get())

    # map function for showing blacklist
    def on_show_blacklist(self, request):
        return Response(show_blacklist())

    # map function for showing imagelist
    def on_show_imagelist(self, request):
        return Response(show_imagelist())

    # map function for flushing (deleting everything in cache)
    def on_flush(self, request):
        return Response(flush())

    # map function for resetting (deleting everythign in cache and blacklist)
    def on_reset(self, request):
        return Response(reset())

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class InputReqApp(object):
    def __init__(self):
        self.url_map = Map()
        self.url_map.add(Rule('/test/<path:url>', endpoint=self.direct_input_request))
        self.url_map.add(Rule('/test-postreq', endpoint=self.post_fullrequest))

    def direct_input_request(self, environ, url=''):
        inputreq = DirectWSGIInputRequest(environ)
        return inputreq.reconstruct_request(url)

    def post_fullrequest(self, environ):
        params = dict(parse_qsl(environ.get('QUERY_STRING', '')))
        inputreq = POSTInputRequest(environ)
        return inputreq.reconstruct_request(params['url'])

    def __call__(self, environ, start_response):
        urls = self.url_map.bind_to_environ(environ)
        try:
            endpoint, args = urls.match()
        except HTTPException as e:
            return e(environ, start_response)

        result = endpoint(environ, **args)
        start_response('200 OK', [('Content-Type', 'text/plain; charset=utf-8')])
        return [result]