
    ^.ht                     R    d dl Z d dlZd dlZd dlmZ d dlmZm	Z	m
Z
  G d de      Zy)    N)parse)
_url_quote_str_encode
as_unicodec                   |    e Zd ZdZdgZdZd Zd Zd Zd Z	d Z
d	 Zd
 ZddZddZddZ	 	 ddZd Zd ZddZy)RouteztThe Route object holds a route recognition and generation
    routine.

    See Route.__init__ docs for usage.

    requirements)/,;.#c                    || _         d| _        d| _        d| _        || _        || _        |j                  dd      | _        |j                  dd      | _        |j                  di       | _
        d| _        |j                  dd      | _        |j                  d	d      | _        |j                  d
d      | _        |j                  dd      | _        |j                  dd      | _        |j                  dd      | _        |j                  dd      | _        |j                  dd      | _        | j                  rd| j                   v | _        d| _        |j+                  d      r| j                  r
|dd | _         | j-                          y)aR  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(None, ':controller/:action/:id')
            >>> sorted(newroute.defaults.items())
            [('action', 'index'), ('id', None)]
            >>> newroute = Route(None, 'date/:year/:month/:day',
            ...     controller="blog", action="view")
            >>> newroute = Route(None, '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.

        FN	_minimize	_encodingzutf-8r	   replace_static_filter	_absolute_member_name_collection_name_parent_resource
conditions	_explicitz://r
      )	routepathsub_domainspriorredirectname_kargspopminimizationencodinggetreqsdecode_errorsstaticfilterabsolutemember_namecollection_nameparent_resourcer   explicitexternal
