|
Server : Apache System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64 User : njnconst ( 1116) PHP Version : 8.4.18 Disable Function : NONE Directory : /lib64/python2.7/site-packages/django/utils/ |
Upload File : |
�
r�\c @ s� d Z d d l m Z d d l m Z d d l m Z i
d d 6d d 6d d 6d d 6d
d 6d d
6d
d 6d
d 6d d 6d d 6Z d e f d � � YZ
d e f d � � YZ d e f d � � YZ d � Z
d � Z d � Z d � Z d � Z d � Z d S( u
Functions for reversing a regular expression (used in reverse URL resolving).
Used internally by Django and not intended for external use.
This is not, and is not intended to be, a complete reg-exp decompiler. It
should be good enough for a large class of URLS, however.
i����( t unicode_literals( t six( t zipu Au bu Bu 0u du xu Du u su Su wu !u Wu Zt Choicec B s e Z d Z RS( u�
Used to represent multiple possibilities at this point in a pattern string.
We use a distinguished type, rather than a list, so that the usage in the
code is clear.
( t __name__t
__module__t __doc__( ( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyR s t Groupc B s e Z d Z RS( uD
Used to represent a capturing group in the pattern string.
( R R R ( ( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyR $ s t
NonCapturec B s e Z d Z RS( uH
Used to represent a non-capturing group in the pattern string.
( R R R ( ( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyR ) s c C ss g } g } t } t t | � � } d } y t | � \ } } Wn t k
r] d g f g SXy�x�t r-| r� | j | � n�| d k r� | j d � nm| d k r� t � nX| d k r� nI| d k r� Pn9| d k r | j � } t | | � } | | | g } n�| d k rwt | � \ } } | j | � t | � \ } } x�| s^| d k rst | � \ } } qLWn�| d
k rUt | � \ } } | d k s�| r�d | }
| d
7} | j t d |
|
f � � t
| | � q t | � \ } } | d k rt
| | � q | d k r8| j t | � � q | d k rWt d | � � q t | � \ } } | d k r�t d | � � n | d k r�d } n d } g }
t | � \ } } x/ | | k r�|
j | � t | � \ } } q�Wd j
|
� } | d k r5| j t d | | f � � t
| | � q | j t d | d f � � n� | d k r�t | | � \ }
} | r�t } n |
d k r�t | d t � r�t d | d g � | d <q�| j � q |
d
k r | j | d g |
d
� q n
| j | � | r$t | � \ } } qd t } qd WWn+ t k
rBn t k
r\d g f g SXt t t | � � � S( u�
Given a reg-exp pattern, normalizes it to an iterable of forms that
suffice for reverse matching. This does the following:
(1) For any repeating sections, keeps the minimum number of occurrences
permitted (this means zero for optional groups).
(2) If an optional group includes parameters, include one occurrence of
that group (along with the zero occurrence case from step (1)).
(3) Select the first (essentially an arbitrary) element from any character
class. Select an arbitrary character for any unordered class (e.g. '.'
or '\w') in the pattern.
(5) Ignore comments and any of the reg-exp flags that won't change
what we construct ("iLmsu"). "(?x)" is an error, however.
(6) Raise an error on all other non-capturing (?...) forms (e.g.
look-ahead and look-behind matches) and any disjunctive ('|')
constructs.
Django's URLs for forward resolving are either all positional arguments or
all keyword arguments. That is assumed here, as well. Although reverse
resolving can be done using positional args when keyword args are
specified, the two cannot be mixed in the same reverse() call.
i u u .u |u ^u $u )u [u ]u (u ?u _%di u %%(%s)su iLmsu#u :u Pu& Non-reversible reg-exp portion: '(?%s'u <u =u' Non-reversible reg-exp portion: '(?P%s'u >u *?+{i����( u <u =N( t Truet next_chart itert nextt
StopIterationt appendt NotImplementedErrort popR R t walk_to_endt lent
ValueErrort joint Nonet get_quantifiert Falset containsR t extendt listR t flatten_result( t patternt resultt non_capturing_groupst consume_nextt pattern_itert num_argst cht escapedt startt innert namet
terminal_chart paramt count( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyt normalize. s�
"
c c sm xf | D]^ } | d k r* | t f Vq n t | � } t j | | � } | d k rZ q n | t f Vq Wd S( u�
An iterator that yields the next character from "pattern_iter", respecting
escape sequences. An escaped character is replaced by a representative of
its class (e.g. \w -> "x"). If the escaped character is one that is
skipped, it is not returned (the next character is returned instead).
Yields the next character, along with a boolean indicating whether it is a
raw (unescaped) character or not.
u \N( R R t ESCAPE_MAPPINGSt getR R ( t
input_iterR" t representative( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyR
� s
c C s~ | d k r d } n d } x\ | D]T \ } } | r: q" q" | d k rS | d 7} q" | d k r" | si d S| d 8} q" q" Wd S( u�
The iterator is currently inside a capturing group. We want to walk to the
close of this group, skipping over any nested groups and handling escaped
parentheses correctly.
u (i i u )N( ( R" R- t nestingR# ( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyR � s
c C s$ | d k rq y t | � \ } } Wn t k
r; d
} n X| d k rQ d
} n | d k rg d | f Sd | f Sg } x/ | d k r� t | � \ } } | j | � qz W| d } d j | � j d � } y t | � \ } } Wn t k
r� d
} n X| d k rd
} n t | d � | f S( u&
Parse a quantifier from the input, where "ch" is the first character in the
quantifier.
Returns the minimum number of occurences permitted by the quantifier and
either None or the next character from the input_iter if the next character
is not part of the quantifier.
u *?+u ?u +i i u }i����u u ,N( R R
R R R t splitt int( R" R- t ch2R# t quantt values( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyR � s.
c C sM t | | � r t St | t � rI x$ | D] } t | | � r) t Sq) Wn t S( u\
Returns True if the "source" contains an instance of "inst". False,
otherwise.
( t
isinstanceR R R R ( t sourcet instt elt( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyR s
c C s� | d k r d g g g f St | t � re | d d k rD g } n
| d g } | d g | g f Sd g } g g } d } } x�t | � D]�\ } } t | t j � r� q� n d j | | | !� } t | t � r� | | d 7} | d } n d } | d } xD t t | � � D]0 } | | c | 7<| r| | j | � qqWt | t
t f � r� t | t � ry| g } n g g }
} x: | D]2 } t | � \ }
} |
j
|
� | j
| � q�Wg } g } x` t | | � D]O \ } } x@ t |
| � D]/ \ } } | j | | � | j | | � q�Wq�W| } | } q� q� W| | k r�d j | | � } x- t t | � � D] } | | c | 7<qwWn | | f S( u�
Turns the given source sequence into a list of reg-exp possibilities and
their arguments. Returns a list of strings and a list of argument lists.
Each of the two lists will be of the same length.
u i i N( R R5 R t enumerateR t string_typesR t rangeR R R R R R R ( R6 t paramsR t result_argst post lastR8 t pieceR( t it inner_resultt
inner_argst itemt rest argst
new_resultt new_argst i_itemt i_args( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyR " sX
N( R t
__future__R t django.utilsR t django.utils.six.movesR R R+ R R R R R* R
R R R R ( ( ( s; /tmp/pip-install-XxeQeY/django/django/utils/regex_helper.pyt <module> s.
� $