Gecko [ emad.team ]

Name	Size	Permission	Date
auth	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
cowbell	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
debug	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
evalexception	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
exceptions	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
util	[ DIR ]	drwxr-xr-x	2022-08-06 15:50
cascade.py	4.4 KB	-rw-r--r--	2011-12-21 20:42
cascade.pyc	4.23 KB	-rw-r--r--	2014-09-17 20:43
cascade.pyo	4.23 KB	-rw-r--r--	2014-09-17 20:43
cgiapp.py	9.37 KB	-rw-r--r--	2011-12-21 20:42
cgiapp.pyc	8.08 KB	-rw-r--r--	2014-09-17 20:43
cgiapp.pyo	7.87 KB	-rw-r--r--	2014-09-17 20:43
cgitb_catcher.py	3.66 KB	-rw-r--r--	2011-12-21 20:42
cgitb_catcher.pyc	3.64 KB	-rw-r--r--	2014-09-17 20:43
cgitb_catcher.pyo	3.64 KB	-rw-r--r--	2014-09-17 20:43
config.py	4.21 KB	-rw-r--r--	2011-12-21 20:42
config.pyc	4.99 KB	-rw-r--r--	2014-09-17 20:43
config.pyo	4.99 KB	-rw-r--r--	2014-09-17 20:43
errordocument.py	13.45 KB	-rw-r--r--	2011-12-21 20:42
errordocument.pyc	12.47 KB	-rw-r--r--	2014-09-17 20:43
errordocument.pyo	12.47 KB	-rw-r--r--	2014-09-17 20:43
fileapp.py	13.29 KB	-rw-r--r--	2011-12-21 20:42
fileapp.pyc	12.6 KB	-rw-r--r--	2014-09-17 20:43
fileapp.pyo	12.48 KB	-rw-r--r--	2014-09-17 20:43
fixture.py	56.63 KB	-rw-r--r--	2014-09-17 20:43
fixture.py.stdlib	56.71 KB	-rw-r--r--	2011-12-21 20:42
fixture.pyc	57.42 KB	-rw-r--r--	2014-09-17 20:43
fixture.pyo	55.18 KB	-rw-r--r--	2014-09-17 20:43
flup_session.py	3.85 KB	-rw-r--r--	2011-12-21 20:42
flup_session.pyc	3.77 KB	-rw-r--r--	2014-09-17 20:43
flup_session.pyo	3.77 KB	-rw-r--r--	2014-09-17 20:43
gzipper.py	3.61 KB	-rw-r--r--	2011-12-21 20:42
gzipper.pyc	4.28 KB	-rw-r--r--	2014-09-17 20:43
gzipper.pyo	4.28 KB	-rw-r--r--	2014-09-17 20:43
httpexceptions.py	23.65 KB	-rw-r--r--	2011-12-21 20:42
httpexceptions.pyc	26.94 KB	-rw-r--r--	2014-09-17 20:43
httpexceptions.pyo	26.2 KB	-rw-r--r--	2014-09-17 20:43
httpheaders.py	42.08 KB	-rw-r--r--	2011-12-21 20:42
httpheaders.pyc	43.1 KB	-rw-r--r--	2014-09-17 20:43
httpheaders.pyo	41.88 KB	-rw-r--r--	2014-09-17 20:43
httpserver.py	54.36 KB	-rw-r--r--	2011-12-21 20:42
httpserver.pyc	46.26 KB	-rw-r--r--	2014-09-17 20:43
httpserver.pyo	45.61 KB	-rw-r--r--	2014-09-17 20:43
lint.py	14.65 KB	-rw-r--r--	2011-12-21 20:42
lint.pyc	16.94 KB	-rw-r--r--	2014-09-17 20:43
lint.pyo	12.91 KB	-rw-r--r--	2014-09-17 20:43
modpython.py	7.79 KB	-rw-r--r--	2011-12-21 20:42
modpython.pyc	8.44 KB	-rw-r--r--	2014-09-17 20:43
modpython.pyo	8.44 KB	-rw-r--r--	2014-09-17 20:43
pony.py	2.23 KB	-rw-r--r--	2011-12-21 20:42
pony.pyc	2.62 KB	-rw-r--r--	2014-09-17 20:43
pony.pyo	2.62 KB	-rw-r--r--	2014-09-17 20:43
progress.py	7.97 KB	-rw-r--r--	2011-12-21 20:42
progress.pyc	8.93 KB	-rw-r--r--	2014-09-17 20:43
progress.pyo	8.93 KB	-rw-r--r--	2014-09-17 20:43
proxy.py	9.94 KB	-rw-r--r--	2011-12-21 20:42
proxy.pyc	8.33 KB	-rw-r--r--	2014-09-17 20:43
proxy.pyo	8.33 KB	-rw-r--r--	2014-09-17 20:43
recursive.py	14.32 KB	-rw-r--r--	2011-12-21 20:42
recursive.pyc	17.1 KB	-rw-r--r--	2014-09-17 20:43
recursive.pyo	16.79 KB	-rw-r--r--	2014-09-17 20:43
registry.py	21.67 KB	-rw-r--r--	2011-12-21 20:42
registry.pyc	21.76 KB	-rw-r--r--	2014-09-17 20:43
registry.pyo	21.76 KB	-rw-r--r--	2014-09-17 20:43
reloader.py	5.87 KB	-rw-r--r--	2011-12-21 20:42
reloader.pyc	5.82 KB	-rw-r--r--	2014-09-17 20:43
reloader.pyo	5.82 KB	-rw-r--r--	2014-09-17 20:43
request.py	13.81 KB	-rw-r--r--	2011-12-21 20:42
request.pyc	13.33 KB	-rw-r--r--	2014-09-17 20:43
request.pyo	13.24 KB	-rw-r--r--	2014-09-17 20:43
response.py	7.48 KB	-rw-r--r--	2011-12-21 20:42
response.pyc	8.9 KB	-rw-r--r--	2014-09-17 20:43
response.pyo	8.82 KB	-rw-r--r--	2014-09-17 20:43
session.py	11.07 KB	-rw-r--r--	2011-12-21 20:42
session.pyc	11.34 KB	-rw-r--r--	2014-09-17 20:43
session.pyo	11.34 KB	-rw-r--r--	2014-09-17 20:43
transaction.py	4.26 KB	-rw-r--r--	2011-12-21 20:42
transaction.pyc	5.49 KB	-rw-r--r--	2014-09-17 20:43
transaction.pyo	5.49 KB	-rw-r--r--	2014-09-17 20:43
translogger.py	4.7 KB	-rw-r--r--	2011-12-21 20:42
translogger.pyc	4.15 KB	-rw-r--r--	2014-09-17 20:43
translogger.pyo	4.15 KB	-rw-r--r--	2014-09-17 20:43
url.py	14.28 KB	-rw-r--r--	2011-12-21 20:42
url.pyc	17.29 KB	-rw-r--r--	2014-09-17 20:43
url.pyo	17.29 KB	-rw-r--r--	2014-09-17 20:43
urlmap.py	8.82 KB	-rw-r--r--	2011-12-21 20:42
urlmap.pyc	9.15 KB	-rw-r--r--	2014-09-17 20:43
urlmap.pyo	9.01 KB	-rw-r--r--	2014-09-17 20:43
urlparser.py	25.8 KB	-rw-r--r--	2011-12-21 20:42
urlparser.pyc	21.52 KB	-rw-r--r--	2014-09-17 20:43
urlparser.pyo	21.34 KB	-rw-r--r--	2014-09-17 20:43
wsgilib.py	19.66 KB	-rw-r--r--	2011-12-21 20:42
wsgilib.pyc	20.91 KB	-rw-r--r--	2014-09-17 20:43
wsgilib.pyo	20.86 KB	-rw-r--r--	2014-09-17 20:43
wsgiwrappers.py	21.65 KB	-rw-r--r--	2011-12-21 20:42
wsgiwrappers.pyc	23.21 KB	-rw-r--r--	2014-09-17 20:43
wsgiwrappers.pyo	23.21 KB	-rw-r--r--	2014-09-17 20:43

