rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
self.wfile.write('''\ | self.body.append('''\ | def pageHeader(self, title): """Render the page header""" self.wfile.write('''\ |
self.wfile.write('''\ | self.body.append('''\ | def pageFooter(self, form_contents): """Render the page footer""" if not form_contents: form_contents = '' |
def __init__(self, address, allowed_request_methods=()): | def __init__(self, address, allowed_request_methods=(), suppress_http_headers=()): | def __init__(self, address, allowed_request_methods=()): self.address = address self.parsed = urlparse.urlsplit(address) self.scheme = self.parsed[0].lower() self.host = self.parsed[1] self.path = self.parsed[2] self.allowed_request_methods = [ x.lower() for x in allowed_request_methods if x] |
if key == 'host': | if key == 'host' or key in self.suppress_http_headers: | def __call__(self, environ, start_response): if (self.allowed_request_methods and environ['REQUEST_METHOD'].lower() not in self.allowed_request_methods): return httpexceptions.HTTPBadRequest("Disallowed")(environ, start_response) |
def make_proxy(global_conf, address, allowed_request_methods=""): | def make_proxy(global_conf, address, allowed_request_methods="", suppress_http_headers=""): | def make_proxy(global_conf, address, allowed_request_methods=""): """ Make a WSGI application that proxies to another address -- 'address' should be the full URL ending with a trailing / 'allowed_request_methods' is a space seperated list of request methods """ from paste.deploy.converters import aslist allowed_request... |
return Proxy(address, allowed_request_methods=allowed_request_methods) | suppress_http_headers = aslist(suppress_http_headers) return Proxy( address, allowed_request_methods=allowed_request_methods, suppress_http_headers=suppress_http_headers) | def make_proxy(global_conf, address, allowed_request_methods=""): """ Make a WSGI application that proxies to another address -- 'address' should be the full URL ending with a trailing / 'allowed_request_methods' is a space seperated list of request methods """ from paste.deploy.converters import aslist allowed_request... |
self.applications.remove((app_url, url)) | self.applications.remove((app_url, app)) | def __delitem__(self, url): url = self.normalize_url(url) for app_url, app in self.applications: if app_url == url: self.applications.remove((app_url, url)) break else: raise KeyError( "No application with the url %r" % (url,)) |
global_conf, | global_conf=None, | def middleware( application, global_conf, http_login=False, http_realm='Secure Website', http_overwrite_realm=True, http_and_cookie=True, cookie_prefix='', login_page='_login/login_form', logout_page='_login/logout_form', secret=None, authenticator=None, ): """ Configuration: http_login: If true, then we'll prefer HTT... |
remote_header(self.headers,'content-length') | remove_header(self.headers,'content-length') | def update(self): stat = os.stat(self.filename) if stat.st_mtime == self.st_mtime: return self.st_mtime = stat.st_mtime if stat.st_size < CACHE_SIZE: fh = open(self.filename,"rb") self.set_content(fh.read()) fh.close() return self.content = None remote_header(self.headers,'content-length') self.headers.append(('conten... |
def __call__(self, *args, **kwargs): """ converts ``values()`` into a string value This method converts the results of ``values()`` into a string value for common usage. If more than one result are found; they are comma delimited as described by section 4.2 of RFC 2616. """ results = self.values(*args, **kwargs) if n... | def __call__(self, *args, **kwargs): """ converts ``values()`` into a string value | |
whole, may be cashed; this implementation does not support the enumeration of private fields | whole, may not be cashed; this implementation does not support the enumeration of private fields | def parse(self, *args, **kwargs): """ return the time value (in seconds since 1970) """ value = self.__call__(*args, **kwargs) if value: try: return mktime_tz(parsedate_tz(value)) except TypeError: raise HTTPBadRequest(( "Received an ill-formed timestamp for %s: %s\r\n") % (self.name, value)) |
else: print_exception(exc_info[0], exc_info[1], exc_info[2], file=errors) | def start_response(status, headers, exc_info=None): if exc_info: try: if headers_sent: # Re-raise original exception only if headers sent raise exc_info[0], exc_info[1], exc_info[2] else: print_exception(exc_info[0], exc_info[1], exc_info[2], file=errors) finally: # avoid dangling circular reference exc_info = None eli... | |
result = method(*json_req['params']) | result = method(*req_data['params']) | def jsonaction(self): request_body = self.servlet().request().rawInput().read() req_data = jsonToObj(request_body) req_id = req_data['id'] try: method_name = req_data['method'] if method_name not in self.jsonMethods(): raise HTTPForbidden( "The method %s is not public" % method_name) method = getattr(self.servlet(), me... |
json_res = objToJon(json_res) | json_res = objToJson(json_res) | def jsonaction(self): request_body = self.servlet().request().rawInput().read() req_data = jsonToObj(request_body) req_id = req_data['id'] try: method_name = req_data['method'] if method_name not in self.jsonMethods(): raise HTTPForbidden( "The method %s is not public" % method_name) method = getattr(self.servlet(), me... |
var servlet = jsonrpc.ServiceProxy(%(here)r, %(methods)r); | var servlet = new jsonrpc.ServiceProxy(%(here)r, %(methods)r); | def jsonjs(self): env = self.servlet().request().environ() base = self.jsolaitURL lib = self.libURL here = wsgilib.construct_url(env, False) here += '?_action_=jsonaction'; if self.baseConfig: base_base = env['%s.base_url' % self.baseConfig] if not base.startswith('/'): base = base_base + '/' + base if not lib.startswi... |
def get_data_files(path, files = []): l = [] for name in os.listdir(path): if name[0] == ".": | def get_data_files(relpath, files=None): files = files or [] for name in os.listdir(os.path.join(BASEDIR, relpath)): if name.startswith("."): | def get_data_files(path, files = []): l = [] for name in os.listdir(path): if name[0] == ".": continue relpath = os.path.join(path, name) f = os.path.join(BASEDIR, relpath) if os.path.isdir(f): get_data_files(relpath, files) elif os.path.isfile(f): l.append(f) pref = sysconfig.get_python_lib()[len(sysconfig.PREFIX) + 1... |
relpath = os.path.join(path, name) f = os.path.join(BASEDIR, relpath) if os.path.isdir(f): get_data_files(relpath, files) elif os.path.isfile(f): l.append(f) pref = sysconfig.get_python_lib()[len(sysconfig.PREFIX) + 1:] files.append((os.path.join(pref, path), l)) | fn = os.path.join(relpath, name) if os.path.isdir(os.path.join(BASEDIR, fn)): get_data_files(fn, files) elif os.path.isfile(os.path.join(BASEDIR, fn)): files.append(fn) | def get_data_files(path, files = []): l = [] for name in os.listdir(path): if name[0] == ".": continue relpath = os.path.join(path, name) f = os.path.join(BASEDIR, relpath) if os.path.isdir(f): get_data_files(relpath, files) elif os.path.isfile(f): l.append(f) pref = sysconfig.get_python_lib()[len(sysconfig.PREFIX) + 1... |
data_files=get_data_files(os.path.join("paste","app_templates")) + get_data_files(os.path.join("paste", "frameworks")) + [(os.path.join(sysconfig.get_python_lib()[len(sysconfig.PREFIX) + 1:], "paste"), [os.path.join("paste", "default_config.conf")])] | package_data={'paste': package_data}, | def get_data_files(path, files = []): l = [] for name in os.listdir(path): if name[0] == ".": continue relpath = os.path.join(path, name) f = os.path.join(BASEDIR, relpath) if os.path.isdir(f): get_data_files(relpath, files) elif os.path.isfile(f): l.append(f) pref = sysconfig.get_python_lib()[len(sysconfig.PREFIX) + 1... |
def __init__(self, default=None): | def __init__(self, default=None, name="Default"): | def __init__(self, default=None): """Create a new StackedObjectProxy If a default is given, its used in every thread if no other object has been pushed on. """ self.__dict__['local'] = threadinglocal.local() if default: self.__dict__['_default_object'] = default |
"No object has been registered for this thread") | "No object (Name: %s) has been registered for this \ thread" % self.__dict__['_name']) | def current_obj(self): """Returns the current active object being proxied to In the event that no object was pushed, the default object if provided will be used. Otherwise, a TypeError will be raised. """ objects = getattr(self.__dict__['local'], 'objects', None) if objects: return objects[-1] else: object = self.__d... |
def _repl_nbsp(match): if len(match.group(2)) == 1: return ' ' return match.group(1) + ' ' * (len(match.group(2))-1) + ' ' | def _repl_nbsp(match): if len(match.group(2)) == 1: return ' ' return match.group(1) + ' ' * (len(match.group(2))-1) + ' ' | |
% html_quote(out.getvalue())] | % html_quote(res)] | def simplecatcher_app(environ, start_response): try: return application(environ, start_response) except: out = StringIO() traceback.print_exc(file=out) start_response('500 Server Error', [('content-type', 'text/html')], sys.exc_info()) res = out.getvalue() return ['<h3>Error</h3><pre>%s</pre>' % html_quote(out.getvalue... |
def app_wrapper(*args): | def wsgiapp_wrapper(*args): | def app_wrapper(*args): # we get 3 args when this is a method, two when it is # a function :( if len(args) == 3: environ = args[1] start_response = args[2] args = [args[0]] else: environ, start_response = args args = [] def application(environ, start_response): form = wsgilib.parse_formvars(environ) headers = wsgilib.R... |
app_wrapper.exposed = True return app_wrapper | wsgiapp_wrapper.exposed = True return wsgiapp_wrapper | def application(environ, start_response): form = wsgilib.parse_formvars(environ) headers = wsgilib.ResponseHeaderDict( {'content-type': 'text/html', 'status': '200 OK'}) form['environ'] = environ form['headers'] = headers res = func(*args, **form) status = headers.pop('status') start_response(status, headers.headeritem... |
def replacement(self, **form): | def debug_info_replacement(self, **form): | def replacement(self, **form): try: if 'debugcount' not in form: raise ValueError('You must provide a debugcount parameter') debugcount = form.pop('debugcount') try: debugcount = int(debugcount) except ValueError: raise ValueError('Bad value for debugcount') if debugcount not in self.debug_infos: raise ValueError('Debu... |
return replacement | return debug_info_replacement | def replacement(self, **form): try: if 'debugcount' not in form: raise ValueError('You must provide a debugcount parameter') debugcount = form.pop('debugcount') try: debugcount = int(debugcount) except ValueError: raise ValueError('Bad value for debugcount') if debugcount not in self.debug_infos: raise ValueError('Debu... |
"The EvalException middleware is not usable in a multi-process environment") | "The EvalException middleware is not usable in a " "multi-process environment") | def __call__(self, environ, start_response): assert not environ['wsgi.multiprocess'], ( "The EvalException middleware is not usable in a multi-process environment") if environ.get('PATH_INFO', '').startswith('/_debug/'): return self.debug(environ, start_response) else: return self.respond(environ, start_response) |
return ('<script type="text/javascript" src="%s/_debug/mochikit/MochiKit.js"></script>\n' '<script type="text/javascript" src="%s/_debug/media/debug.js"></script>\n' '<script type="text/javascript">\n' 'debug_base = %r;\n' 'debug_count = %r;\n' '\n</script>\n' % (base_path, base_path, base_path, counter)) | base_path += '/_debug' return ( '<script type="text/javascript" src="%s/mochikit/MochiKit.js">' '</script>\n' '<script type="text/javascript" src="%s/media/debug.js">' '</script>\n' '<script type="text/javascript">\n' 'debug_base = %r;\n' 'debug_count = %r;\n' '</script>\n' % (base_path, base_path, base_path, counter)) | def eval_javascript(self, base_path, counter): return ('<script type="text/javascript" src="%s/_debug/mochikit/MochiKit.js"></script>\n' '<script type="text/javascript" src="%s/_debug/media/debug.js"></script>\n' '<script type="text/javascript">\n' 'debug_base = %r;\n' 'debug_count = %r;\n' '\n</script>\n' % (base_path... |
value = value[:100] + '<span style="background-color: | value = value[:100] value += '<span style="background-color: | def make_table(items): if isinstance(items, dict): items = items.items() items.sort() rows = [] i = 0 for name, value in items: i += 1 out = StringIO() pprint.pprint(value, out) value = html_quote(out.getvalue()) if len(value) > 100: # @@: This can actually break the HTML :( # should I truncate before quoting? value = ... |
rows.append('<tr%s style="vertical-align: top;"><td><b>%s</b></td><td style="overflow: auto">%s<td></tr>' | rows.append('<tr%s style="vertical-align: top;"><td>' '<b>%s</b></td><td style="overflow: auto">%s<td></tr>' | def make_table(items): if isinstance(items, dict): items = items.items() items.sort() rows = [] i = 0 for name, value in items: i += 1 out = StringIO() pprint.pprint(value, out) value = html_quote(out.getvalue()) if len(value) > 100: # @@: This can actually break the HTML :( # should I truncate before quoting? value = ... |
def params(self): """Uses cascading dict to pull from the params Return a key value from the parameters, they are checked in the following order: POST, GET, URL If a key is not found in the first dict, the next is checked. As with dict.get, None will be returned if the key is not found in all three. Additional metho... | def params(): doc = """\ MultiDict of keys from POST, GET, URL dicts Return a key value from the parameters, they are checked in the following order: POST, GET, URL Additional methods supported: getlist(key) Returns a list keyed by parameter location of all the values by that key in that parameter location""" def fg... | def params(self): """Uses cascading dict to pull from the params Return a key value from the parameters, they are checked in the following order: POST, GET, URL If a key is not found in the first dict, the next is checked. As with dict.get, None will be returned if the key is not found in all three. Additional metho... |
return self.environ.get('HTTP_X-Requested-With', '') == 'XMLHttpRequest' | return self.environ.get('HTTP_X_REQUESTED_WITH', '') == 'XMLHttpRequest' | def is_xhr(self): """Returns a boolean if X-Requested-With is present and a XMLHttpRequest""" return self.environ.get('HTTP_X-Requested-With', '') == 'XMLHttpRequest' |
if os.path.sep != '/': directory = directory.replace('/', os.path.sep) self.root_directory = self.root_directory.replace('/', os.path.sep) | def __init__(self, directory, root_directory=None, cache_max_age=None): if os.path.sep != '/': directory = directory.replace(os.path.sep, '/') self.directory = directory self.root_directory = root_directory if root_directory is not None: self.root_directory = os.path.normpath(self.root_directory) else: self.root_direct... | |
status=None): | status=None, expect_errors=False): | def get(self, url, params=None, headers={}, status=None): if params: if isinstance(params, dict): params = urllib.urlencode(params) if '?' in url: url += '&' else: url += '?' url += params environ = self.make_environ() for header, value in headers.items(): environ['HTTP_%s' % header.replace('-', '_').upper()] = value i... |
req = TestRequest(url, environ) | req = TestRequest(url, environ, expect_errors) | def get(self, url, params=None, headers={}, status=None): if params: if isinstance(params, dict): params = urllib.urlencode(params) if '?' in url: url += '&' else: url += '?' url += params environ = self.make_environ() for header, value in headers.items(): environ['HTTP_%s' % header.replace('-', '_').upper()] = value i... |
upload_files=None): | upload_files=None, expect_errors=False): | def post(self, url, params=None, headers={}, status=None, upload_files=None): environ = self.make_environ() if params and isinstance(params, dict): params = urllib.urlencode(params) if upload_files: params = cgi.parse_qsl(params, keep_blank_values=True) content_type, params = self.encode_multipart( params, upload_files... |
req = TestRequest(url, environ) | req = TestRequest(url, environ, expect_errors) | def post(self, url, params=None, headers={}, status=None, upload_files=None): environ = self.make_environ() if params and isinstance(params, dict): params = urllib.urlencode(params) if upload_files: params = cgi.parse_qsl(params, keep_blank_values=True) content_type, params = self.encode_multipart( params, upload_files... |
self.check_status(status, res) self.check_errors(res) | if not req.expect_errors: self.check_status(status, res) self.check_errors(res) | def do_request(self, req, status): if self.cookies: c = SimpleCookie() for name, value in self.cookies.items(): c[name] = value req.environ['HTTP_COOKIE'] = str(c).split(': ', 1)[1] app = lint.middleware(self.app) old_stdout = sys.stdout out = StringIO() try: sys.stdout = out start_time = time.time() raw_res = wsgilib.... |
if status != res.status_int: | if status != res.status: | def check_status(self, status, res): if status == '*': return if status is None: if res.status == 200 or ( res.status >= 300 and res.status < 400): return raise AppError( "Bad response: %s (not 200 OK or 3xx redirect)" % res.full_status) if status != res.status_int: raise AppError( "Bad response: %s (not %s)" % (res.fu... |
def __init__(self, url, environ): | def __init__(self, url, environ, expect_errors=False): | def __init__(self, url, environ): self.url = url self.environ = environ if environ.get('QUERY_STRING'): self.full_url = url + '?' + environ['QUERY_STRING'] else: self.full_url = url |
self.expect_errors = expect_errors | def __init__(self, url, environ): self.url = url self.environ = environ if environ.get('QUERY_STRING'): self.full_url = url + '?' + environ['QUERY_STRING'] else: self.full_url = url | |
for name in fs.keys(): values = fs[name] if not isinstance(values, list): values = [values] for value in values: if not value.filename: value = value.value if name in formvars: if isinstance(formvars[name], list): formvars[name].append(value) | if not isinstance(fs.value, list): formvars['__body__'] = fs.value else: for name in fs.keys(): values = fs[name] if not isinstance(values, list): values = [values] for value in values: if not value.filename: value = value.value if name in formvars: if isinstance(formvars[name], list): formvars[name].append(value) el... | def parse_formvars(environ, all_as_list=False, include_get_vars=True): """Parses the request, returning a dictionary of the keys. If ``all_as_list`` is true, then all values will be lists. If not, then only values that show up multiple times will be lists. If ``include_get_vars`` is true and this was a POST request,... |
formvars[name] = [formvars[name], value] elif all_as_list: formvars[name] = [value] else: formvars[name] = value | formvars[name] = value | def parse_formvars(environ, all_as_list=False, include_get_vars=True): """Parses the request, returning a dictionary of the keys. If ``all_as_list`` is true, then all values will be lists. If not, then only values that show up multiple times will be lists. If ``include_get_vars`` is true and this was a POST request,... |
environ.update(self.headers) | args.update(self.headers) | def html(self, environ): message = self.message args = environ.copy() if self.headers: environ.update(self.headers) message = message % args return ('<html><head><title>%(title)s</title></head>\n' '<body>\n' '<h1>%(title)s</h1>\n' '<p>%(message)s</p>\n' '<hr noshade>\n' '<div align="right">WSGI server</div>\n' '</body>... |
getlist(key) | ``getlist(key)`` | def params(self): """MultiDict of keys from POST, GET, URL dicts |
def make_wrappable(self, html, wrap_limit=50, | def make_wrappable(self, html, wrap_limit=60, | def make_wrappable(self, html, wrap_limit=50, split_on=';?&@!$#-/\\"\''): # Currently using <wbr>, maybe should use ​ # http://www.cs.tut.fi/~jkorpela/html/nobr.html words = html.split() new_words = [] for word in words: for char in split_on: if char in word: word = word.replace(char, char+'<wbr>') break new_wo... |
for char in split_on: if char in word: word = word.replace(char, char+'<wbr>') break new_words.append(word) | if len(word) > wrap_limit: for char in split_on: if char in word: words = [ self.make_wrappable(w, wrap_limit=wrap_limit, split_on=split_on) for w in word.split(char, 1)] new_words.append('<wbr>'.join(words)) break else: new_words.append(word) | def make_wrappable(self, html, wrap_limit=50, split_on=';?&@!$#-/\\"\''): # Currently using <wbr>, maybe should use ​ # http://www.cs.tut.fi/~jkorpela/html/nobr.html words = html.split() new_words = [] for word in words: for char in split_on: if char in word: word = word.replace(char, char+'<wbr>') break new_wo... |
if headers is None: headers = {} | def get(self, url, params=None, headers=None, extra_environ=None, status=None, expect_errors=False): """ Get the given url (well, actually a path like ``'/page.html'``). | |
for header, value in headers.items(): if header.lower() == 'content-type': var = 'CONTENT_TYPE' elif header.lower() == 'content-length': var = 'CONTENT_LENGTH' else: var = 'HTTP_%s' % header.replace('-', '_').upper() environ[var] = value | def get(self, url, params=None, headers=None, extra_environ=None, status=None, expect_errors=False): """ Get the given url (well, actually a path like ``'/page.html'``). | |
for header, value in headers.items(): environ['HTTP_%s' % header.replace('-', '_').upper()] = value | self._set_headers(headers, environ) | def post(self, url, params='', headers=None, extra_environ=None, status=None, upload_files=None, expect_errors=False): """ Do a POST request. Very like the ``.get()`` method. ``params`` are put in the body of the request. |
name = [] result = self.name.lower() | result = [] name = self.name.lower() | def values(self, *args, **kwargs): """ find/construct field-value(s) for the given header |
print "all good", environ, start_response | def wsgi_application(self, environ, start_response, exc_info=None): """ This exception as a WSGI application """ if 'html' in environ.get('HTTP_ACCEPT',''): headers = {'content-type': 'text/html'} content = self.html(environ) else: headers = {'content-type': 'text/plain'} content = self.plain(environ) if self.headers: ... | |
'HTTPExceptionHandler instead', | 'make_middleware or HTTPExceptionHandler instead', | def middleware(*args, **kw): import warnings # deprecated 13 dec 2005 warnings.warn('httpexceptions.middleware is deprecated; use ' 'HTTPExceptionHandler instead', DeprecationWarning, 1) return HTTPExceptionHandler(*args, **kw) |
return HTTPExceptionHandler(*args, **kw) | return make_middleware(*args, **kw) | def middleware(*args, **kw): import warnings # deprecated 13 dec 2005 warnings.warn('httpexceptions.middleware is deprecated; use ' 'HTTPExceptionHandler instead', DeprecationWarning, 1) return HTTPExceptionHandler(*args, **kw) |
def __init__(self, directory, root_directory=None): | def __init__(self, directory, root_directory=None, cache_max_age=None): | def __init__(self, directory, root_directory=None): if os.path.sep != '/': directory = directory.replace(os.path.sep, '/') self.directory = directory self.root_directory = root_directory if root_directory is not None: self.root_directory = os.path.normpath(self.root_directory) |
self.cache_max_age = cache_max_age | def __init__(self, directory, root_directory=None): if os.path.sep != '/': directory = directory.replace(os.path.sep, '/') self.directory = directory self.root_directory = root_directory if root_directory is not None: self.root_directory = os.path.normpath(self.root_directory) | |
return self.__class__(full, root_directory=child_root)(environ, | return self.__class__(full, root_directory=child_root, cache_max_age=self.cache_max_age)(environ, | def __call__(self, environ, start_response): path_info = environ.get('PATH_INFO', '') if not path_info: return self.add_slash(environ, start_response) if path_info == '/': # @@: This should obviously be configurable filename = 'index.html' else: # Handle quoted chars (e.g. %20) filename = urllib.unquote(request.path_in... |
return fileapp.FileApp(full)(environ, start_response) | fa = fileapp.FileApp(full) if self.cache_max_age: fa.cache_control(max_age=self.cache_max_age) return fa(environ, start_response) | def __call__(self, environ, start_response): path_info = environ.get('PATH_INFO', '') if not path_info: return self.add_slash(environ, start_response) if path_info == '/': # @@: This should obviously be configurable filename = 'index.html' else: # Handle quoted chars (e.g. %20) filename = urllib.unquote(request.path_in... |
def make_static(global_conf, document_root): | def make_static(global_conf, document_root, cache_max_age=None): | def make_static(global_conf, document_root): """ Return a WSGI application that serves a directory (configured with document_root) """ return StaticURLParser(document_root) |
""" return StaticURLParser(document_root) | max_cache_age - integer specifies CACHE_CONTROL max_age in seconds """ if cache_max_age is not None: cache_max_age = int(cache_max_age) return StaticURLParser(document_root, **kw) | def make_static(global_conf, document_root): """ Return a WSGI application that serves a directory (configured with document_root) """ return StaticURLParser(document_root) |
self.add(key, value) | self.add(name, value) | def fromlist(cls, seq): self = cls() for name, value in seq: self.add(key, value) return self |
self.render(request, message, css_class='error', form_contents=openid_url) | return self.render(request, message, css_class='error', form_contents=openid_url) | def do_verify(self, request): """Process the form submission, initating OpenID verification. """ |
self.environ = environ self.start = start_response self.body = [] self.base_url = request.construct_url(environ, with_path_info=False, | request = dict(environ=environ, start=start_response, body=[]) request['base_url'] = paste.request.construct_url(environ, with_path_info=False, | def __call__(self, environ, start_response): if environ['PATH_INFO'].startswith(self.auth_prefix): self.environ = environ self.start = start_response self.body = [] self.base_url = request.construct_url(environ, with_path_info=False, with_query_string=False) path = re.sub(self.auth_prefix, '', environ['PATH_INFO']) se... |
self.parsed_uri = urlparse.urlparse(path) self.query = dict(request.parse_querystring(environ)) | request['parsed_uri'] = urlparse.urlparse(path) request['query'] = dict(paste.request.parse_querystring(environ)) | def __call__(self, environ, start_response): if environ['PATH_INFO'].startswith(self.auth_prefix): self.environ = environ self.start = start_response self.body = [] self.base_url = request.construct_url(environ, with_path_info=False, with_query_string=False) path = re.sub(self.auth_prefix, '', environ['PATH_INFO']) se... |
path = self.parsed_uri[2] | path = request['parsed_uri'][2] | def __call__(self, environ, start_response): if environ['PATH_INFO'].startswith(self.auth_prefix): self.environ = environ self.start = start_response self.body = [] self.base_url = request.construct_url(environ, with_path_info=False, with_query_string=False) path = re.sub(self.auth_prefix, '', environ['PATH_INFO']) se... |
return self.render() | return self.render(request) | def __call__(self, environ, start_response): if environ['PATH_INFO'].startswith(self.auth_prefix): self.environ = environ self.start = start_response self.body = [] self.base_url = request.construct_url(environ, with_path_info=False, with_query_string=False) path = re.sub(self.auth_prefix, '', environ['PATH_INFO']) se... |
return self.do_verify() | return self.do_verify(request) | def __call__(self, environ, start_response): if environ['PATH_INFO'].startswith(self.auth_prefix): self.environ = environ self.start = start_response self.body = [] self.base_url = request.construct_url(environ, with_path_info=False, with_query_string=False) path = re.sub(self.auth_prefix, '', environ['PATH_INFO']) se... |
return self.do_process() | return self.do_process(request) | def __call__(self, environ, start_response): if environ['PATH_INFO'].startswith(self.auth_prefix): self.environ = environ self.start = start_response self.body = [] self.base_url = request.construct_url(environ, with_path_info=False, with_query_string=False) path = re.sub(self.auth_prefix, '', environ['PATH_INFO']) se... |
return self.not_found() | return self.not_found(request) | def __call__(self, environ, start_response): if environ['PATH_INFO'].startswith(self.auth_prefix): self.environ = environ self.start = start_response self.body = [] self.base_url = request.construct_url(environ, with_path_info=False, with_query_string=False) path = re.sub(self.auth_prefix, '', environ['PATH_INFO']) se... |
def do_verify(self): | def do_verify(self, request): | def do_verify(self): """Process the form submission, initating OpenID verification. """ |
openid_url = self.query.get('openid_url') | openid_url = request['query'].get('openid_url') | def do_verify(self): """Process the form submission, initating OpenID verification. """ |
return self.render('Enter an identity URL to verify.', | return self.render(request, 'Enter an identity URL to verify.', | def do_verify(self): """Process the form submission, initating OpenID verification. """ |
self.render(message, css_class='error', form_contents=openid_url) | self.render(request, message, css_class='error', form_contents=openid_url) | def do_verify(self): """Process the form submission, initating OpenID verification. """ |
return_to = self.build_url('process', token=info.token) | return_to = self.build_url(request, 'process', token=info.token) | def do_verify(self): """Process the form submission, initating OpenID verification. """ |
info, return_to, trust_root=self.base_url) | info, return_to, trust_root=request['base_url']) | def do_verify(self): """Process the form submission, initating OpenID verification. """ |
return self.redirect(redirect_url) | return self.redirect(request, redirect_url) | def do_verify(self): """Process the form submission, initating OpenID verification. """ |
def do_process(self): | def do_process(self, request): | def do_process(self): """Handle the redirect from the OpenID server. """ oidconsumer = self.oidconsumer |
token = self.query.get('token', '') | token = request['query'].get('token', '') | def do_process(self): """Handle the redirect from the OpenID server. """ oidconsumer = self.oidconsumer |
status, info = oidconsumer.completeAuth(token, self.query) | status, info = oidconsumer.completeAuth(token, request['query']) | def do_process(self): """Handle the redirect from the OpenID server. """ oidconsumer = self.oidconsumer |
self.environ['paste.auth.open_id'] = openid_url self.environ['PATH_INFO'] = self.login_redirect return self.app(self.environ, self.start) | request['environ']['paste.auth.open_id'] = openid_url request['environ']['PATH_INFO'] = self.login_redirect return self.app(request['environ'], request['start']) | def do_process(self): """Handle the redirect from the OpenID server. """ oidconsumer = self.oidconsumer |
return self.render(message, css_class, openid_url) def build_url(self, action, **query): | return self.render(request, message, css_class, openid_url) def build_url(self, request, action, **query): | def do_process(self): """Handle the redirect from the OpenID server. """ oidconsumer = self.oidconsumer |
base = urlparse.urljoin(self.base_url, self.auth_prefix + '/' + action) | base = urlparse.urljoin(request['base_url'], self.auth_prefix + '/' + action) | def build_url(self, action, **query): """Build a URL relative to the server base_url, with the given query parameters added.""" base = urlparse.urljoin(self.base_url, self.auth_prefix + '/' + action) return appendArgs(base, query) |
def redirect(self, redirect_url): | def redirect(self, request, redirect_url): | def redirect(self, redirect_url): """Send a redirect response to the given URL to the browser.""" response_headers = [('Content-type', 'text/plain'), ('Location', redirect_url)] self.start('302 REDIRECT', response_headers) return ["Redirecting to %s" % redirect_url] |
self.start('302 REDIRECT', response_headers) | request['start']('302 REDIRECT', response_headers) | def redirect(self, redirect_url): """Send a redirect response to the given URL to the browser.""" response_headers = [('Content-type', 'text/plain'), ('Location', redirect_url)] self.start('302 REDIRECT', response_headers) return ["Redirecting to %s" % redirect_url] |
def not_found(self): | def not_found(self, request): | def not_found(self): """Render a page with a 404 return code and a message.""" fmt = 'The path <q>%s</q> was not understood by this server.' msg = fmt % (self.parsed_uri,) openid_url = self.query.get('openid_url') return self.render(msg, 'error', openid_url, status='404 Not Found') |
msg = fmt % (self.parsed_uri,) openid_url = self.query.get('openid_url') return self.render(msg, 'error', openid_url, status='404 Not Found') def render(self, message=None, css_class='alert', form_contents=None, | msg = fmt % (request['parsed_uri'],) openid_url = request['query'].get('openid_url') return self.render(request, msg, 'error', openid_url, status='404 Not Found') def render(self, request, message=None, css_class='alert', form_contents=None, | def not_found(self): """Render a page with a 404 return code and a message.""" fmt = 'The path <q>%s</q> was not understood by this server.' msg = fmt % (self.parsed_uri,) openid_url = self.query.get('openid_url') return self.render(msg, 'error', openid_url, status='404 Not Found') |
self.start(str(status), response_headers) self.page_header(title) | request['start'](str(status), response_headers) self.page_header(request, title) | def render(self, message=None, css_class='alert', form_contents=None, status='200 OK', title="Python OpenID Consumer"): """Render a page.""" response_headers = [('Content-type', 'text/html')] self.start(str(status), response_headers) |
self.body.append("<div class='%s'>" % (css_class,)) self.body.append(message) self.body.append("</div>") self.page_footer(form_contents) return self.body def page_header(self, title): | request['body'].append("<div class='%s'>" % (css_class,)) request['body'].append(message) request['body'].append("</div>") self.page_footer(request, form_contents) return request['body'] def page_header(self, request, title): | def render(self, message=None, css_class='alert', form_contents=None, status='200 OK', title="Python OpenID Consumer"): """Render a page.""" response_headers = [('Content-type', 'text/html')] self.start(str(status), response_headers) |
self.body.append('''\ | request['body'].append('''\ | def page_header(self, title): """Render the page header""" self.body.append('''\ |
def page_footer(self, form_contents): | def page_footer(self, request, form_contents): | def page_footer(self, form_contents): """Render the page footer""" if not form_contents: form_contents = '' |
self.body.append('''\ | request['body'].append('''\ | def page_footer(self, form_contents): """Render the page footer""" if not form_contents: form_contents = '' |
''' % (quoteattr(self.build_url('verify')), quoteattr(form_contents))) | ''' % (quoteattr(self.build_url(request, 'verify')), quoteattr(form_contents))) | def page_footer(self, form_contents): """Render the page footer""" if not form_contents: form_contents = '' |
'Content-type': 'text/html; charset=UTF-8'} | 'content-type': 'text/html; charset=UTF-8'} | def __call__(self, environ, start_response): value = event.raise_event('call', self, environ, start_response) if value is not event.Continue: status, headers, app_iter = value start_response(status, headers) return app_iter self.environ = environ self.config = self.environ['paste.config'] if self.config.get('app_name')... |
return self.__class__.__name__ | return self._title or self.__class__.__name__ | def title__get(self): return self.__class__.__name__ |
self.__dict__['title'] = value | self._title = value def html_title__get(self): return self._html_title or self.title def html_title__set(self, value): self._html_title = value | def title__set(self, value): # Get rid of the property: self.__dict__['title'] = value |
return_error = error_template('', error_message, '') | return_error = error_template('', msg, '') | def handle_exception(exc_info, error_stream, html=True, debug_mode=False, error_email=None, error_log=None, show_exceptions_in_wsgi_errors=False, error_email_from='errors@localhost', smtp_server='localhost', error_subject_prefix='', error_message=None, simple_html_error=False, ): """ For exception handling outside of a... |
error = int(error.split(None, 1)) | error = int(error.split(None, 1)[0]) | def __init__(self, applications, catch=(404,)): self.apps = applications self.catch_codes = {} self.catch_exceptions = [] for error in catch: if isinstance(error, str): error = int(error.split(None, 1)) if isinstance(error, httpexceptions.HTTPException): exc = error code = error.code else: exc = httpexceptions.get_exce... |
"http://belnet.dl.sourceforge.net/sourceforge/zpt/ZopePageTemplates-1.4.0.tgz") | "http://easynews.dl.sourceforge.net/sourceforge/zpt/ZopePageTemplates-1.4.0.tgz") | def installer(name): mkdirs(THIRD + "/" + name +"-files") cmd = '%s setup.py install -f --install-lib="%s/%s-files" --install-scripts="%s/%s-files/scripts" --no-compile' % (sys.executable, THIRD, name, THIRD, name) print cmd os.system(cmd) |
field = self.fields.get(name) | field = fields.get(name) | def _parse_fields(self): in_select = None in_textarea = None fields = {} for match in self._tag_re.finditer(self.text): end = match.group(1) == '/' tag = match.group(2).lower() if tag not in ('input', 'select', 'option', 'textarea', 'button'): continue if tag == 'select' and end: assert in_select, ( '%r without startin... |
headers=[('location', url)]) | headers={'location', url}) | def add_slash(self, environ, start_response): """ This happens when you try to get to a directory without a trailing / """ url = request.construct_url(environ, with_query_string=False) url += '/' if environ.get('QUERY_STRING'): url += '?' + environ['QUERY_STRING'] exc = httpexceptions.HTTPMovedPermanently( 'The resourc... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.