startswith_setup_route)selfr    r   kargss       `/var/www/html/School_Mangement_New/src/backend/venv/lib/python3.12/site-packages/routes/route.py__init__zRoute.__init__   s]   0 # 
	!IIk59		+w7IInb1	& ii	51ii	40		+u5 !99^T:$yy);TB$yy);TB  ))L$7 		+u5 ;;!T^^3DM %D $):):&qr]DN    c                      j                   j                        x _        }t        d |D              t        d |D               _         j
                  s j                          i  _        t        j                   j                        D ]-  \  }}t        j                  d|z   dz          j                  |<   /  j                   j                   j                  j!                               \   _        }|z   _         j'                  |d d        \   _         _        t         fd j$                  D               _        t         j"                  j/                                _        y )Nc              3   F   K   | ]  }t        |t              r|d      yw)r    N
isinstancedict.0keys     r4   	<genexpr>z%Route._setup_route.<locals>.<genexpr>Y   s%      8c!+C!6 "&k 8s   !c              3   V   K   | ]!  }t        |t              r|d    dk(  r|d    # yw)typer   r    Nr9   r<   s     r4   r?   z%Route._setup_route.<locals>.<genexpr>[   s1      !5$.sD$9!$V!3 "%V !5s   ')^$c              3   H   K   | ]  }|vrj                   |   |  y wN)defaults)r=   r>   	routekeysr2   s     r4   r?   z%Route._setup_route.<locals>.<genexpr>t   s1      #J3&)&:*.--*<*H $' #Js   ")	_pathkeysr   	routelist	frozensetdotkeysr#   make_full_routereq_regssix	iteritemsr&   recompile	_defaultsreserved_keysr!   copyrF   maxkeys_minkeysminkeysroutebackwards	hardcodedkeys_default_keys)r2   rI   r>   valdefaultkeysrG   s   `    @r4   r1   zRoute._setup_routeV   sE   %)^^DNN%CC 8Y 8 8	  !5	 !5 5     " dii0 	=HC!#C#IO!<DMM#	= (,~~i6:6H6H6:kk6F6F6H(J$ #Y. /3mmIaL.I+t* # #J$,, #J J
 't}}'9'9';<r6   c                     d}| j                   D ]&  }t        |t              r|d|d   z   dz   z  }"||z  }( || _        y)zJMake a full routelist string for use with non-minimized
        generation z%(r    z)sN)rI   r:   r;   regpath)r2   r`   parts      r4   rL   zRoute.make_full_route{   sP     NN 	 D$%4$v,.554		 
 r6   c                     t        |t        j                        r|S t        |t              r|j	                  | j
                        S t        |      r|S t        j                  |      S )z3Transform the given argument into a unicode string.)r:   rN   	text_typebytesdecoder$   callable)r2   ss     r4   make_unicodezRoute.make_unicode   sM    a'H5!88DMM**a[H==##r6   c                    d}d}d}d}d}d}g }|D ]1  }	|r|	dv r||	z  }n|d|	z   z  }d}|	dk(  rd}#|	dv r|s| j                   r|	dv r4|s2d}d}|	}|	dk(  rd	}d}t        |      d
kD  sY|j                  |       d}m|r|rd}|	dk(  rd}{|	}| j                  dz   }|r
|	|vr||	z  }|rd}|dk(  rH|d
   dk(  rd}|dd }nd}|j	                  d      }
t        |
      dkD  r|
d
   }|
d   | j
                  |<   |j                  t        ||             |	| j                  v r|j                  |	       dx}x}}-||	z  }4 |r|j                  t        ||             |S |r|j                  |       |S )zYUtility function to walk the route, and pull out the valid
        dynamic/wildcard keys.Fr_   )\:*{}rj   T)rk   rl   rm   )rm   rm   rn   r   ())-r   r   Nrk   )rA   r    )r(   lenappend
done_charssplitr&   r;   )r2   r   
collectingescapingcurrentdone_onvar_typejust_startedrI   charoptss              r4   rH   zRoute._pathkeys   s    
	 .	 D55tOGtd{*G (DKK%-
#!
3;!G#(Lw<!#$$W- G$3;!G"G"oo6GG 34"
s?qzS(#&")!"+#&"==-D4y1}"&q'-1!W		'*  8'!BC4??*$$T*/111(W4].	 ^ Txg>?  W%r6   c                    g }|dd }| j                   s9|D ]'  }t        |t              s|j                  |d          ) t	        |      |fS d}|j                          |D ]]  }t        |t              s|| j                  vrd}$t        |t              s5|d   }|| j                  v r|sK|j                  |       d}_ t	        |      |fS )a  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

        Nr    FT)r#   r:   r;   rs   rJ   reversert   rF   )r2   rI   rW   	backcheckra   gapsr>   s          r4   rV   zRoute._minkeys   s     aL	   ! 1dD)NN4<01 g&	22 
	DdD)d$//.Id+v,Cdmm#DNN3D
	 '"I..r6   c                    i }d|vrd|vr| j                   sd|d<   d|vrd|vr| j                   sd|d<   t        fd|j                         D              }|D ]$  }||   | j                  ||         ||<    d||<   & d|v rd|vr| j                   sd|d<   d|v rd|vr| j                   sd|d<   t        fd|j                         D              }||fS )	a  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

        
controllercontentactionindexc              3   *   K   | ]
  }|vr|  y wrE    r=   r>   rS   s     r4   r?   z"Route._defaults.<locals>.<genexpr>  s        =#&m#; !$  =   Nidc              3   *   K   | ]
  }|vr|  y wrE   r   r   s     r4   r?   z"Route._defaults.<locals>.<genexpr>  s"      #@3&)&> $' #@r   )r.   rJ   rZ   rh   )r2   rG   rS   r3   rF   r]   r>   newdefaultkeyss     `     r4   rR   zRoute._defaults   s    y(\-F=="+E,9$)>==%E(O  =uzz|  = = 	%CSz% $ 1 1%* = $		%
 y XX%===!(HX9X!5==!HTN" #@(--/ #@ @ .))r6   c                    | j                   rC| j                  | j                  ||      d   }|sd}|dz   dz   }|j                  d      sd|z   }n| j	                  ||      }d|z   }|s|S || _        t        j                  |      | _        y)a\  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.

        include_names indicates whether this should be a match regexp
        assigned to itself using regexp grouping names, or if names
        should be excluded for use in a single larger regexp to
        determine if any routes match

        r   r
   z/?rC   rB   N)	r#   buildnextregrI   r0   buildfullregregexprP   rQ   regmatch)r2   clistinclude_namesregs       r4   
makeregexpzRoute.makeregexp  s      ##DNNE=I!LC*s"C>>#&Ci##E=9CCiJ

3r6   c                    g }| j                   D ]  }t        |t              r|d   }|dk(  r*dj                  t	        t
        j                  |            }no|d   dk(  r | j                  j                  |      xs d}nG|d   dk(  r | j                  j                  |      xs d}n| j                  j                  |      xs d	}|r
d
|d|d}nd|z  }|d   dk(  r|j                  d|z         |j                  |       |j                  t        j                  |              dj                  |      dz   }|S )zqBuild the regexp by iterating through the routelist and
        replacing dicts with the appropriate regexp matchr    r   |rA   rk   z[^/]+?r   z[^/.]+?z.+?(?P<>rp   (?:%s)
(?:\.%s)??r_   rC   )
rI   r:   r;   joinmaprP   escaper&   r%   rs   )	r2   r   r   regpartsra   var	partmatchregpartr   s	            r4   r   zRoute.buildfullreg=  s    NN 	1D$%6l,& #RYY)> ?I&\S( $		c 2 >hI&\S( $		c 2 ?iI $		c 2 ;eI .19=G&2G<3&OOMG$;<OOG,		$0)	1* "S(r6   c           	      <   |r|d   }nd}d}d\  }}}t        |dd       dkD  r!|| _        | j                  |dd ||      \  }}}t        |t              r|d   dv r|d   }	|d   }
d}|	| j
                  v r8|rd	|	d