Rename

# (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
"""
Map URL prefixes to WSGI applications.  See ``URLMap``
"""

from UserDict import DictMixin
import re
import os
import cgi
from paste import httpexceptions

__all__ = ['URLMap', 'PathProxyURLMap']

def urlmap_factory(loader, global_conf, **local_conf):
    if 'not_found_app' in local_conf:
        not_found_app = local_conf.pop('not_found_app')
    else:
        not_found_app = global_conf.get('not_found_app')
    if not_found_app:
        not_found_app = loader.get_app(not_found_app, global_conf=global_conf)
    urlmap = URLMap(not_found_app=not_found_app)
    for path, app_name in local_conf.items():
        path = parse_path_expression(path)
        app = loader.get_app(app_name, global_conf=global_conf)
        urlmap[path] = app
    return urlmap

def parse_path_expression(path):
    """
    Parses a path expression like 'domain foobar.com port 20 /' or
    just '/foobar' for a path alone.  Returns as an address that
    URLMap likes.
    """
    parts = path.split()
    domain = port = path = None
    while parts:
        if parts[0] == 'domain':
            parts.pop(0)
            if not parts:
                raise ValueError("'domain' must be followed with a domain name")
            if domain:
                raise ValueError("'domain' given twice")
            domain = parts.pop(0)
        elif parts[0] == 'port':
            parts.pop(0)
            if not parts:
                raise ValueError("'port' must be followed with a port number")
            if port:
                raise ValueError("'port' given twice")
            port = parts.pop(0)
        else:
            if path:
                raise ValueError("more than one path given (have %r, got %r)"
                                 % (path, parts[0]))
            path = parts.pop(0)
    s = ''
    if domain:
        s = 'http://%s' % domain
    if port:
        if not domain:
            raise ValueError("If you give a port, you must also give a domain")
        s += ':' + port
    if path:
        if s:
            s += '/'
        s += path
    return s

