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_methods = aslist(allowed_request_methods) return Proxy(address, allowed_request_methods=allowed_request_methods)
|
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_methods = aslist(allowed_request_methods) return Proxy(address, allowed_request_methods=allowed_request_methods)
|
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 HTTP Basic logins, passing a 401 to the user. If false, we'll use form logins with Cookie authentication. http_realm: The realm to use. If http_overwrite_realm is true then we will force this to be the realm (even if the application supplies its own realm). http_and_cookie: If true, we'll give the user a login cookie even if they use HTTP. Then we don't have to throw a 401 on every page to get them to re-login. cookie_prefix: Used before all cookie names; like a domain. login_page: If using cookie login and we get a 401, we'll turn it into a 200 and do an internal redirect to this page (using recursive). logout_page: Ditto the logout (logout will at some point be triggered with another key we add to the environment). secret: We use this for signing cookies. We'll generate it automatically if it's not provided explicitly (set it explicitly to be sure it is stable). authenticator: When we do HTTP logins we need to tell if they are using the correct login immediately. See the Authenticator object for the framework of an implementation. When you require a login, return a 401 error. When a login has occurred, the logged-in username will be in REMOTE_USER. When the user is logged in, but denied access, use a 403 error (not a 401). It might be useful to have another middleware that wraps an application and returns a 401 error, based on parsing the URL. Currently, the login form, if used, is rendered at the URL requested by the user, instead of issuing an HTTP redirect. This will require some attention to caching issues, but allows forms to be POSTed without losing data after the login (as long as the login page contains the appropriate hidden fields.) Also, the cookie is not deleted on an unsuccessful login attempt. The cookie is issued with path '/' and no expiration date. This should probably be overridable. Environment variables used: paste.login.signer: signer, created from UsernameSigner class paste.login._dologin: user name to be logged in, either from HTTP auth or from form submission (XXX form not implement) paste.login._doredirect: login page to which to redirect paste.login._loginredirect: set to True iff _doredirect set and login_page is relative, else undefined. Used where? """ http_login = converters.asbool(http_login) http_overwrite_realm = converters.asbool(http_overwrite_realm) http_and_cookie = converters.asbool(http_and_cookie) if authenticator and isinstance(authenticator, (str, unicode)): authenticator = import_string.eval_import(authenticator) if http_login: assert authenticator, ( "You must provide an authenticator argument if you " "are using http_login") if secret is None: secret = global_conf.get('secret') if secret is None: secret = create_secret() cookie_name = cookie_prefix + '_login_auth' signer = UsernameSigner(secret) def login_application(environ, start_response): orig_script_name = environ['SCRIPT_NAME'] orig_path_info = environ['PATH_INFO'] cookies = wsgilib.get_cookies(environ) cookie = cookies.get(cookie_name) username = None environ['paste.login.signer'] = signer if cookie and cookie.value: username = signer.check_signature( cookie.value, environ['wsgi.errors']) authenticatee = ( environ.get('HTTP_AUTHORIZATION') or environ.get('HTTP_CGI_AUTHORIZATION')) if (not username and authenticator and authenticatee): username = authenticator().check_basic_auth(authenticatee) if http_and_cookie: environ['paste.login._dologin'] = username if username: environ['REMOTE_USER'] = username def login_start_response(status, headers, exc_info=None): if environ.get('paste.login._dologin'): cookie = SimpleCookie(cookie_name, signer.make_signature(username), '/') headers.append(('Set-Cookie', str(cookie))) del environ['paste.login._dologin'] status_int = int(status.split(None, 1)[0].strip()) if status_int == 401 and http_login: if (http_overwrite_realm or not wsgilib.has_header(headers, 'www-authenticate')): headers.append(('WWW-Authenticate', 'Basic realm="%s"' % http_realm)) elif status_int == 401: status = '200 OK' if login_page.startswith('/'): assert environ.has_key('paste.recursive.include'), ( "You must use the recursive middleware to " "use a non-relative page for the login_page") environ['paste.login._doredirect'] = login_page return garbage_writer return start_response(status, headers, exc_info) app_iter = application(environ, login_start_response) if environ.get('paste.login._doredirect'): page_name = environ['paste.login._doredirect'] del environ['paste.login._doredirect'] eat_app_iter(app_iter) if login_page.startswith('/'): app_iter = environ['paste.recursive.forward']( login_page[1:]) else: # Don't use recursive, since login page is # internal to new_environ = environ.copy() new_environ['SCRIPT_NAME'] = orig_script_name new_environ['PATH_INFO'] = '/' + login_page new_environ['paste.login._loginredirect'] = True app_iter = login_application(new_environ, start_response) return app_iter return login_application
|
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(('content-length',stat.st_size))
|
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 not results: return '' return ", ".join([str(v).strip() for v in results])
|
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 elif headers_set: # You cannot set the headers more than once, unless the # exc_info is provided. raise AssertionError("Headers already set and no exc_info!") headers_set.append(True) data['status'] = status data['headers'] = headers return output.append
|
|
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(), method_name) result = method(*json_req['params']) json_res = {'id': req_id, 'result': result, 'error': None} json_res = objToJson(json_res) except Exception, e: if isinstance(e, httpexceptions.HTTPException): raise out = StringIO() traceback.print_exc(file=out) json_res = {'id': req_id, 'result': None, 'error': out.getvalue()} json_res = objToJon(json_res) self.servlet().response().write(json_res) self.servlet().setView(None)
|
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(), method_name) result = method(*json_req['params']) json_res = {'id': req_id, 'result': result, 'error': None} json_res = objToJson(json_res) except Exception, e: if isinstance(e, httpexceptions.HTTPException): raise out = StringIO() traceback.print_exc(file=out) json_res = {'id': req_id, 'result': None, 'error': out.getvalue()} json_res = objToJon(json_res) self.servlet().response().write(json_res) self.servlet().setView(None)
|
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.startswith('/'): lib = base_base + '/' + lib text = (r''' <script type="text/javascript" src="%(base)s/init.js"></script> <script type="text/javascript" src="%(base)s/lib/urllib.js"></script> <script type="text/javascript" src="%(base)s/lib/jsonrpc.js"></script> <script type="text/javascript" src="%(base)s/lib/lang.js"></script> <script type="text/javascript"> var jsonrpc = importModule('jsonrpc'); var servlet = jsonrpc.ServiceProxy(%(here)r, %(methods)r); </script> ''' % {'base': base, 'lib': lib, 'here': here, 'methods': self.jsonMethods()}) return text
|
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:] files.append((os.path.join(pref, path), l)) return files
|
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:] files.append((os.path.join(pref, path), l)) return files
|
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:] files.append((os.path.join(pref, path), l)) return files
|
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.__dict__.get('_default_object') if object: return object else: raise TypeError( "No object has been registered for this thread")
|
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.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.headeritems()) return [res] app = httpexceptions.middleware(application) app = simplecatcher(app) return app(environ, start_response)
|
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.headeritems()) return [res]
|
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('Debug %s no longer found (maybe it has expired?)' % debugcount) debug_info = self.debug_infos[debugcount] return func(self, debug_info=debug_info, **form) except ValueError, e: form['headers']['status'] = '500 Server Error' return '<html>There was an error: %s</html>' % e
|
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('Debug %s no longer found (maybe it has expired?)' % debugcount) debug_info = self.debug_infos[debugcount] return func(self, debug_info=debug_info, **form) except ValueError, e: form['headers']['status'] = '500 Server Error' return '<html>There was an error: %s</html>' % e
|
"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, base_path, base_path, counter))
|
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 = value[:100] + '<span style="background-color: #999">...</span>' value = formatter.make_wrappable(value) if i % 2: attr = ' class="even"' else: attr = ' class="odd"' rows.append('<tr%s style="vertical-align: top;"><td><b>%s</b></td><td style="overflow: auto">%s<td></tr>' % (attr, html_quote(name), preserve_whitespace(value, quote=False))) return '<table>%s</table>' % ( '\n'.join(rows))
|
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 = value[:100] + '<span style="background-color: #999">...</span>' value = formatter.make_wrappable(value) if i % 2: attr = ' class="even"' else: attr = ' class="odd"' rows.append('<tr%s style="vertical-align: top;"><td><b>%s</b></td><td style="overflow: auto">%s<td></tr>' % (attr, html_quote(name), preserve_whitespace(value, quote=False))) return '<table>%s</table>' % ( '\n'.join(rows))
|
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 methods supported: getall(key) Returns a list keyed by parameter location of all the values by that key in that parameter location getone(key) Return one value (like __getitem__) but an error if more than one key exists. (Or the other way around?) The object returned by .get and .post is a dictionary of this style as well. .urlvars is a plain dict (?) Should this decode input to unicode on some level? """ pass
|
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 fget(self): pms = MultiDict() pms.update(self.post) pms.update(self.get) return pms fget = LazyCache(fget) return locals() params = property(**params())
|
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 methods supported: getall(key) Returns a list keyed by parameter location of all the values by that key in that parameter location getone(key) Return one value (like __getitem__) but an error if more than one key exists. (Or the other way around?) The object returned by .get and .post is a dictionary of this style as well. .urlvars is a plain dict (?) Should this decode input to unicode on some level? """ pass
|
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_directory = directory self.cache_max_age = cache_max_age
|
|
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 if '?' in url: url, environ['QUERY_STRING'] = url.split('?', 1) req = TestRequest(url, environ) return self.do_request(req, status=status)
|
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 if '?' in url: url, environ['QUERY_STRING'] = url.split('?', 1) req = TestRequest(url, environ) return self.do_request(req, status=status)
|
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) environ['CONTENT_TYPE'] = content_type environ['CONTENT_LENGTH'] = str(len(params)) environ['REQUEST_METHOD'] = 'POST' environ['wsgi.input'] = StringIO(params) for header, value in headers.items(): environ['HTTP_%s' % header.replace('-', '_').upper()] = value req = TestRequest(url, environ) return self.do_request(req, status=status)
|
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) environ['CONTENT_TYPE'] = content_type environ['CONTENT_LENGTH'] = str(len(params)) environ['REQUEST_METHOD'] = 'POST' environ['wsgi.input'] = StringIO(params) for header, value in headers.items(): environ['HTTP_%s' % header.replace('-', '_').upper()] = value req = TestRequest(url, environ) return self.do_request(req, status=status)
|
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.raw_interactive(app, req.url, **req.environ) end_time = time.time() finally: sys.stdout = old_stdout sys.stderr.write(out.getvalue()) res = self.make_response(raw_res, end_time - start_time) res.request = req if self.namespace is not None: self.namespace['res'] = res self.check_status(status, res) self.check_errors(res) for header in res.all_headers('set-cookie'): c = SimpleCookie(header) for key, morsel in c.items(): self.cookies[key] = morsel.value if self.namespace is None: # It's annoying to return the response in doctests, as it'll # be printed, so we only return it is we couldn't assign # it anywhere return res
|
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.full_status, status))
|
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) else: formvars[name] = [formvars[name], value] elif all_as_list: 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, then GET (query string) variables will also be folded into the dictionary. All values should be strings, except for file uploads which are left as FieldStorage instances. """ source = (environ.get('QUERY_STRING', ''), environ['wsgi.input'], environ['REQUEST_METHOD'], all_as_list, include_get_vars) if 'paste.parsed_formvars' in environ: parsed, check_source = environ['paste.parsed_formvars'] if check_source == source: return parsed fs = cgi.FieldStorage(fp=environ['wsgi.input'], environ=environ, keep_blank_values=1) formvars = {} 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) else: formvars[name] = [formvars[name], value] elif all_as_list: formvars[name] = [value] else: formvars[name] = value if environ['REQUEST_METHOD'] == 'POST' and include_get_vars: for name, value in parse_querystring(environ): if name in formvars: if isinstance(formvars[name], list): formvars[name].append(value) else: formvars[name] = [formvars[name], value] elif all_as_list: formvars[name] = [value] else: formvars[name] = value environ['paste.parsed_formvars'] = (formvars, source) return formvars
|
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, then GET (query string) variables will also be folded into the dictionary. All values should be strings, except for file uploads which are left as FieldStorage instances. """ source = (environ.get('QUERY_STRING', ''), environ['wsgi.input'], environ['REQUEST_METHOD'], all_as_list, include_get_vars) if 'paste.parsed_formvars' in environ: parsed, check_source = environ['paste.parsed_formvars'] if check_source == source: return parsed fs = cgi.FieldStorage(fp=environ['wsgi.input'], environ=environ, keep_blank_values=1) formvars = {} 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) else: formvars[name] = [formvars[name], value] elif all_as_list: formvars[name] = [value] else: formvars[name] = value if environ['REQUEST_METHOD'] == 'POST' and include_get_vars: for name, value in parse_querystring(environ): if name in formvars: if isinstance(formvars[name], list): formvars[name].append(value) else: formvars[name] = [formvars[name], value] elif all_as_list: formvars[name] = [value] else: formvars[name] = value environ['paste.parsed_formvars'] = (formvars, source) return formvars
|
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></html>\n' % {'title': self.title, 'code': self.code, 'message': message})
|
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_words.append(word) return ' '.join(new_words)
|
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_words.append(word) return ' '.join(new_words)
|
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: headers.update(self.headers) if isinstance(content, unicode): content = content.encode('utf8') headers['content_type'] += '; charset=utf8' print "all good", environ, start_response start_response('%s %s' % (self.code, self.title), headers.items(), exc_info) return [content]
|
|
'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_info_pop(environ)) full = os.path.normpath(os.path.join(self.directory, filename)) if self.root_directory is not None and not full.startswith(self.root_directory): # Out of bounds return self.not_found(environ, start_response) if not os.path.exists(full): return self.not_found(environ, start_response) if os.path.isdir(full): # @@: Cache? child_root = self.root_directory is not None and \ self.root_directory or self.directory return self.__class__(full, root_directory=child_root)(environ, start_response) if environ.get('PATH_INFO') and environ.get('PATH_INFO') != '/': return self.error_extra_path(environ, start_response) if_none_match = environ.get('HTTP_IF_NONE_MATCH') if if_none_match: mytime = os.stat(full).st_mtime if str(mytime) == if_none_match: headers = [] ETAG.update(headers, mytime) start_response('304 Not Modified',headers) return [''] # empty body return fileapp.FileApp(full)(environ, start_response)
|
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_info_pop(environ)) full = os.path.normpath(os.path.join(self.directory, filename)) if self.root_directory is not None and not full.startswith(self.root_directory): # Out of bounds return self.not_found(environ, start_response) if not os.path.exists(full): return self.not_found(environ, start_response) if os.path.isdir(full): # @@: Cache? child_root = self.root_directory is not None and \ self.root_directory or self.directory return self.__class__(full, root_directory=child_root)(environ, start_response) if environ.get('PATH_INFO') and environ.get('PATH_INFO') != '/': return self.error_extra_path(environ, start_response) if_none_match = environ.get('HTTP_IF_NONE_MATCH') if if_none_match: mytime = os.stat(full).st_mtime if str(mytime) == if_none_match: headers = [] ETAG.update(headers, mytime) start_response('304 Not Modified',headers) return [''] # empty body return fileapp.FileApp(full)(environ, start_response)
|
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']) self.parsed_uri = urlparse.urlparse(path) self.query = dict(request.parse_querystring(environ)) path = self.parsed_uri[2] if path == '/' or not path: return self.render() elif path == '/verify': return self.do_verify() elif path == '/process': return self.do_process() else: return self.not_found() else: return self.app(environ, start_response)
|
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']) self.parsed_uri = urlparse.urlparse(path) self.query = dict(request.parse_querystring(environ)) path = self.parsed_uri[2] if path == '/' or not path: return self.render() elif path == '/verify': return self.do_verify() elif path == '/process': return self.do_process() else: return self.not_found() else: return self.app(environ, start_response)
|
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']) self.parsed_uri = urlparse.urlparse(path) self.query = dict(request.parse_querystring(environ)) path = self.parsed_uri[2] if path == '/' or not path: return self.render() elif path == '/verify': return self.do_verify() elif path == '/process': return self.do_process() else: return self.not_found() else: return self.app(environ, start_response)
|
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']) self.parsed_uri = urlparse.urlparse(path) self.query = dict(request.parse_querystring(environ)) path = self.parsed_uri[2] if path == '/' or not path: return self.render() elif path == '/verify': return self.do_verify() elif path == '/process': return self.do_process() else: return self.not_found() else: return self.app(environ, start_response)
|
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']) self.parsed_uri = urlparse.urlparse(path) self.query = dict(request.parse_querystring(environ)) path = self.parsed_uri[2] if path == '/' or not path: return self.render() elif path == '/verify': return self.do_verify() elif path == '/process': return self.do_process() else: return self.not_found() else: return self.app(environ, start_response)
|
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']) self.parsed_uri = urlparse.urlparse(path) self.query = dict(request.parse_querystring(environ)) path = self.parsed_uri[2] if path == '/' or not path: return self.render() elif path == '/verify': return self.do_verify() elif path == '/process': return self.do_process() else: return self.not_found() else: return self.app(environ, start_response)
|
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']) self.parsed_uri = urlparse.urlparse(path) self.query = dict(request.parse_querystring(environ)) path = self.parsed_uri[2] if path == '/' or not path: return self.render() elif path == '/verify': return self.do_verify() elif path == '/process': return self.do_process() else: return self.not_found() else: return self.app(environ, start_response)
|
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'): self.app_name = self.config['app_name'] self._cached_output = [] self.headers_out = { 'Content-type': 'text/html; charset=UTF-8'} self.status = '200 OK' self.cookies_out = {} self.request_method = environ['REQUEST_METHOD'].upper() self.app_url = self.environ.get('%s.base_url' % self.app_name, '') self.app_static_url = self.config.get( 'static_url', self.app_url + '/static') self.path_info = self.environ.get('PATH_INFO', '') if self.path_info: self.path_parts = filter(None, self.path_info[1:].split('/')) else: # Note that you have to look at self.path_info to # distinguish between '' and '/' self.path_parts = [] self.fields = cgifields.Fields(cgifields.parse_fields(environ)) self.run() headers = [] for name, value in self.headers_out.items(): if isinstance(value, list): for v in value: headers.append((name, v)) else: headers.append((name, value)) # @@: cookies start_response(self.status, headers) return self._cached_output
|
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 web context Use like:: import sys import paste import paste.error_middleware try: do stuff except: paste.error_middleware.exception_handler( sys.exc_info(), paste.CONFIG, sys.stderr, html=False) If you want to report, but not fully catch the exception, call ``raise`` after ``exception_handler``, which (when given no argument) will reraise the exception. """ reported = False exc_data = collector.collect_exception(*exc_info) extra_data = '' if error_email: rep = reporter.EmailReporter( to_addresses=error_email, from_address=error_email_from, smtp_server=smtp_server, subject_prefix=error_subject_prefix) rep_err = send_report(rep, exc_data, html=html) if rep_err: extra_data += rep_err else: reported = True if error_log: rep = reporter.LogReporter( filename=error_log) rep_err = send_report(rep, exc_data, html=html) if rep_err: extra_data += rep_err else: reported = True if show_exceptions_in_wsgi_errors: rep = reporter.FileReporter( file=error_stream) rep_err = send_report(rep, exc_data, html=html) if rep_err: extra_data += rep_err else: reported = True else: error_stream.write('Error - %s: %s\n' % ( exc_data.exception_type, exc_data.exception_value)) if html: if debug_mode and simple_html_error: return_error = formatter.format_html( exc_data, include_hidden_frames=False, include_reusable=False, show_extra_data=False) reported = True elif debug_mode and not simple_html_error: error_html = formatter.format_html( exc_data, include_hidden_frames=True, include_reusable=False) head_html = formatter.error_css + formatter.hide_display_js return_error = error_template( head_html, error_html, extra_data) extra_data = '' reported = True else: msg = error_message or ''' An error occurred. See the error logs for more information. (Turn debug on to display exception reports here) ''' return_error = error_template('', error_message, '') else: return_error = None if not reported and error_stream: err_report = formatter.format_text(exc_data, show_hidden_frames=True) err_report += '\n' + '-'*60 + '\n' error_stream.write(err_report) if extra_data: error_stream.write(extra_data) return return_error
|
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_exception(error) code = error self.catch_codes[code] = exc self.catch_exceptions.append(exc) self.catch_exceptions = tuple(self.catch_exceptions)
|
"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 starting select' % match.group(0)) in_select = None continue if tag == 'textarea' and end: assert in_textarea, ( "</textarea> with no <textarea> at %s" % match.start()) in_textarea[0].value = html_unquote(self.text[in_textarea[1]:match.start()]) in_textarea = None continue if end: continue attrs = _parse_attrs(match.group(3)) if 'name' in attrs: name = attrs.pop('name') else: name = None if tag == 'option': in_select.options.append((attrs.get('value'), 'selected' in attrs)) continue if tag == 'input' and attrs.get('type') == 'radio': field = self.fields.get(name) if not field: field = Radio(self, tag, name, match.start(), **attrs) fields.setdefault(name, []).append(field) else: field = field[0] assert isinstance(field, Radio) field.options.append((attrs.get('value'), 'checked' in attrs)) continue tag_type = tag if tag == 'input': tag_type = attrs.get('type', 'text').lower() FieldClass = Field.classes.get(tag_type, Field) field = FieldClass(self, tag, name, match.start(), **attrs) if tag == 'textarea': assert not in_textarea, ( "Nested textareas: %r and %r" % (in_textarea, match.group(0))) in_textarea = field, match.end() elif tag == 'select': assert not in_select, ( "Nested selects: %r and %r" % (in_select, match.group(0))) in_select = field fields.setdefault(name, []).append(field) self.fields = fields
|
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 resource has moved to %s - you should be redirected ' 'automatically.''' % url, headers=[('location', url)]) return exc.wsgi_application(environ, start_response)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.