| j
                  |	   d}nd| j
                  |	   z  }|
dk(  ryd|z  }nr|	dk(  rb|r2d	|	d
dj                  t        t        j                  |            d}n9ddj                  t        t        j                  |            z  }n| j                  dv r.|rd	|	z   dz   | j                  z   dz   }nd| j                  z   dz   }n|s&|
dk(  rd}nd}|r
d	|	d|d}nd|z  }|
dk(  rd|z  }ndj                  | j                        }|}|d   dk(  rt        |      dkD  r|d   }n'|j                  d      rt        |      dkD  r|d   }n|}t        |      t        dg      z  }|rd	|	ddj                  |      d}nddj                  |      z  }|	| j
                  v rd}|	| j                  vrd}d}|r|	| j
                  v r|	| j                  v rd|z   |z   dz   }n|	| j
                  v r	d}||z   }n|	| j                  v r| j                  dv r||z   }np|	| j                  v r
|dz   |z   }nXd}||z   }nO|r|	| j                  v rd|z   |z   dz   }n2||z   }n+t        |t              r|d   d k(  r|d   }	|r#|r	d!|	z  |z   }nd"|z   }|	| j                  vrd}d}n|r|	| j                  v r|r	d!|	z  |z   }nd"|z   }n|	| j                  v r|r	d!|	z  |z   }nd"|z   }n|r	d!|	z  |z   }nd"|z   }d}d}n|rv|d#   | j                  v re|r=t        j                  |dd#       dz   t        j                  |d#         z   |z   }|dz  }nBd}|dk(  rd$|z   }n5t        j                  |      |z   }nd}d}t        j                  |      |z   }|||fS )%zRecursively 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.

        r   r_   )r_   TTr   NrA   rk   r   r    r   r   rp   r   r   r   r   r   )r
   r   z>[^z]+?)z(?:[^z/.r
   z(?:[^%s]+?)rj   z(\   Fz(?:z)?)r   r   r   ?rl   z
(?P<%s>.*)z(?:.*)z\/)rr   r   r   r:   r;   r&   r   r   rP   r   rt   r0   rJ   rF   )r2   pathr   r   ra   r   restnoreqsallblankr   typpartregexclude_charsendrems                  r4   r   zRoute.buildnextregY  s    7DD
 $4 vxtABx=1DJ'+'8'8ab59F(H$T68dD!d6lj&@v,Cv,CG dii .1499S>BG&37G#:+g5G$ .1388C		@E=G 4H IG '#bii2G)HHGz) $slU2TZZ?&HG%

2V;Gcz(,(+$7:M"J"/-"?cz"/'"9''$//2CC1v~#c(Q,!!f.3s8a<!!f!#C.9cU+;;C$7:BGGCL"I"/"''#,">dii$--'  
 $))#t}}(<'/D047C DII%$H!D.C DMM)djjO.K!D.C DMM)!C-$.C
  %H!D.C t}} 4'/D047C
 "D.Cd#V(;v,C &,t3C"T/Cdmm+$H"Ft}} 4$*S047&oDMM)$*S047&o$*S047&o$H"Fd2h$//1iiSb	*U2RYYtBx5HH4Ot  3;$,C))D/D0C
 FH))D/D(CVX&&r6   Nc                 D   | j                   ry| j                  j                  |      }|syd}|rW|rUd|v rQ|d   j                  d      d   }t	        j
                  d|z        }	t	        j                  |	d|      }
|
|vr||
k7  r|
}| j                  rmd| j                  v r|r|d	   | j                  d   vry| j                  j                  d
      }|r|sy|sd
| j                  v r|ryt        |t              r||vry|j                         }i }| j                  t        |j                               z
  }t        j                   |      D ]o  \  }}|dk7  r.| j"                  r"	 t%        || j"                  | j&                        }|s0|| j*                  v r"| j*                  |   r| j*                  |   ||<   k|||<   q |D ]  }| j*                  |   ||<    |r||d
<   | j                  r%d| j                  v r | j                  d   ||      sy|S # t(        $ r Y  yw xY w)a  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.

        FN	HTTP_HOSTrk   r   z^(.+?)\.%s$z\1methodREQUEST_METHOD
