^.hdZddlZddlZddlZddlZddlmZddlZddl m Z ddl m Z m Z mZddlmZgdZgdZd ZGd d eZGd d eZdZGddeZy)zMapper and Sub-MapperN)LRUCache)request_config)controller_scanRoutesException as_unicodeRoute)indexcreatenew)showupdatedeleteeditc^|jdr|dd}|jdr|dd}|S)z8Remove slashes from the beginning and end of a part/URL./N) startswithendswith)names a/var/www/html/School_Mangement_New/src/backend/venv/lib/python3.12/site-packages/routes/mapper.py strip_slashesrs5 sABx }}SCRy Kc*eZdZdZdZdddeedfdZy)SubMapperParentzbBase class for Mapper and SubMapper, both of which may be the parent of SubMapper objects c t|fi|S)aCreate a partial version of the Mapper with the designated options set This results in a :class:`routes.mapper.SubMapper` object. If keyword arguments provided to this method also exist in the keyword arguments provided to the submapper, their values will be merged with the saved options going first. In addition to :class:`routes.route.Route` arguments, submapper can also take a ``path_prefix`` argument which will be prepended to the path of all routes that are connected. Example:: >>> map = Mapper(controller_scan=None) >>> map.connect('home', '/', controller='home', action='splash') >>> map.matchlist[0].name == 'home' True >>> m = map.submapper(controller='home') >>> m.connect('index', '/index', action='index') >>> map.matchlist[1].name == 'index' True >>> map.matchlist[1].defaults['controller'] == 'home' True Optional ``collection_name`` and ``resource_name`` arguments are used in the generation of route names by the ``action`` and ``link`` methods. These in turn are used by the ``index``, ``new``, ``create``, ``show``, ``edit``, ``update`` and ``delete`` methods which may be invoked indirectly by listing them in the ``actions`` argument. If the ``formatted`` argument is set to ``True`` (the default), generated paths are given the suffix '{.format}' which matches or generates an optional format extension. Example:: >>> from routes.util import url_for >>> map = Mapper(controller_scan=None) >>> m = map.submapper(path_prefix='/entries', collection_name='entries', resource_name='entry', actions=['index', 'new']) >>> url_for('entries') == '/entries' True >>> url_for('new_entry', format='xml') == '/entries/new.xml' True ) SubMapper)selfkargss r submapperzSubMapperParent.submapper%s`'''rNz/{id}c ||xs|}||d} n d} n|d} nd} | j||}t|f|||||d| } t| f||d|xsi| _| S)aCreate a submapper that represents a collection. This results in a :class:`routes.mapper.SubMapper` object, with a ``member`` property of the same type that represents the collection's member resources. Its interface is the same as the ``submapper`` together with ``member_prefix``, ``member_actions`` and ``member_options`` which are passed to the ``member`` submapper as ``path_prefix``, ``actions`` and keyword arguments respectively. Example:: >>> from routes.util import url_for >>> map = Mapper(controller_scan=None) >>> c = map.collection('entries', 'entry') >>> c.member.link('ping', method='POST') >>> url_for('entries') == '/entries' True >>> url_for('edit_entry', id=1) == '/entries/1/edit' True >>> url_for('ping_entry', id=1) == '/entries/1/ping' True z/{collection_name}z{pre}z{pre}/{collection_name})precollection_name)r% resource_name path_prefix controlleractions)r'r))formatrmember) rr%r&r' member_prefixr(collection_actionsmember_actionsmember_optionskwargspath_prefix_str collections rr2zSubMapperParent.collectionWs<  &9/J  &"$"6&")";&,,=L-N tE_-:+6:'9E>DE &j@m.<@)7)=2@ r)__name__ __module__ __qualname____doc__r!COLLECTION_ACTIONSMEMBER_ACTIONSr2rrrr s&0(dFJ!(T&8"09rrcxeZdZdZ ddZddZ ddZdZdZddZ dd Z dd Z d Z d Z d ZdZdZdZy)rz#Partial mapper for use with_optionsNc :||_||_||_d|_|xs0t |ddxs!|j ddxs t |dd|_|||_n%t |dd|_|jd|_|j|xsgfi|y)Nr&r( formattedT) r0objr%r+getattrgetr&r< add_actions)rr=r&r%r)r<r0s r__init__zSubMapper.__init__s . *0sOT20zz,-0sL$/   &DN$S+t&+$>HSM%+3KHSM $ C 0 5 16 ,C$++% &s   ,u%txx5H55rc |s||jrd}nd}|j|xs|dz|jzd|xs|z|zfd|xs|xs|it||S)aGenerates a named route for a subresource. Example:: >>> from routes.util import url_for >>> map = Mapper(controller_scan=None) >>> c = map.collection('entries', 'entry') >>> c.link('recent', name='recent_entries') >>> c.member.link('ping', method='POST', formatted=True) >>> url_for('entries') == '/entries' True >>> url_for('recent_entries') == '/entries/recent' True >>> url_for('ping_entry', id=1) == '/entries/1/ping' True >>> url_for('ping_entry', id=1, format='xml') == '/entries/1/ping.xml' True {.format}r#_ractionr<rIr&_kwargs_with_conditions)rrelrrUmethodr<r0suffixs rlinkzSubMapper.links}* *t~~ FFt||DDS3Y1C1C%C3;$/&8G#)#8S#8DG6ffEG Grc *|jdddi|S)z4Generates the "new" link for a collection submapper.rXr r9r[rr0s rr z SubMapper.newstyy-U-f--rc *|jdddi|S)z>> from routes import url_for >>> map = Mapper(controller_scan=None) >>> c = map.submapper(path_prefix='/entries', controller='entry') >>> c.action(action='index', name='entries', formatted=True) >>> c.action(action='create', method='POST') >>> url_for(controller='entry', action='index', method='GET') == '/entries' True >>> url_for(controller='entry', action='index', method='GET', format='xml') == '/entries.xml' True >>> url_for(controller='entry', action='create', method='POST') == '/entries' True rSr#rTrUrV)rrrUrYr<r0rZs rrUzSubMapper.actionsi& *t~~ FFt||DGVc\D4F4F%F"G#)>TG6ffEG Grc J|jd|xs |jddd|S)z8Generates the "index" action for a collection submapper.r GETrrUrYr9)rUr%rrr0s rr zSubMapper.indexs8t{{C <(<(<")%C;AC Crc J|jd|xs |jddd|S)z>Generates the "show" action for a collection member submapper.r rbrcr9)rUr&rds rr zSubMapper.shows8t{{B :(:(:"(B:@B Brc ,|jdddd|S)z9Generates the "create" action for a collection submapper.r POSTrUrYr9rUr^s rr zSubMapper.createst{{D(6DVDDrc ,|jdddd|S)z@Generates the "update" action for a collection member submapper.rPUTrhr9rir^s rrzSubMapper.updatest{{C(5CFCCrc ,|jdddd|S)z@Generates the "delete" action for a collection member submapper.rDELETErhr9rir^s rrzSubMapper.delete"st{{F(8FvFFrc N|Dcgc]}t||di|c}ycc}wNr9)r>)rr)r0rUs rr@zSubMapper.add_actions&s%7>?V v  ( (??s"c|SNr9rs r __enter__zSubMapper.__enter__*s rcyrqr9)rtyperPtbs r__exit__zSubMapper.__exit__-s r)NNNNrq)NNNrbN)NNrbN)r3r4r5r6rArIr[r rrUr r r rrr@rsrwr9rrrrsc-@D)-2$$6L=BG>./G8C B EDG@ rrcD|rd|vr|j}d|i|d<|S|S)N conditionsrY)copy)r0rY newkwargss rrWrW2s1 ,f,KKM #+V"4 , rceZdZdZeddddfdZdZdZdZd Z e eee Z dd Z d Z d Zd ZdZddZdZddZddZdZdZdZy)MapperapMapper 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. NFTcg|_i|_i|_td|_d|_d|_d|_d|_tj|_ ||_ ||_ ||_d|_i|_d|_d|_d|_g|_d|_||_d|_d|_d|_d|_tj6|_|rt;}||_yy)a 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. Alternatively, a list of controllers or None can be passed in which are assumed to be the definitive list of controller names valid when matching 'controller'. ``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. ``explicit`` Boolean used to determine if routes should be connected with implicit defaults of:: {'controller':'content','action':'index','id':None} When set to True, these defaults will not be added to route connections and ``url_for`` will not use Route memory. Additional attributes that may be set after mapper initialization (ie, map.ATTRIBUTE = 'something'): ``encoding`` Used to indicate alternative encoding/decoding systems to use with both incoming URL's, and during Route generation when passed a Unicode string. Defaults to 'utf-8'. ``decode_errors`` How to handle errors in the encoding, generally ignoring any chars that don't convert should be sufficient. Defaults to 'ignore'. ``minimization`` Boolean used to indicate whether or not Routes should minimize URL's and the generated URL's, or require every part where it appears in the path. Defaults to False. ``hardcode_names`` Whether or not Named Routes result in the default options for the route being used *or* if they actually force url generation to use the route. Defaults to False. i@FNz[^\.\/]+?\.[^\.\/]+utf-8ignoreT) matchlistmaxkeysminkeysrurlcache _created_regs _created_gens_master_regexpprefix threadinglocalreq_data directory always_scanr _regprefix _routenamesdebug append_slash sub_domainssub_domains_ignore domain_matchexplicitencoding decode_errorshardcode_names minimizationLockcreate_regs_lockrmapper)rrrrregisterrconfigs rrAzMapper.__init__GsF    """ !) "&. ! "$2   %"! ) 0 #%F FM rc d}dg|jDcgc]_}|jxsd|||jxsd|jj dd|jj ddfac}z}t t |dDcgc]tfd|Dc}djfd |DScc}wcc}w) z*Generates a tabular string representation.c|jrD|jjdd}t|tuxr|xsdj |Sy)NrYr#z, )ryr?rustrrF)rrYs rformat_methodsz&Mapper.__str__..format_methodssD||))(B7F|s*5vJ69JJr)z Route nameMethodsPath ControllerrUr#r(rUrc3:K|]}t|ywrqlen).0rowcols r z!Mapper.__str__..s5c#c(m5s c 3zK|]1djfdttD3yw) c3LK|]}|j|ywrq)ljust)rrrwidthss rrz+Mapper.__str__...s*4X^^F3K04s!$N)rFranger)rrrs @rrz!Mapper.__str__..s: HH4 %c&k 24 4s7;) rr routepathdefaultsr?rrmaxrF)rrrtablerrs `@r__str__zMapper.__str__s KK..*&&,Bq 11;;3D"**..r2AJJNN8R4PR** #3uQx=135u553yy *3s A$CCcN |jjS#t$rYywxYwrq)renvironAttributeErrorrrs r_envgetzMapper._envgets) ==(( (  s  $$c&||j_yrqrr)renvs r_envsetzMapper._envsets # rc|j`yrqrrrs r_envdelzMapper._envdels MM !rc|D]}|r*|jrdj||jg}n|r||jz}n |j}|j|j|fd|j i|j y)aExtends the mapper routes with a list of Route objects If a path_prefix is provided, all the routes will have their path prepended with the path_prefix. Example:: >>> map = Mapper(controller_scan=None) >>> map.connect('home', '/', controller='home', action='splash') >>> map.matchlist[0].name == 'home' True >>> routes = [Route('index', '/index.htm', controller='home', ... action='index')] >>> map.extend(routes) >>> len(map.matchlist) == 2 True >>> map.extend(routes, path_prefix='/subapp') >>> len(map.matchlist) == 3 True >>> map.matchlist[2].routepath == '/subapp/index.htm' True .. note:: This function does not merely extend the mapper with the given list of routes, it actually creates new routes with identical calling arguments. rryN)rrFrrIrry_kargs)rroutesr'routers rextendz Mapper.extends< Eu11HHk5??%CD '%//9 !OO DLL" $)$4$4 !<<  rct|i|S)zjMake a new Route object A subclass can override this method to use a custom Route class. r)rargsr s r make_routezMapper.make_routes d$e$$rcd}t|dkDr|d}nd|z}d|vr|j|d<d|vr|j|d<|j|i|}|jdk7s|j dk7r&d |vr"|j|_|j |_|j s|jj||r||j|<||_ |j ryd }|jD]3}||jk(s|j|j|d }n|s|g|j|j<d |_ y) aCreate 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') Nrrrq _explicit _minimizerr _encodingFT) rrrrrrstaticrappendrrrr)rrr rJrexistsrOs rrIzMapper.connectsF( t9q=QIT>D e #!%E+  e #!%!2!2E+ // MMW $(:(:h(F e #!]]EN"&"4"4E || NN ! !% ( */D  Y '"EJ << << Cemm# S!((/   +0'DLL '"rci}i}|jD]P}|jrd|jvrd||jd<d|jvs?d||jd<Rt|j dgz}t|j dgz}i}|jD]}|jr|}|}d|j vr|jdg}d|j vr#t j|jdg}|D]A}|D]:}|j|i} | j|gifdj|<C||_ d|_ y)z.Create the generation hashes for route lookupsr(TrU*rN) rrrlistkeys hardcodedrD text_type setdefaultr_gendictr) rcontrollerlist actionlistrgendictclistalistr(rU actiondicts r _create_genszMapper._create_gens4s{ ^^ >)7; 5>>(34  <n1134u<*//+,u4 ^^ ME||"EEu. 565??*u~~h'?@A# M #MF!(!3!3J!CJ))&2r(;A>EEeLM M M  !rc|jj |j|i||jjy#|jjwxYw)zPAtomically creates regular expressions for all connected routes N)racquire _create_regsrelease)rrr0s r create_regszMapper.create_regs^sU %%' , D  t .v .  ! ! ) ) +D ! ! ) ) +s A A%c|i|jr|j|j}nAt|jr|j}n|jsg}n |j}tj|j D]\}}|D]}|j |g}tjt}|jD]}|jr|j|j |ddjtjd|j }|j"r|j%dsd|z}||j'dj|||_t+t-d|Dd |_|j0r't3j4|j0d z|_d j|Dcgc]}d |z c}} | |_ t3j4| |_d|_ycc}w#t<$rd|_Yd|_ywxYw) z4Creates regular expressions for all connected routesNF) include_namesr#c"t|tSrq)rGr)ps rz%Mapper._create_regs..~s 1c8Jrrc32K|]}t|ywrqr)rrs rrz&Mapper._create_regs..s&E!s1v&EsT)reversez(.*)|z(?:%s)) rrcallablerDrEr makeregexp collections defaultdictrrrrrFit takewhile routelistrrrstrip_prefix2routessortedset _prefix_lensrrecompiler _master_regr OverflowErrorr) rrrOvalrregexps prefix2routesrxregexps rrzMapper._create_regshs =~~,,T^^<$../,,.)),, dll3 (HC (  ' ( (#//5 ^^ @E<<u//U/KL.J.3oo"?@%%f.?.?.D 6\FfmmC0188? @,"3&E}&E#E+/1 ;; jjv)=>DO9A8a<9:! '"$**V"4D " : '"&D ! 's& H#H((IIc jsjrjnjs tdjrjg}j rKt jjr&t jjdsdndd|fS|xs j}j}j}j}j}j!t jj}nd}|sdd|fSt j"j%fdj&D} | D]} | j(r|r|j+t-| d.| j||||} |r%|j+t-| t/| t1| t,s| s}| | |fcSdd|fS) zInternal 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. z:You must generate the regular expressions before matching.z\1rNTc3\K|]#}jjd|d%ywro)rr?)r prefix_lenrurls rrz Mapper._match..s6+P/9,0+>+>+B+B3{ CSUW+X+Ps),)rr)rr)rrrrrrrmatchrsubrrrrrrrchain from_iterablerrrrHboolrG) rrrmatchlogrrrr valid_urlrrrs `` r_matchz Mapper._matchs!!d&:&:    ##!#67 7        ;;xx-ffT__eS9CdH--)T\\&& !44((      *!4!4c:I I$) )HH**+P=A=N=N+PP  0E||OODuT$BCKKWk;M ,.E5e EF%&%uh// 0dH%%rc| |s td||d}|j||}|jr|d|d|dfSt|dts|dr|dSy)zMatch 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') NURL or environ must be provided PATH_INFOrrrrrrGrHrrrresults rrz Mapper.matchsw ;w!"CD D ;+&CS'* ::!9fQi2 2 fQi &&)!9 rc| |s td||d}|j||}|jr|d|d|dfSt|dts|dr |d|dfSy)aMatch 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') Nrrrrrrrs r routematchzMapper.routematchs ;w!"CD D ;+&CS'* ::!9fQi2 2 fQi &&)!9fQi' 'rc|js|j|jrd|d<|jsd|vrd|d<d|vrd|d<|j d|j xsi}d|vr|d}n,|j rd|j vr|j d}nd }|j dd }|j dd }tj|jd tj|jd z}|j]tjr#d j|jd |f}n|d|}|jj ||} | |k7r| St||j}t||j}|jj |xs|jj di} | s|sy | j |xs| j dd if\} } | s|sy t!|j#d} tj}| j |}|r|} nq|r|} nld} g}| D]<}t%|j&|j(z z dk(s,|j+|>|} Gfdd}| j-|| r| | |<| D]}d}|j.D][}|j |}|st||j}||j0|k7s@t3|j0|rYd}n|rs|j4di|}|r|j6r|j6|z}|j8xr |j:}|j<s |s||z}}n|}|j%|jj?|tA|tA|cSy )zGenerate 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) T _append_slashr(contentrUr _environ SCRIPT_NAMEr#Nutf8:r:rFrc*eZdZdZdZfdZdZy)"Mapper.generate..KeySorterc||_yrq)r=)rr=rs rrAz+Mapper.generate..KeySorter.__init__Ps "DHrcT|j|j|jdkS)Nr)_keysortr=)rothers r__lt__z)Mapper.generate..KeySorter.__lt__Ss ==599=AArc|j}|j}t|z }t|z }|dk(r|dk(ry|dk(ry|dk(ry|j||dk7r|j||St|zt|zk(r$|jt|t|S|jt|zt|zS)zOSorts two sets of sets, to order them ideally for matching.rrr)rr_compare)rablendiffalendiffbrs rr%z+Mapper.generate..KeySorter._keysortVs A A"4!8}H"4!8}H1}Q  1}! 1} }}Xx8A=#}}Xx@@4!8}D1H 5#}}SVSV<< $}}S]CqMJJrc||kry||kryy)Nrrrr9)robj1obj2s rr)z+Mapper.generate..KeySorter._compareysd{!  rN)r3r4r5rAr'r%r))rsr KeySorterr"Ns#B!KF!rr1)rOr9)!rrrrpoprr?rDrencoderPY3rFrrr frozensetrrrdotkeysrsortrrrgeneraterrexternalabsoluteputr)rrr r script_namer(rU cache_keycache_key_script_namerrkeylist sortcachecachesetcachekey cachelistnewlistrr1failrOkvalrKexternal_staticrs @rr8zMapper.generates!!       %)E/ "}}5(&/l#u$")h))J 5; G #!-0K \\mt||;,,}5KKYY|T2 8T* MM$'..v6 MM% ' ' /0  == $ww(, ;3E3Eg3N3<3>)?%4? (J%--##$94@Cd{  DMM: FDMM2]]&&z2Pdmm6G6GR6P $)~~f5 , NN3r + )t&==&MM(+ G GHG  *u}}u}}4t;<ANN5) *G1 !1 !f LLYL '&- (# ED yy~!$ 65>>#..$U^^C%89D !5>>*E*D;;;;-D"',,"A5>>~~o&-D/C#C==,MM%%c3t954y 7 8rc v|jdi}|jdi}|jdi}|jdd}|jdd}|jdd} | || dd | d d }|d | d z}n|d }|d }d|d<|jddid} | |i} | |i} | |i} | jdgjdd| jdgjdd| jdgjddt |}t |}d|z}|r|dk7r |dz|z}nd|z}|}|dz}|dz}|j d|||| |j ddd|vr|dd<fd}t j| D]\}dk7xr|jdxsd}|}|D]F}||d <||d!|}|jd"|z|d|d#fi||j||d|fi|H|sx||d <|jd$|zfi||j|fi||jd"|z|z|d#zfd%d&dgid'|j||z|fd%d&dgid't j| D]s\}|}|D]a}d(|z}||d <|dk(r|}|d#z}n|d|}|d!z|z}|d|d#}|jd"|z|z|fi||j||z|fi|cud)}t j| D]\}|}d*|i|d<d+vr|jd}nd}|D]I}||d <|jd"||d!||d|d#fi||j||d!||d|fi|K|s~||d <|jd$|zfi||j|fi||d}d,|d <d*|i|d<|jd"|z|z|d#zfi||j||z|fi|y)-aGenerate routes for a controller resource The member_name name should be the appropriate singular version of the resource given your locale and used with members of the collection. The collection_name name will be used to refer to the resource collection methods and should be a plural version of the member_name argument. By default, the member_name name will also be assumed to map to a controller you create. 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', 'messages', 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', 'messages', 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', 'messages', 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', 'messages', controller='categories', path_prefix='/category/:category_id', name_prefix="category_") # GET /category/7/message/1 # has named route "category_message" ``requirements`` A dictionary that restricts the matching of a variable. Can be used when matching variables with path_prefix. Example:: map.resource('message', 'messages', path_prefix='{project_id}/', requirements={"project_id": R"\d+"}) # POST /01234/message # success, project_id is set to "01234" # POST /foo/message # 404 not found, won't be matched by this route ``parent_resource`` A ``dict`` containing information about the parent resource, for creating a nested resource. It should contain the ``member_name`` and ``collection_name`` of the parent resource. This ``dict`` will be available via the associated ``Route`` object which can be accessed during a request via ``request.environ['routes.route']`` If ``parent_resource`` is supplied and ``path_prefix`` isn't, ``path_prefix`` will be generated from ``parent_resource`` as "/:_id". If ``parent_resource`` is supplied and ``name_prefix`` isn't, ``name_prefix`` will be generated from ``parent_resource`` as "_". Example:: >>> from routes.util import url_for >>> m = Mapper() >>> m.resource('location', 'locations', ... parent_resource=dict(member_name='region', ... collection_name='regions')) >>> # path_prefix is "regions/:region_id" >>> # name prefix is "region_" >>> url_for('region_locations', region_id=13) '/regions/13/locations' >>> url_for('region_new_location', region_id=13) '/regions/13/locations/new' >>> url_for('region_location', region_id=13, id=60) '/regions/13/locations/60' >>> url_for('region_edit_location', region_id=13, id=60) '/regions/13/locations/60/edit' Overriding generated ``path_prefix``:: >>> m = Mapper() >>> m.resource('location', 'locations', ... parent_resource=dict(member_name='region', ... collection_name='regions'), ... path_prefix='areas/:area_id') >>> # name prefix is "region_" >>> url_for('region_locations', area_id=51) '/areas/51/locations' Overriding generated ``name_prefix``:: >>> m = Mapper() >>> m.resource('location', 'locations', ... parent_resource=dict(member_name='region', ... collection_name='regions'), ... name_prefix='') >>> # path_prefix is "regions/:region_id" >>> url_for('locations', region_id=51) '/regions/51/locations' r2r+r r'NrCparent_resourcer%z/: member_name_idz%s_r#rbrctj|D]4\}}|j|jgj |6|S)ziSwap the keys and values in the dict, and uppercase the values from the dict during the swap.)rDrErupperr)dctnewdctrOrs rswapzMapper.resource..swapVsF MM#. ?S!!#))+r299#> ?Mrrgrr rkrrmrrz/newz/:(id)r(_filter)r( _member_name_collection_name_parent_resourcerQ requirementsc^j}dk7rd|jgi|d<|S)zUReturns a new dict to be used for all route creation as the route optionsanyrYry)rzrM)methoptsrYoptionss rrequirements_forz)Mapper.resource..requirements_for{s3<<>D&.%?\"KrrUrT formatted_z .:(format)z %s.:(format)r rY)rUrynew_z [^\/]+(?"  "*b1fb)3m  %%fb188HE!!%,33Ax@!!(B/66q(C#?3 #K0 K' ;#-$z1D#D&=Xo !**\:>' / /zz),   V #&,^&$G,V4M .*0 h'*5vO  \J6-v97I:GI ZOV)L.,.  .*1 h' ^o=OO _> > ?"  \K//A$|3 @ @  [?2O P#E70C PGN P==5 HKFC,V4M H +*0 h'U?#D%- %.,. [4/GG H H 1==8 ;KFC,V4M-13F,GM. )33''!* O*0 h' K4?A2=vF. -. +v{K(3V<O@MO  O*1 h' ^k9K]K [:M:% ;*)/ "( h)-/B(C n% \K/+= </ B3@ B [;. M}Mrc>gd}dg}|jdd}ii} }||zD]} | |vs|| || <d|d<|D]} | |vs|| | | <|j|fi| |jd} |jdt| z|fi|d| _|| _y ) aAdd a redirect route to the mapper Redirect routes bypass the wrapped WSGI application and instead result in a redirect being issued by the RoutesMiddleware. As such, this method is only meaningful when using RoutesMiddleware. By default, a 302 Found status code is used, this can be changed by providing a ``_redirect_code`` keyword argument which will then be used instead. Note that the entire status code string needs to be present. When using keyword arguments, all arguments that apply to matching will be used for the match, while generation specific options will be used during generation. Thus all options normally available to connected Routes may be used with redirect routes as well. Example:: map = Mapper() map.redirect('/legacyapp/archives/{url:.*}', '/archives/{url}') map.redirect('/home/index', '/', _redirect_code='301 Moved Permanently') )rrrrQ_redirect_codez 302 FoundT_staticrz _redirect_%sN)r2rIrr^redirectredirect_status) r match_pathdestination_pathrr0 both_argsgen_args status_codegen_dict match_dictrO match_routes rrpzMapper.redirects6< ;jj!1;? !2*x' ,Cf} &s   ,# .C(""(+ 3 .  Z.:.nnR(  ^bo57G ! !# &1 #r)r#rq)NN)r3r4r5r6rrArrrrpropertyrrrrIrrrrrrr8rlrpr9rrr}r};s (7$"TD^!@, $"w1G)V%6#p("T,+"Z;&z..cJdNL 22rr})r6r itertoolsrrr repoze.lrurrDrr routes.utilrrr routes.router r7r8robjectrrrWr}r9rrrso  ! 05pfpf[ [ ~B2_B2r