class URLMap(DictMixin):

"""
    URLMap instances are dictionary-like object that dispatch to one
    of several applications based on the URL.

The dictionary keys are URLs to match (like
    ``PATH_INFO.startswith(url)``), and the values are applications to
    dispatch to.  URLs are matched most-specific-first, i.e., longest
    URL first.  The ``SCRIPT_NAME`` and ``PATH_INFO`` environmental
    variables are adjusted to indicate the new context.

URLs can also include domains, like ``http://blah.com/foo``, or as
    tuples ``('blah.com', '/foo')``.  This will match domain names; without
    the ``http://domain`` or with a domain of ``None`` any domain will be
    matched (so long as no other explicit domain matches).  """

def __init__(self, not_found_app=None):
        self.applications = []
        if not not_found_app:
            not_found_app = self.not_found_app
        self.not_found_application = not_found_app

norm_url_re = re.compile('//+')
    domain_url_re = re.compile('^(http|https)://')

def not_found_app(self, environ, start_response):
        mapper = environ.get('paste.urlmap_object')
        if mapper:
            matches = [p for p, a in mapper.applications]
            extra = 'defined apps: %s' % (
                ',\n  '.join(map(repr, matches)))
        else:
            extra = ''
        extra += '\nSCRIPT_NAME: %r' % environ.get('SCRIPT_NAME')
        extra += '\nPATH_INFO: %r' % environ.get('PATH_INFO')
        extra += '\nHTTP_HOST: %r' % environ.get('HTTP_HOST')
        app = httpexceptions.HTTPNotFound(
            environ['PATH_INFO'],
            comment=cgi.escape(extra)).wsgi_application
        return app(environ, start_response)

