PKе35“×2EGG-INFO/dependency_links.txt PKе35D(ÆØØEGG-INFO/PKG-INFOMetadata-Version: 1.0 Name: Routes Version: 1.5 Summary: Routing Recognition and Generation Tools Home-page: http://routes.groovie.org/ Author: Ben Bangert Author-email: ben@groovie.org License: UNKNOWN Description: A Routing package for Python that matches URL's to dicts and vice versa `Dev version available `_ Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Programming Language :: Python Classifier: Topic :: Internet :: WWW/HTTP Classifier: Topic :: Software Development :: Libraries :: Python Modules PKе35U£ÎÎEGG-INFO/SOURCES.txtCHANGELOG INSTALL LICENSE README setup.cfg setup.py Routes.egg-info/PKG-INFO Routes.egg-info/SOURCES.txt Routes.egg-info/dependency_links.txt Routes.egg-info/top_level.txt docs/index.txt docs/integration.txt docs/manual.txt docs/recipes.txt docs/community/index.txt docs/docs/index.txt docs/download/index.txt docs/pudge_template/SyntaxHighlighter.css docs/pudge_template/layout.css docs/pudge_template/layout.html docs/pudge_template/pudge.css docs/pudge_template/rst.css docs/pudge_template/site.css ez_setup/README.txt ez_setup/__init__.py routes/__init__.py routes/base.py routes/threadinglocal.py routes/util.py tests/test_files/controller_files/content.py tests/test_files/controller_files/users.py tests/test_files/controller_files/admin/users.py tests/test_functional/__init__.py tests/test_functional/test_generation.py tests/test_functional/test_recognition.py tests/test_functional/test_utils.py tests/test_units/test_base.py tests/test_units/test_environment.py PKе35g1`EGG-INFO/top_level.txtroutes PKѵ35“×2EGG-INFO/zip-safe PKô„$5¸¥¡?//routes/__init__.py"""Provides common classes and functions most users will want access to.""" import threadinglocal, sys class _RequestConfig(object): """ RequestConfig thread-local singleton The Routes RequestConfig object is a thread-local singleton that should be initialized by the web framework that is utilizing Routes. """ __shared_state = threadinglocal.local() def __getattr__(self, name): return getattr(self.__shared_state, name) def __setattr__(self, name, value): """ If the name is environ, load the wsgi envion with load_wsgi_environ and set the environ """ if name == 'environ': self.load_wsgi_environ(value) return self.__shared_state.__setattr__(name, value) return self.__shared_state.__setattr__(name, value) def __delattr__(self, name): delattr(self.__shared_state, name) def load_wsgi_environ(self, environ): """ Load the protocol/server info from the environ and store it. Also, match the incoming URL if there's already a mapper, and store the resulting match dict in mapper_dict. """ port_info = '' if environ.get('HTTPS'): self.__shared_state.protocol = 'https' if environ.get('SERVER_PORT') != '443': port_info += ':' + environ['SERVER_PORT'] else: self.__shared_state.protocol = 'http' if environ.get('SERVER_PORT', '80') != '80': port_info += ':' + environ.get('SERVER_PORT', '80') if hasattr(self, 'mapper'): self.mapper.environ = environ if 'PATH_INFO' in environ and hasattr(self, 'mapper'): mapper = self.mapper self.mapper.req_data.environ = environ path = environ['PATH_INFO'] self.__shared_state.mapper_dict = mapper.match(path) host = environ.get('HTTP_HOST') or environ.get('SERVER_NAME') self.__shared_state.host = host.split(':')[0] self.__shared_state.host += port_info def request_config(original=False): """ Returns the Routes RequestConfig object. To get the Routes RequestConfig: >>> from routes import * >>> config = request_config() The following attributes must be set on the config object every request: mapper mapper should be a Mapper instance thats ready for use host host is the hostname of the webapp protocol protocol is the protocol of the current request mapper_dict mapper_dict should be the dict returned by mapper.match() redirect redirect should be a function that issues a redirect, and takes a url as the sole argument prefix (optional) Set if the application is moved under a URL prefix. Prefix will be stripped before matching, and prepended on generation environ (optional) Set to the WSGI environ for automatic prefix support if the webapp is underneath a 'SCRIPT_NAME' Setting the environ will use information in environ to try and populate the host/protocol/mapper_dict options if you've already set a mapper. **Using your own requst local** If you have your own request local object that you'd like to use instead of the default thread local provided by Routes, you can configure Routes to use it:: from routes import request_config() config = request_config() if hasattr(config, 'using_request_local'): config.request_local = YourLocalCallable config = request_config() Once you have configured request_config, its advisable you retrieve it again to get the object you wanted. The variable you assign to request_local is assumed to be a callable that will get the local config object you wish. This example tests for the presence of the 'using_request_local' attribute which will be present if you haven't assigned it yet. This way you can avoid repeat assignments of the request specific callable. Should you want the original object, perhaps to change the callable its using or stop this behavior, call request_config(original=True). """ obj = _RequestConfig() if hasattr(obj, 'request_local') and original is False: return getattr(obj, 'request_local')() else: obj.using_request_local = False return _RequestConfig() from base import Mapper from util import url_for, redirect_to __all__=['Mapper', 'url_for', 'redirect_to', 'request_config'] PKѵ35ûÞ=ÌHHroutes/__init__.pyc;ò <¹üDc@spdZdkZdkZdefd„ƒYZed„ZdklZdk l Z l Z ddd d gZ dS( sEProvides common classes and functions most users will want access to.Ns_RequestConfigcBs>tZdZeiƒZd„Zd„Zd„Zd„Z RS(sÁ RequestConfig thread-local singleton The Routes RequestConfig object is a thread-local singleton that should be initialized by the web framework that is utilizing Routes. cCst|i|ƒSdS(N(sgetattrsselfs_RequestConfig__shared_statesname(sselfsname((s?build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/__init__.pys __getattr__scCsH|djo$|i|ƒ|ii||ƒSn|ii||ƒSdS(sq If the name is environ, load the wsgi envion with load_wsgi_environ and set the environ senvironN(snamesselfsload_wsgi_environsvalues_RequestConfig__shared_states __setattr__(sselfsnamesvalue((s?build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/__init__.pys __setattr__s   cCst|i|ƒdS(N(sdelattrsselfs_RequestConfig__shared_statesname(sselfsname((s?build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/__init__.pys __delattr__scCs[d}|idƒo<d|i_|idƒdjo|d|d7}q•nDd|i_|iddƒdjo|d|iddƒ7}nt|d ƒo||i_nd |jo t|d ƒo;|i}||ii_|d }|i |ƒ|i_ n|id ƒp |id ƒ}|i dƒd |i_ |ii |7_ dS(sË Load the protocol/server info from the environ and store it. Also, match the incoming URL if there's already a mapper, and store the resulting match dict in mapper_dict. ssHTTPSshttpss SERVER_PORTs443s:shttps80smappers PATH_INFOs HTTP_HOSTs SERVER_NAMEiN(s port_infosenvironsgetsselfs_RequestConfig__shared_statesprotocolshasattrsmappersreq_dataspathsmatchs mapper_dictshostssplit(sselfsenvironsmappershostspaths port_info((s?build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/__init__.pysload_wsgi_environs&    ( s__name__s __module__s__doc__sthreadinglocalslocals_RequestConfig__shared_states __getattr__s __setattr__s __delattr__sload_wsgi_environ(((s?build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/__init__.pys_RequestConfigs    cCsNtƒ}t|dƒo |tjot|dƒƒSn t|_tƒSdS(sy Returns the Routes RequestConfig object. To get the Routes RequestConfig: >>> from routes import * >>> config = request_config() The following attributes must be set on the config object every request: mapper mapper should be a Mapper instance thats ready for use host host is the hostname of the webapp protocol protocol is the protocol of the current request mapper_dict mapper_dict should be the dict returned by mapper.match() redirect redirect should be a function that issues a redirect, and takes a url as the sole argument prefix (optional) Set if the application is moved under a URL prefix. Prefix will be stripped before matching, and prepended on generation environ (optional) Set to the WSGI environ for automatic prefix support if the webapp is underneath a 'SCRIPT_NAME' Setting the environ will use information in environ to try and populate the host/protocol/mapper_dict options if you've already set a mapper. **Using your own requst local** If you have your own request local object that you'd like to use instead of the default thread local provided by Routes, you can configure Routes to use it:: from routes import request_config() config = request_config() if hasattr(config, 'using_request_local'): config.request_local = YourLocalCallable config = request_config() Once you have configured request_config, its advisable you retrieve it again to get the object you wanted. The variable you assign to request_local is assumed to be a callable that will get the local config object you wish. This example tests for the presence of the 'using_request_local' attribute which will be present if you haven't assigned it yet. This way you can avoid repeat assignments of the request specific callable. Should you want the original object, perhaps to change the callable its using or stop this behavior, call request_config(original=True). s request_localN(s_RequestConfigsobjshasattrsoriginalsFalsesgetattrsusing_request_local(soriginalsobj((s?build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/__init__.pysrequest_config8s 6  (sMapper(surl_fors redirect_tosMappersurl_fors redirect_tosrequest_config( s__doc__sthreadinglocalssyssobjects_RequestConfigsFalsesrequest_configsbasesMappersutilsurl_fors redirect_tos__all__(sMappers_RequestConfigs__all__s redirect_tossyssrequest_configsurl_forsthreadinglocal((s?build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/__init__.pys?s 3 > PK.¢358ØS V˜V˜routes/base.py"""Route and Mapper core classes""" import re import sys import urllib from util import _url_quote as url_quote from util import controller_scan, RouteException from routes import request_config if sys.version < '2.4': from sets import ImmutableSet as frozenset import threadinglocal def strip_slashes(name): if name.startswith('/'): name = name[1:] if name.endswith('/'): name = name[:-1] return name class Route(object): """The Route object holds a route recognition and generation routine. See Route.__init__ docs for usage. """ def __init__(self, routepath, **kargs): """Initialize a route, with a given routepath for matching/generation The set of keyword args will be used as defaults. Usage:: >>> from routes.base import Route >>> newroute = Route(':controller/:action/:id') >>> newroute.defaults {'action': 'index', 'id': None} >>> newroute = Route('date/:year/:month/:day', controller="blog", action="view") >>> newroute = Route('archives/:page', controller="blog", action="by_page", requirements = { 'page':'\d{1,2}' }) >>> newroute.reqs {'page': '\\\d{1,2}'} .. Note:: Route is generally not called directly, a Mapper instance connect method should be used to add routes. """ self.routepath = routepath self.sub_domains = False # Don't bother forming stuff we don't need if its a static route self.static = kargs.get('_static', False) self.filter = kargs.pop('_filter', None) # Pull out route conditions self.conditions = kargs.pop('conditions', None) # reserved keys that don't count reserved_keys = ['requirements'] # Strip preceding '/' if present if routepath.startswith('/'): routepath = routepath[1:] # Build our routelist, and the keys used in the route self.routelist = routelist = self._pathkeys(routepath) routekeys = frozenset([key['name'] for key in routelist if isinstance(key, dict)]) # Build a req list with all the regexp requirements for our args self.reqs = kargs.get('requirements', {}) self.req_regs = {} for key,val in self.reqs.iteritems(): self.req_regs[key] = re.compile('^' + val + '$') # Update our defaults and set new default keys if needed. defaults needs to be saved (self.defaults, defaultkeys) = self._defaults(routekeys, reserved_keys, kargs) # Save the maximum keys we could utilize self.maxkeys = defaultkeys | routekeys # Populate our minimum keys, and save a copy of our backward keys for quicker generation later (self.minkeys, self.routebackwards) = self._minkeys(routelist[:]) # Populate our hardcoded keys, these are ones that are set and don't exist in the route self.hardcoded = frozenset([key for key in self.maxkeys \ if key not in routekeys and self.defaults[key] is not None]) def _pathkeys(self, routepath): """Utility function to walk the route, and pull out the valid dynamic/wildcard keys""" collecting = False current = '' done_on = '' var_type = '' just_started = False routelist = [] for char in routepath: if char in [':', '*'] and not collecting: just_started = True collecting = True var_type = char if len(current) > 0: routelist.append(current) current = '' elif collecting and just_started: just_started = False if char == '(': done_on = ')' else: current = char done_on = '/' elif collecting and char != done_on: current += char elif collecting: collecting = False routelist.append(dict(type=var_type, name=current)) if done_on == '/': routelist.append(done_on) done_on = var_type = current = '' else: current += char if collecting: routelist.append(dict(type=var_type, name=current)) elif current: routelist.append(current) return routelist def _minkeys(self, routelist): """Utility function to walk the route backwards Will also determine the minimum keys we can handle to generate a working route. routelist is a list of the '/' split route path defaults is a dict of all the defaults provided for the route """ minkeys = [] backcheck = routelist[:] gaps = False backcheck.reverse() for part in backcheck: if not isinstance(part, dict) and part != '/': gaps = True continue elif not isinstance(part, dict): continue key = part['name'] if self.defaults.has_key(key) and not gaps: continue minkeys.append(key) gaps = True return (frozenset(minkeys), backcheck) def _defaults(self, routekeys, reserved_keys, kargs): """Creates default set with values stringified Put together our list of defaults, stringify non-None values and add in our action/id default if they use it and didn't specify it defaultkeys is a list of the currently assumed default keys routekeys is a list of the keys found in the route path reserved_keys is a list of keys that are not """ defaults = {} # Add in a controller/action default if they don't exist if 'controller' not in routekeys and 'controller' not in kargs: kargs['controller'] = 'content' if 'action' not in routekeys and 'action' not in kargs: kargs['action'] = 'index' defaultkeys = frozenset([key for key in kargs.keys() if key not in reserved_keys]) for key in defaultkeys: if kargs[key] != None: defaults[key] = str(kargs[key]) else: defaults[key] = None if 'action' in routekeys and not defaults.has_key('action'): defaults['action'] = 'index' if 'id' in routekeys and not defaults.has_key('id'): defaults['id'] = None newdefaultkeys = frozenset([key for key in defaults.keys() if key not in reserved_keys]) return (defaults, newdefaultkeys) def makeregexp(self, clist): """Create a regular expression for matching purposes Note: This MUST be called before match can function properly. clist should be a list of valid controller strings that can be matched, for this reason makeregexp should be called by the web framework after it knows all available controllers that can be utilized """ (reg, noreqs, allblank) = self.buildnextreg(self.routelist, clist) if not reg: reg = '/' reg = reg + '(/)?' + '$' if not reg.startswith('/'): reg = '/' + reg reg = '^' + reg self.regexp = reg self.regmatch = re.compile(reg) def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = re.escape(part['name']) partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '|'.join(map(re.escape, clist)) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '*': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.*)' + rest else: reg = '(?P<' + var + '>.*)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.*)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.*)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.*)' + rest elif part.endswith('/'): if allblank: reg = re.escape(part[:-1]) + '(/' + rest + ')?' else: allblank = False reg = re.escape(part) + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = re.escape(part) + rest return (reg, noreqs, allblank) def match(self, url, environ=None, sub_domains=False, sub_domains_ignore=None, domain_match=''): """Match a url to our regexp. While the regexp might match, this operation isn't guaranteed as there's other factors that can cause a match to fail even though the regexp succeeds (Default that was relied on wasn't given, requirement regexp doesn't pass, etc.). Therefore the calling function shouldn't assume this will return a valid dict, the other possible return is False if a match doesn't work out. """ # Static routes don't match, they generate only if self.static: return False if url.endswith('/') and len(url) > 1: url = url[:-1] m = self.regmatch.match(url) if not m: return False if not environ: environ = {} sub_domain = None if environ.get('HTTP_HOST') and sub_domains: host = environ['HTTP_HOST'].split(':')[0] sub_match = re.compile('^(.+?)\.%s$' % domain_match) subdomain = re.sub(sub_match, r'\1', host) if subdomain not in sub_domains_ignore and host != subdomain: sub_domain = subdomain if self.conditions: if self.conditions.has_key('method') and \ environ.get('REQUEST_METHOD') not in self.conditions['method']: return False # Check sub-domains? use_sd = self.conditions.get('sub_domain') if use_sd and not sub_domain: return False if isinstance(use_sd, list) and sub_domain not in use_sd: return False matchdict = m.groupdict() result = {} extras = frozenset(self.defaults.keys()) - frozenset(matchdict.keys()) for key,val in matchdict.iteritems(): if not val and self.defaults.has_key(key) and self.defaults[key]: result[key] = self.defaults[key] else: result[key] = val for key in extras: result[key] = self.defaults[key] # Add the sub-domain if there is one if sub_domains: result['sub_domain'] = sub_domain # If there's a function, call it with environ and expire if it # returns False if self.conditions and self.conditions.has_key('function') and \ not self.conditions['function'](environ, result): return False return result def generate(self, _ignore_req_list=False, **kargs): """Generate a URL from ourself given a set of keyword arguments Toss an exception if this set of keywords would cause a gap in the url. """ # Verify that our args pass any regexp requirements if not _ignore_req_list: for key in self.reqs.keys(): val = kargs.get(key) if val and not self.req_regs[key].match(str(val)): return False # Verify that if we have a method arg, its in the method accept list. Also, method # will be changed to _method for route generation meth = kargs.get('method') if meth: if self.conditions and 'method' in self.conditions \ and meth.upper() not in self.conditions['method']: return False kargs.pop('method') routelist = self.routebackwards urllist = [] gaps = False for part in routelist: if isinstance(part, dict) and part['type'] == ':': arg = part['name'] # For efficiency, check these just once has_arg = kargs.has_key(arg) has_default = self.defaults.has_key(arg) # Determine if we can leave this part off # First check if the default exists and wasn't provided in the call (also no gaps) if has_default and not has_arg and not gaps: continue # Now check to see if there's a default and it matches the incoming call arg if (has_default and has_arg) and str(kargs[arg]) == str(self.defaults[arg]) and not gaps: continue # We need to pull the value to append, if the arg is None and we have a default, use that if has_arg and kargs[arg] is None and has_default and not gaps: continue # Otherwise if we do have an arg, use that elif has_arg: val = kargs[arg] elif has_default and self.defaults[arg] is not None: val = self.defaults[arg] # No arg at all? This won't work else: return False urllist.append(url_quote(val)) if has_arg: del kargs[arg] gaps = True elif isinstance(part, dict) and part['type'] == '*': arg = part['name'] kar = kargs.get(arg) if kar is not None: urllist.append(url_quote(kar)) gaps = True elif part.endswith('/'): if not gaps and part == '/': continue elif not gaps: urllist.append(part[:-1]) gaps = True else: gaps = True urllist.append(part) else: gaps = True urllist.append(part) urllist.reverse() url = ''.join(urllist) if not url.startswith('/'): url = '/' + url extras = frozenset(kargs.keys()) - self.maxkeys if extras: url += '?' url += urllib.urlencode([(key, kargs[key]) for key in kargs if key in extras and \ (key != 'action' or key != 'controller')]) return url class Mapper(object): """Mapper handles URL generation and URL recognition in a web application. Mapper is built handling dictionary's. It is assumed that the web application will handle the dictionary returned by URL recognition to dispatch appropriately. URL generation is done by passing keyword parameters into the generate function, a URL is then returned. """ def __init__(self, controller_scan=controller_scan, directory=None, always_scan=False, register=True): """Create a new Mapper instance All keyword arguments are optional. ``controller_scan`` Function reference that will be used to return a list of valid controllers used during URL matching. If ``directory`` keyword arg is present, it will be passed into the function during its call. This option defaults to a function that will scan a directory for controllers. ``directory`` Passed into controller_scan for the directory to scan. It should be an absolute path if using the default ``controller_scan`` function. ``always_scan`` Whether or not the ``controller_scan`` function should be run during every URL match. This is typically a good idea during development so the server won't need to be restarted anytime a controller is added. ``register`` Boolean used to determine if the Mapper should use ``request_config`` to register itself as the mapper. Since it's done on a thread-local basis, this is typically best used during testing though it won't hurt in other cases. """ self.matchlist = [] self.maxkeys = {} self.minkeys = {} self.urlcache = {} self._created_regs = False self._created_gens = False self.prefix = None self.environ = None self.req_data = threadinglocal.local() self.directory = directory self.always_scan = always_scan self.controller_scan = controller_scan self._regprefix = None self._routenames = {} self.debug = False self.append_slash = False self.sub_domains = False self.sub_domains_ignore = [] self.domain_match = '[^\.\/]+?\.[^\.\/]+' if register: config = request_config() config.mapper = self def connect(self, *args, **kargs): """Create and connect a new Route to the Mapper. Usage: .. code-block:: Python m = Mapper() m.connect(':controller/:action/:id') m.connect('date/:year/:month/:day', controller="blog", action="view") m.connect('archives/:page', controller="blog", action="by_page", requirements = { 'page':'\d{1,2}' }) m.connect('category_list', 'archives/category/:section', controller='blog', action='category', section='home', type='list') m.connect('home', '', controller='blog', action='view', section='home') """ routename = None if len(args) > 1: routename = args[0] args = args[1:] route = Route(*args, **kargs) self.matchlist.append(route) if routename: self._routenames[routename] = route if route.static: return exists = False for key in self.maxkeys: if key == route.maxkeys: self.maxkeys[key].append(route) exists = True break if not exists: self.maxkeys[route.maxkeys] = [route] self._created_gens = False def _create_gens(self): """Create the generation hashes for route lookups""" # Use keys temporailly to assemble the list to avoid excessive # list iteration testing with "in" controllerlist = {} actionlist = {} # Assemble all the hardcoded/defaulted actions/controllers used for route in self.matchlist: if route.static: continue if route.defaults.has_key('controller'): controllerlist[route.defaults['controller']] = True if route.defaults.has_key('action'): actionlist[route.defaults['action']] = True # Setup the lists of all controllers/actions we'll add each route # to. We include the '*' in the case that a generate contains a # controller/action that has no hardcodes controllerlist = controllerlist.keys() + ['*'] actionlist = actionlist.keys() + ['*'] # Go through our list again, assemble the controllers/actions we'll # add each route to. If its hardcoded, we only add it to that dict key. # Otherwise we add it to every hardcode since it can be changed. gendict = {} # Our generated two-deep hash for route in self.matchlist: if route.static: continue clist = controllerlist alist = actionlist if 'controller' in route.hardcoded: clist = [route.defaults['controller']] if 'action' in route.hardcoded: alist = [str(route.defaults['action'])] for controller in clist: for action in alist: actiondict = gendict.setdefault(controller, {}) actiondict.setdefault(action, ([], {}))[0].append(route) self._gendict = gendict self._created_gens = True def create_regs(self, clist=None): """Creates regular expressions for all connected routes""" if clist is None: if self.directory: clist = self.controller_scan(self.directory) else: clist = self.controller_scan() for key,val in self.maxkeys.iteritems(): for route in val: route.makeregexp(clist) # Create our regexp to strip the prefix if self.prefix: self._regprefix = re.compile(self.prefix + '(.*)') self._created_regs = True def _match(self, url): """Internal Route matcher Matches a URL against a route, and returns a tuple of the match dict and the route object if a match is successfull, otherwise it returns empty. For internal use only. """ if not self._created_regs and self.controller_scan: self.create_regs() elif not self._created_regs: raise RouteException, "You must generate the regular expressions before matching." if self.always_scan: self.create_regs() matchlog = [] if self.prefix: if re.match(self._regprefix, url): url = re.sub(self._regprefix, r'\1', url) if not url: url = '/' else: return (None, None, matchlog) for route in self.matchlist: if route.static: if self.debug: matchlog.append(dict(route=route, static=True)) continue match = route.match(url, self.environ, self.sub_domains, self.sub_domains_ignore, self.domain_match) if self.debug: matchlog.append(dict(route=route, regexp=bool(match))) if match: return (match, route, matchlog) return (None, None, matchlog) def match(self, url): """Match a URL against against one of the routes contained. Will return None if no valid match is found. .. code-block:: Python resultdict = m.match('/joe/sixpack') """ result = self._match(url) if self.debug: return result[0], result[1], result[2] if result[0]: return result[0] return None def routematch(self, url): """Match a URL against against one of the routes contained. Will return None if no valid match is found, otherwise a result dict and a route object is returned. .. code-block:: Python resultdict, route_obj = m.match('/joe/sixpack') """ result = self._match(url) if self.debug: return result[0], result[1], result[2] if result[0]: return result[0], result[1] return None def generate(self, controller='content', action='index', **kargs): """Generate a route from a set of keywords Returns the url text, or None if no URL could be generated. .. code-block:: Python m.generate(controller='content',action='view',id=10) """ # Generate ourself if we haven't already if not self._created_gens: self._create_gens() kargs['controller'] = controller kargs['action'] = action # Check the url cache to see if it exists, use it if it does if str(kargs) in self.urlcache: return self.urlcache[str(kargs)] actionlist = self._gendict.get(controller) or self._gendict.get('*') if not actionlist: return None (keylist, sortcache) = actionlist.get(action) or actionlist.get('*', (None, None)) if not keylist: return None keys = frozenset(kargs.keys()) cacheset = False cachekey = str(keys) cachelist = sortcache.get(cachekey) if cachelist: keylist = cachelist else: cacheset = True newlist = [] for route in keylist: if len(route.minkeys-keys) == 0: newlist.append(route) keylist = newlist def keysort(a, b): am = a.minkeys a = a.maxkeys b = b.maxkeys lendiffa = len(keys^a) lendiffb = len(keys^b) # If they both match, don't switch them if lendiffa == 0 and lendiffb == 0: return 0 # First, if a matches exactly, use it if lendiffa == 0: return -1 # Or b matches exactly, use it if lendiffb == 0: return 1 # Neither matches exactly, return the one with the most in common if cmp(lendiffa,lendiffb) != 0: return cmp(lendiffa,lendiffb) # Neither matches exactly, but if they both have just as much in common if len(keys&b) == len(keys&a): return cmp(len(a),len(b)) # Then we return the shortest of the two # Otherwise, we return the one that has the most in common else: return cmp(len(keys&b), len(keys&a)) keylist.sort(keysort) if cacheset: sortcache[cachekey] = keylist for route in keylist: fail = False for key in route.hardcoded: kval = kargs.get(key) if not kval: continue if kval != route.defaults[key]: fail = True break if fail: continue path = route.generate(**kargs) if path: if self.prefix: path = self.prefix + path if self.environ and self.environ.get('SCRIPT_NAME', '') != '': path = self.environ['SCRIPT_NAME'] + path if self.urlcache is not None: self.urlcache[str(kargs)] = path return path else: continue return None def resource(self, controller_name, **kwargs): """Generate routes for a controller resource The controller should be the name of the controller for which a set of resource-based Routes should be generated. The concept of a web resource maps somewhat directly to 'CRUD' operations. The overlying things to keep in mind is that mapping a resource is about handling creating, viewing, and editing that resource. All keyword arguments are optional. ``controller`` If specified in the keyword args, the controller will be the actual controller used, but the rest of the naming conventions used for the route names and URL paths are unchanged. ``collection`` Additional action mappings used to manipulate/view the entire set of resources provided by the controller. Example:: map.resource('message', collection={'rss':'GET'}) # GET /message;rss (maps to the rss action) # also adds named route "rss_message" ``member`` Additional action mappings used to access an individual 'member' of this controllers resources. Example:: map.resource('message', member={'mark':'POST'}) # POST /message/1;mark (maps to the mark action) # also adds named route "mark_message" ``new`` Action mappings that involve dealing with a new member in the controller resources. Example:: map.resource('message', new={'preview':'POST'}) # POST /message/new;preview (maps to the preview action) # also adds a url named "preview_new_message" ``path_prefix`` Prepends the URL path for the Route with the path_prefix given. This is most useful for cases where you want to mix resources or relations between resources. ``name_prefix`` Perpends the route names that are generated with the name_prefix given. Combined with the path_prefix option, it's easy to generate route names and paths that represent resources that are in relations. Example:: map.resource('message', controller='categories', path_prefix='/category/:category_id', name_prefix="category_") # GET /category/7/message/1 # has named route "category_message" """ controller = controller_name collection = kwargs.pop('collection', {}) member = kwargs.pop('member', {}) new = kwargs.pop('new', {}) path_prefix = kwargs.pop('path_prefix', '') name_prefix = kwargs.pop('name_prefix', '') # Ensure the edit and new actions are in and GET member['edit'] = 'GET' new.update({'new': 'GET'}) # Make new dict's based off the old, except the old values become keys, # and the old keys become items in a list as the value def swap(dct, newdct): for key, val in dct.iteritems(): newdct.setdefault(val.upper(), []).append(key) return newdct collection_methods = swap(collection, {}) member_methods = swap(member, {}) new_methods = swap(new, {}) # Insert create, update, and destroy methods collection_methods.setdefault('POST', []).insert(0, 'create') member_methods.setdefault('PUT', []).insert(0, 'update') member_methods.setdefault('DELETE', []).insert(0, 'delete') # If there's a path prefix option, use it with the controller controller = strip_slashes(controller) path_prefix = strip_slashes(path_prefix) if path_prefix: path = path_prefix + '/' + controller else: path = controller collection_path = path new_path = path + "/new" member_path = path + "/:(id)" options = {'controller':kwargs.get('controller', controller)} def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth.upper()]} return opts # Add the routes for handling collection methods for method, lst in collection_methods.iteritems(): primary = (method != 'GET' and lst.pop(0)) or None route_options = requirements_for(method) for action in lst: route_options['action'] = action route_name = "%s%s_%s" % (name_prefix, action, controller) self.connect(route_name, "%s;%s" % (collection_path, action), **route_options) self.connect("formatted_" + route_name, "%s.:(format);%s" % (collection_path, action)) if primary: route_options['action'] = primary self.connect(collection_path, **route_options) self.connect("%s.:(format)" % collection_path, **route_options) # Specifically add in the built-in 'index' collection method and its formatted # version self.connect(name_prefix + controller, collection_path, action='index', conditions={'method':['GET']}, **options) self.connect("formatted_" + name_prefix + controller, collection_path + ".:(format)", action='index', conditions={'method':['GET']}, **options) # Add the routes that deal with new resource methods for method, lst in new_methods.iteritems(): route_options = requirements_for(method) for action in lst: path = (action == 'new' and new_path) or "%s;%s" % (new_path, action) name = "new_" + controller if action != 'new': name = action + "_" + name route_options['action'] = action self.connect(name_prefix + name, path, **route_options) path = (action == 'new' and new_path + '.:(format)') or \ "%s.:(format);%s" % (new_path, action) self.connect("formatted_" + name_prefix + name, path, **route_options) # Add the routes that deal with member methods of a resource for method, lst in member_methods.iteritems(): route_options = requirements_for(method) route_options['requirements'] = {'id':'\w+'} if method not in ['POST', 'GET', 'any']: primary = lst.pop(0) else: primary = None for action in lst: route_options['action'] = action self.connect("%s%s_%s" % (name_prefix, action, controller), "%s;%s" % (member_path, action), **route_options) self.connect("formatted_%s%s_%s" % (name_prefix, action, controller), "%s.:(format);%s" % (member_path, action), **route_options) if primary: route_options['action'] = primary self.connect(member_path, **route_options) # Specifically add the member 'show' method route_options = requirements_for('GET') route_options['action'] = 'show' route_options['requirements'] = {'id':'\w+'} self.connect(name_prefix + controller, member_path, **route_options) self.connect("formatted_" + name_prefix + controller, member_path + ".:(format)", **route_options) PKѵ35NK·||routes/base.pyc;ò ɲEc@s±dZdkZdkZdkZdklZdklZlZdk l Z ei djodk l ZndkZd„Zdefd „ƒYZd efd „ƒYZdS( sRoute and Mapper core classesN(s _url_quote(scontroller_scansRouteException(srequest_configs2.4(s ImmutableSetcCsD|idƒo|d}n|idƒo|d }n|SdS(Ns/iiÿÿÿÿ(snames startswithsendswith(sname((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/base.pys strip_slashess sRoutecBsetZdZd„Zd„Zd„Zd„Zd„Zd„Ze e e dd„Z e d „Z RS( sxThe Route object holds a route recognition and generation routine. See Route.__init__ docs for usage. c KsÒ||_t|_|idtƒ|_|idtƒ|_ |idtƒ|_ dg}|i dƒo|d}n|i |ƒ|_} tgi}| D](}t|tƒo||dƒqŸqŸ~ƒ}|idhƒ|_h|_x;|iiƒD]*\}}tid|d ƒ|i|>> from routes.base import Route >>> newroute = Route(':controller/:action/:id') >>> newroute.defaults {'action': 'index', 'id': None} >>> newroute = Route('date/:year/:month/:day', controller="blog", action="view") >>> newroute = Route('archives/:page', controller="blog", action="by_page", requirements = { 'page':'\d{1,2}' }) >>> newroute.reqs {'page': '\\d{1,2}'} .. Note:: Route is generally not called directly, a Mapper instance connect method should be used to add routes. s_statics_filters conditionss requirementss/isnames^s$N($s routepathsselfsFalses sub_domainsskargssgetsstaticspopsNonesfilters conditionss reserved_keyss startswiths _pathkeyss routelists frozensetsappends_[1]skeys isinstancesdicts routekeyssreqssreq_regss iteritemssvalsrescompiles _defaultssdefaultss defaultkeyssmaxkeyss_minkeyssminkeyssroutebackwardss hardcoded( sselfs routepathskargsskeysvals defaultkeyss routekeyss_[1]s reserved_keyss routelist((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/base.pys__init__s(   E  " c Cs—t}d}d}d}t}g}x)|D]!}|ddgjo| o@t }t }|}t |ƒdjo|i |ƒd}qLq+|o|o-t}|djo d}qL|}d}q+|o ||jo||7}q+|oRt}|i t d|d |ƒƒ|djo|i |ƒnd}}}q+||7}q+W|o |i t d|d |ƒƒn|o|i |ƒn|Sd S( sPUtility function to walk the route, and pull out the valid dynamic/wildcard keysss:s*is(s)s/stypesnameN( sFalses collectingscurrentsdone_onsvar_types just_starteds routelists routepathscharsTrueslensappendsdict( sselfs routepaths collectingscharsvar_typesdone_onscurrents routelists just_started((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/base.pys _pathkeysWsH      cCsÄg}|}t}|iƒx|D]ˆ}t|tƒ o |djo t }q$nt|tƒ oq$n|d}|i i |ƒo| oq$n|i|ƒt }q$Wt|ƒ|fSdS(s&Utility function to walk the route backwards Will also determine the minimum keys we can handle to generate a working route. routelist is a list of the '/' split route path defaults is a dict of all the defaults provided for the route s/snameN(sminkeyss routelists backchecksFalsesgapssreversesparts isinstancesdictsTrueskeysselfsdefaultsshas_keysappends frozenset(sselfs routelists backchecksminkeyssgapsskeyspart((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/base.pys_minkeyss$    c Csˆh}d|jo d|jod|ds)s controllers|s>[^s]+)s>[^/]+)s(s)?s?s*s>.*)s/iÿÿÿÿs(/N(spathspartsregsTruesrestsnoreqssallblankslensselfs buildnextregsclists isinstancesdictsresescapesvarspartregsreqsshas_keysjoinsmapsFalsesdefaultssendswith( sselfspathsclistsnoreqsspartregsrestsallblankspartsvarsreg((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/base.pys buildnextregÌsx#!! /"  &!  #scCs§|iotSn|idƒot|ƒdjo|d }n|ii|ƒ}| otSn| o h}nt }|i dƒo|og|didƒd} tid|ƒ} ti| d| ƒ} | |jo | | jo | }qûn|ioŠ|iid ƒo|i d ƒ|id jotSn|ii d ƒ} | o| otSnt| tƒo || jotSqn|iƒ}h}t|i i!ƒƒt|i!ƒƒ} xb|i#ƒD]T\}}| o|i i|ƒo |i |o|i |||tZd„Zeid„Zeid„Zeid„ZRS(NcCsh|id 1: port += ':' + hostmatch[1] sub_match = re.compile('^.+?\.(%s)$' % config.mapper.domain_match) domain = re.sub(sub_match, r'\1', host) if subdomain and not host.startswith(subdomain) and \ subdomain not in config.mapper.sub_domains_ignore: kargs['_host'] = subdomain + '.' + domain + port elif (subdomain in config.mapper.sub_domains_ignore or subdomain is None) and domain != host: kargs['_host'] = domain + port return kargs else: return kargs def _url_quote(string): return urllib.quote_plus(str(string), '/') def url_for(*args, **kargs): """Generates a URL All keys given to url_for are sent to the Routes Mapper instance for generation except for:: anchor specified the anchor name to be appened to the path host overrides the default (current) host if provided protocol overrides the default (current) protocol if provided The URL is generated based on the rest of the keys. When generating a new URL, values will be used from the current request's parameters (if present). The following rules are used to determine when and how to keep the current requests parameters: * If the controller is present and begins with '/', no defaults are used * If the controller is changed, action is set to 'index' unless otherwise specified For example, if the current request yielded a dict of {'controller': 'blog', 'action': 'view', 'id': 2}, with the standard ':controller/:action/:id' route, you'd get the following results:: url_for(id=4) => '/blog/view/4', url_for(controller='/admin') => '/admin', url_for(controller='admin') => '/admin/index/4' url_for(action='edit') => '/blog/post/4', url_for(action='list', id=None) => '/blog/list' **Static and Named Routes** If there is a string present as the first argument, a lookup is done against the named routes table to see if there's any matching routes. The keyword defaults used with static routes will be sent in as GET query arg's if a route matches. If no route by that name is found, the string is assumed to be a raw URL. Should the raw URL begin with ``/`` then appropriate SCRIPT_NAME data will be added if present, otherwise the string will be used as the url with keyword args becoming GET query args. """ anchor = kargs.get('anchor') host = kargs.get('host') protocol = kargs.get('protocol') # Remove special words from kargs, convert placeholders for key in ['anchor', 'host', 'protocol']: if kargs.get(key): del kargs[key] if kargs.has_key(key+'_'): kargs[key] = kargs.pop(key+'_') config = request_config() route = None static = False url = '' if len(args) > 0: route = config.mapper._routenames.get(args[0]) if route and route.defaults.has_key('_static'): static = True url = route.routepath # No named route found, assume the argument is a relative path if not route: static = True url = args[0] if url.startswith('/') and hasattr(config, 'environ') \ and config.environ.get('SCRIPT_NAME'): url = config.environ.get('SCRIPT_NAME') + url if static: if kargs: url += '?' url += urllib.urlencode(kargs) if not static: if route: newargs = route.defaults.copy() newargs.update(kargs) # If this route has a filter, apply it if route.filter: newargs = route.filter(newargs) # Handle sub-domains newargs = _subdomain_check(config, newargs) else: newargs = _screenargs(kargs) anchor = newargs.pop('_anchor', None) or anchor host = newargs.pop('_host', None) or host protocol = newargs.pop('_protocol', None) or protocol url = config.mapper.generate(**newargs) if config.mapper.append_slash and not url.endswith('/'): url += '/' if anchor: url += '#' + _url_quote(anchor) if host or protocol: if not host: # Ensure we don't use a specific port, as changing the protocol # means that we most likely need a new port host = config.host.split(':')[0] if not protocol: protocol = config.protocol url = protocol + '://' + host + url return url def redirect_to(*args, **kargs): """ Issues a redirect based on the arguments. Redirect's *should* occur as a "302 Moved" header, however the web framework may utilize a different method. All arguments are passed to url_for to retrieve the appropriate URL, then the resulting URL it sent to the redirect function as the URL. """ target = url_for(*args, **kargs) config = request_config() config.redirect(target) def controller_scan(directory=None): """ Scan a directory for python files and use them as controllers """ if directory is None: return [] def find_controllers(dirname, prefix=''): controllers = [] for fname in os.listdir(dirname): filename = os.path.join(dirname, fname) if os.path.isfile(filename) and re.match('^[^_]{1,1}.*\.py$', fname): controllers.append(prefix + fname[:-3]) elif os.path.isdir(filename): controllers.extend(find_controllers(filename, prefix=prefix+fname+'/')) return controllers def longest_first(a, b): return cmp(len(b), len(a)) controllers = find_controllers(directory) controllers.sort(longest_first) return controllers class RouteException(Exception): pass PKѵ35]m†íé"é"routes/util.pyc;ò ;§Ec@sdZdkZdkZdkZdklZd„Zd„Zd„Zd„Z d„Z e d„Z d e fd „ƒYZdS( sÜUtility functions for use in templates / controllers *PLEASE NOTE*: Many of these functions expect an initialized RequestConfig object. This is expected to have been initialized for EACH REQUEST by the web framework. N(srequest_configcCs+|idƒ}|o |idƒo|dd|d<|Sn'|o|idƒ od|d '/blog/view/4', url_for(controller='/admin') => '/admin', url_for(controller='admin') => '/admin/index/4' url_for(action='edit') => '/blog/post/4', url_for(action='list', id=None) => '/blog/list' **Static and Named Routes** If there is a string present as the first argument, a lookup is done against the named routes table to see if there's any matching routes. The keyword defaults used with static routes will be sent in as GET query arg's if a route matches. If no route by that name is found, the string is assumed to be a raw URL. Should the raw URL begin with ``/`` then appropriate SCRIPT_NAME data will be added if present, otherwise the string will be used as the url with keyword args becoming GET query args. sanchorshostsprotocols_sis_statics/senvirons SCRIPT_NAMEs?s_anchors_hosts _protocols#s:s://N(&skargssgetsanchorshostsprotocolskeyshas_keyspopsrequest_configsconfigsNonesroutesFalsesstaticsurlslensargssmappers _routenamessdefaultssTrues routepaths startswithshasattrsenvironsurllibs urlencodescopysnewargssupdatesfilters_subdomain_checks _screenargssgenerates append_slashsendswiths _url_quotessplit( sargsskargssprotocolsurlsrouteshostsstaticskeysnewargssconfigsanchor((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/util.pysurl_forDsf$   3     cOs)t||Ž}tƒ}|i|ƒdS(sI Issues a redirect based on the arguments. Redirect's *should* occur as a "302 Moved" header, however the web framework may utilize a different method. All arguments are passed to url_for to retrieve the appropriate URL, then the resulting URL it sent to the redirect function as the URL. N(surl_forsargsskargsstargetsrequest_configsconfigsredirect(sargsskargssconfigstarget((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/util.pys redirect_to§s  csN|tjogSnd‡d†‰d„}ˆ|ƒ}|i|ƒ|SdS(sG Scan a directory for python files and use them as controllers scs´g}x£ti|ƒD]’}tii||ƒ}tii|ƒot i d|ƒo|i ||d ƒqtii |ƒo%|iˆ|d||dƒƒqqW|SdS(Ns^[^_]{1,1}.*\.py$iýÿÿÿsprefixs/(s controllerssosslistdirsdirnamesfnamespathsjoinsfilenamesisfilesresmatchsappendsprefixsisdirsextendsfind_controllers(sdirnamesprefixsfilenames controllerssfname(sfind_controllers(s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/util.pysfind_controllers½s&)cCstt|ƒt|ƒƒSdS(N(scmpslensbsa(sasb((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/util.pys longest_firstÆsN(s directorysNonesfind_controllerss longest_firsts controllersssort(s directorys longest_firsts controllerssfind_controllers((sfind_controllerss;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/util.pyscontroller_scan¶s    sRouteExceptioncBstZRS(N(s__name__s __module__(((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/util.pysRouteExceptionÌs(s__doc__sossresurllibsroutessrequest_configs _screenargss_subdomain_checks _url_quotesurl_fors redirect_tosNonescontroller_scans ExceptionsRouteException( s _screenargssurl_fors redirect_toscontroller_scansurllibsresrequest_configsRouteExceptions _url_quotes_subdomain_checksos((s;build/bdist.darwin-8.7.0-Power_Macintosh/egg/routes/util.pys?s     !   c  PKе35“×2¤EGG-INFO/dependency_links.txtPKе35D(ÆØؤ<EGG-INFO/PKG-INFOPKе35U£ÎΤCEGG-INFO/SOURCES.txtPKе35g1`¤CEGG-INFO/top_level.txtPKѵ35“×2¤~EGG-INFO/zip-safePKô„$5¸¥¡?//¤®routes/__init__.pyPKѵ35ûÞ=ÌHH¤ routes/__init__.pycPK.¢358ØS V˜V˜¤†1routes/base.pyPKѵ35NK·||¤Êroutes/base.pycPKX{4 Ð 6¯¯¤¶Froutes/threadinglocal.pyPKѵ35™Ò+ù||¤›Kroutes/threadinglocal.pycPK…›35‹p¢p——¤NTroutes/util.pyPKѵ35]m†íé"é"¤sroutes/util.pycPK O'–