sub_domain	path_infofunction)r(   r   matchru   rP   rQ   subr   r%   r:   list	groupdictr[   rJ   rZ   rN   rO   r$   r   r'   UnicodeDecodeErrorrF   )r2   urlenvironr   sub_domains_ignoredomain_matchr   r   host	sub_match	subdomainuse_sd	matchdictresultextrasr>   r\   s                    r4   r   zRoute.match	  s"    ;;##C(
7{g'=;'--c215D

>L#@AIy%6I 22ty7H&
??4??*w,-T__X5NN __((6Fj ?J&$'Jf,DOO%	##i	0@&AAi0 	"HCk!dmm!$S$--9K9KLC 3$--/DMM#4F"mmC0s!s	"  	-C--,F3K	- #-F<  ??zT__</DOOJ/@) * ! !s   %!H	HHc                 N   | j                   | j                  z
  D ]=  }||vr y| j                  ||         | j                  | j                  |         k7  s= y | j                  D ]!  }||vs||   || j                  v rd||<   ! y |D ]  }|| j                   v s|| j                  v r:||   s&t        dt        ||   | j                        z   | j                        ||<   Zt        t        ||   | j                        | j                        ||<    | j                  |z  S )z)Generate a non-minimal version of the URLFr_   r   )	rU   rW   rh   rF   rK   	url_quoter   r$   r`   )r2   r3   kargs       r4   generate_non_minimizedzRoute.generate_non_minimizedV  s3   
 , 	A~""58,%%dmmA&678	 << 	!C%5:#5$,,&!#E#J 	!  	8ADLL $Qx#,S:eAh-1]]4< .<=A]]$La  )E!Hdmm)L)- 8E!H	8 ||e##r6   c                    | j                   }g }d}|D ]  }t        |t              r|d   dv r|d   }||v }|| j                  v }|r|s|s9|r8|r6| j	                  ||         | j	                  | j                  |         k(  r|ss|r
||   |r|s|r||   }	n,|r| j                  |   | j                  |   }	n|d   dk(  r yt        |	| j                        }	|j                  t        |	| j                               |d   dk(  r|j                  d       |r||= d}t        |t              rK|d   dk(  rC|d   }|j                  |      }
|
B|j                  t        |
| j                               d}k|rR|d	   | j                  v rA|s|| j                  v r|s|j                  |dd	        d}d}|j                  |       d}|j                  |        |j                          d
j                  |      }|S )z'Generate a minimized version of the URLFrA   r   r    Nr   Trl   r   r_   )rX   r:   r;   rF   rh   r   r$   rs   r   r%   rt   r   r   )r2   r3   rI   urllistr   ra   r   has_arghas_defaultr\   karr   s               r4   generate_minimizedzRoute.generate_minimizedw  s   ''	 @	%D$%$v,**D6l ,!T]]2
 wt  G%%eCj1))$--*<=>FJ uSz1k$ *C T]]3%7%C--,C&\S( ! dmm4ydmm<=<3&NN3'c
D$'DLC,?6liin?NN9S$--#@AD$r(doo5 7NN49-DDNN4(t$A@	%B 	ggg
r6   c           	         |sb| j                   j                         D ]E  }|j                  |      }|s| j                  |   j	                  | j                  |            rE y t        |j                  d      | j                        }|rK| j                  r.d| j                  v r |j                         | j                  d   vry|j                  d       | j                  r| j                  |      }n| j                  |      }|du r|S |j                  d      s| j                  sd|z   }t!        |j                               | j"                  z
  }|r|r|j%                  d      s|dz  }g }	|D ]  }||vr|dk(  s|dk(  r||   }t'        |t(        t*        f      rE|D ]?  }
t        |
| j                        }
|	j-                  |t/        |
| j                        f       A st        || j                        }|	j-                  |t/        || j                        f        |	r|dz  }|t1        j2                  |	      z  }|S |r|j%                  d      s|dz  }|S )zGenerate 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.

        Fr   r
   r   r   r   )r&   rZ   r%   rM   r   rh   r   r$   r   upperr"   r#   r   r   r0   r(   rJ   rU   endswithr:   tupler   rs   r   urlparse	urlencode)r2   _ignore_req_list_append_slashr3   r>   r\   methr   r   	fragmentsvalues              r4   generatezRoute.generate  s:     yy~~' !iint}}S1778I8I#8NO ! %))H-t}}=8t#>

DOOH,EEIIh))%0C--e4C%<J~~c"4;;)C5::<(4<<7S\\#%6s
I  Mf$(?c\&9CjcE4=1!$ L *5$-- @!((#{5;?==0J *K LL
 %S$--8C$$c;sDMM+J%KLM s
x)))44 
 3<<#43JC
r6   )T)NFNr_   )FF)__name__
__module____qualname____doc__rS   rt   r5   r1   rL   rh   rH   rV   rR   r   r   r   r   r   r   r   r   r6   r4   r   r   
   ss     $$M +J=~#=J		$=~"/H$*L!(F8n'` 4946KZ$BHT;r6   r   )rP   sysrN   six.moves.urllibr   r   routes.utilr   r   r   r   objectr   r   r6   r4   <module>r      s%    	 
 
 . H HrF rr6   