def normalize_url(self, url, trim=True):
        if isinstance(url, (list, tuple)):
            domain = url[0]
            url = self.normalize_url(url[1])[1]
            return domain, url
        assert (not url or url.startswith('/')
                or self.domain_url_re.search(url)), (
            "URL fragments must start with / or http:// (you gave %r)" % url)
        match = self.domain_url_re.search(url)
        if match:
            url = url[match.end():]
            if '/' in url:
                domain, url = url.split('/', 1)
                url = '/' + url
            else:
                domain, url = url, ''
        else:
            domain = None
        url = self.norm_url_re.sub('/', url)
        if trim:
            url = url.rstrip('/')
        return domain, url

def sort_apps(self):
        """
        Make sure applications are sorted with longest URLs first
        """
        def key(app_desc):
            (domain, url), app = app_desc
            if not domain:
                # Make sure empty domains sort last:
                return '\xff', -len(url)
            else:
                return domain, -len(url)
        apps = [(key(desc), desc) for desc in self.applications]
        apps.sort()
        self.applications = [desc for (sortable, desc) in apps]

def __setitem__(self, url, app):
        if app is None:
            try:
                del self[url]
            except KeyError:
                pass
            return
        dom_url = self.normalize_url(url)
        if dom_url in self:
            del self[dom_url]
        self.applications.append((dom_url, app))
        self.sort_apps()

def __getitem__(self, url):
        dom_url = self.normalize_url(url)
        for app_url, app in self.applications:
            if app_url == dom_url:
                return app
        raise KeyError(
            "No application with the url %r (domain: %r; existing: %s)"
            % (url[1], url[0] or '*', self.applications))

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, app))
                break
        else:
            raise KeyError(
                "No application with the url %r" % (url,))

def keys(self):
        return [app_url for app_url, app in self.applications]

def __call__(self, environ, start_response):
        host = environ.get('HTTP_HOST', environ.get('SERVER_NAME')).lower()
        if ':' in host:
            host, port = host.split(':', 1)
        else:
            if environ['wsgi.url_scheme'] == 'http':
                port = '80'
            else:
                port = '443'
        path_info = environ.get('PATH_INFO')
        path_info = self.normalize_url(path_info, False)[1]
        for (domain, app_url), app in self.applications:
            if domain and domain != host and domain != host+':'+port:
                continue
            if (path_info == app_url
                or path_info.startswith(app_url + '/')):
                environ['SCRIPT_NAME'] += app_url
                environ['PATH_INFO'] = path_info[len(app_url):]
                return app(environ, start_response)
        environ['paste.urlmap_object'] = self
        return self.not_found_application(environ, start_response)

class PathProxyURLMap(object):

"""
    This is a wrapper for URLMap that catches any strings that
    are passed in as applications; these strings are treated as
    filenames (relative to `base_path`) and are passed to the
    callable `builder`, which will return an application.

This is intended for cases when configuration files can be
    treated as applications.

`base_paste_url` is the URL under which all applications added through
    this wrapper must go.  Use ``""`` if you want this to not
    change incoming URLs.
    """

def __init__(self, map, base_paste_url, base_path, builder):
        self.map = map
        self.base_paste_url = self.map.normalize_url(base_paste_url)
        self.base_path = base_path
        self.builder = builder

def __setitem__(self, url, app):
        if isinstance(app, (str, unicode)):
            app_fn = os.path.join(self.base_path, app)
            app = self.builder(app_fn)
        url = self.map.normalize_url(url)
        # @@: This means http://foo.com/bar will potentially
        # match foo.com, but /base_paste_url/bar, which is unintuitive
        url = (url[0] or self.base_paste_url[0],
               self.base_paste_url[1] + url[1])
        self.map[url] = app

def __getattr__(self, attr):
        return getattr(self.map, attr)

# This is really the only settable attribute
    def not_found_application__get(self):
        return self.map.not_found_application
    def not_found_application__set(self, value):
        self.map.not_found_application = value
    not_found_application = property(not_found_application__get,
                                     not_found_application__set)