
    af\                        d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZmZ ddlmZ ddlmZmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZmZ ddlmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6m7Z7 ddl8m9Z9 ddl:m;Z; ddl<m=Z= ddl>m?Z? ddl@mAZB ddl@mCZC dZD G d d          ZE G d deE          ZF G d deE          ZG G d deG          ZH G d deG          ZI G d  d!eE          ZJ G d" d#eJ          ZK G d$ d%eJ          ZL G d& d'          ZM G d( d)eJ          ZN G d* d+eE          ZO G d, d-eF          ZP G d. d/eF          ZQ G d0 d1eE          ZR G d2 d3eR          ZS G d4 d5eF          ZT G d6 d7eE          ZU G d8 d9eU          ZV G d: d;eE          ZW G d< d=eW          ZX G d> d?eW          ZY G d@ dAeY          ZZ G dB dCeE          Z[ G dD dEeE          Z\ G dF dGeW          Z] G dH dIe\          Z^ G dJ dKeF          Z_ G dL dMeF          Z` G dN dOeF          Za G dP dQeb          Zc G dR dSeb          Zd G dT dUeF          ZedS )Vz
Field classes.
    N)DecimalDecimalException)BytesIO)urlsplit
urlunsplit)settings)
validators)ValidationError
BoundField)from_current_timezoneto_current_timezone)FILE_INPUT_CONTRADICTIONCheckboxInputClearableFileInput	DateInputDateTimeInput
EmailInput	FileInputHiddenInputMultipleHiddenInputNullBooleanSelectNumberInputSelectSelectMultipleSplitDateTimeWidgetSplitHiddenDateTimeWidgetTextarea	TextInput	TimeInputURLInput)formats)normalize_choices)parse_datetimeparse_duration)RemovedInDjango60Warning)duration_string)clean_ipv6_address)_lazy_re_compile)gettext_lazy)ngettext_lazy)Field	CharFieldIntegerField	DateField	TimeFieldDateTimeFieldDurationField
RegexField
EmailField	FileField
ImageFieldURLFieldBooleanFieldNullBooleanFieldChoiceFieldMultipleChoiceField
ComboFieldMultiValueField
FloatFieldDecimalFieldSplitDateTimeFieldGenericIPAddressFieldFilePathField	JSONField	SlugFieldTypedChoiceFieldTypedMultipleChoiceField	UUIDFieldc                        e Zd ZeZeZg Zd ed          iZ	 e
ej                  Zddddddddddddd fd	
Zd
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Z xZS )r,   requiredzThis field is required.TN F )rI   widgetlabelinitial	help_texterror_messagesshow_hidden_initialr	   localizedisabledlabel_suffixtemplate_namec                   |||c| _         | _        | _        || _        || _        |
| _        || _        |p| j        }t          |t                    r |            }nt          j        |          }|	| _        | j        rd|_        | j         |_        |                     |          }|r|j                            |           || _        i }t%          | j        j                  D ]&}|                    t+          |di                      '|                    |pi            || _        g | j        || _        || _        t5                                                       d S )NTdefault_error_messages)rI   rM   rN   rQ   rO   rS   rT   rL   
isinstancetypecopydeepcopyrR   is_localizedis_requiredwidget_attrsattrsupdatereversed	__class____mro__getattrrP   default_validatorsr	   rU   super__init__)selfrI   rL   rM   rN   rO   rP   rQ   r	   rR   rS   rT   rU   extra_attrsmessagescrb   s                   E/var/www/html/env/lib/python3.11/site-packages/django/forms/fields.pyrg   zField.__init__c   sq   N 3;E7/tz4<#6 " (&4;fd## 	+VXXFF]6**F != 	'"&F "] ''// 	-L,,,$.011 	F 	FAOOGA'?DDEEEE,"---&AD3AjA*    c                     |S NrK   rh   values     rl   prepare_valuezField.prepare_value       rm   c                     |S ro   rK   rp   s     rl   	to_pythonzField.to_python   rs   rm   c                 b    || j         v r#| j        rt          | j        d         d          d S d S NrI   code)empty_valuesrI   r
   rP   rp   s     rl   validatezField.validate   s@    D%%%$-%!$"5j"A
SSSS &%%%rm   c                 :   || j         v rd S g }| j        D ]t}	  ||           # t          $ rY}t          |d          r%|j        | j        v r| j        |j                 |_        |                    |j                   Y d }~md }~ww xY w|rt          |          d S )Nry   )	rz   r	   r
   hasattrry   rP   messageextend
error_list)rh   rq   errorsves        rl   run_validatorszField.run_validators   s    D%%%F 	, 	,A,%" , , ,1f%% <!&D4G*G*G $ 3AF ;AIal++++++++,  	*!&)))	* 	*s   $
BABBc                     |                      |          }|                     |           |                     |           |S )z
        Validate the given value and return its "cleaned" value as an
        appropriate Python object. Raise ValidationError for any errors.
        )ru   r{   r   rp   s     rl   cleanzField.clean   s@    
 u%%eE"""rm   c                     | j         r|S |S )a'  
        Return the value that should be shown for this field on render of a
        bound form, given the submitted POST data for the field and the initial
        data, if any.

        For most fields, this will simply be data; FileFields need to handle it
        a bit differently.
        rS   rh   datarN   s      rl   
bound_datazField.bound_data   s     = 	Nrm   c                     i S )z
        Given a Widget instance (*not* a Widget class), return a dictionary of
        any HTML attributes that should be added to the Widget, based on this
        Field.
        rK   )rh   rL   s     rl   r^   zField.widget_attrs   s	     	rm   c                     | j         rdS 	 |                     |          }t          | d          r,|                     |          |                     |          k    S n# t          $ r Y dS w xY w||nd}||nd}||k    S )z)Return True if data differs from initial.F_coerceTNrJ   )rS   ru   r}   r   r
   )rh   rN   r   initial_value
data_values        rl   has_changedzField.has_changed   s     = 	5	>>$''DtY'' C||D))T\\'-B-BBBC 	 	 	44	
 $+#6B!-TT2

**s   AA 
A+*A+c                 $    t          || |          S )zu
        Return a BoundField instance that will be used when accessing the form
        field in a template.
        r   )rh   form
field_names      rl   get_bound_fieldzField.get_bound_field   s    
 $j111rm   c                     t          j         |           }||t          |           <   t          j        | j        |          |_        | j                                         |_        | j        d d          |_        |S ro   )rZ   idr[   rL   rP   r	   )rh   memoresults      rl   __deepcopy__zField.__deepcopy__   sb    4RXXdk488 $ 3 8 8 : : OAAA.rm   )__name__
__module____qualname__r   rL   r   hidden_widgetre   _rW   listr	   EMPTY_VALUESrz   rg   rr   ru   r{   r   r   r   r^   r   r   r   __classcell__rb   s   @rl   r,   r,   V   sL       F   	AA/00 4
/00L
 !J J J J J J JX    T T T* * *      + + +&2 2 2      rm   r,   c                   :     e Zd Zddddd fd
Zd Z fdZ xZS )r-   NTrJ   )
max_length
min_lengthstripempty_valuec                   || _         || _        || _        || _         t	                      j        di | |9| j                            t          j        t          |                               |9| j                            t          j
        t          |                               | j                            t          j                               d S NrK   )r   r   r   r   rf   rg   r	   appendMinLengthValidatorintMaxLengthValidatorProhibitNullCharactersValidator)rh   r   r   r   r   kwargsrb   s         rl   rg   zCharField.__init__
  s     %$
&""6"""!O"":#@Z#Q#QRRR!O"":#@Z#Q#QRRRzIKKLLLLLrm   c                     || j         vr*t          |          }| j        r|                                }|| j         v r| j        S |S )Return a string.)rz   strr   r   rp   s     rl   ru   zCharField.to_python  sN    )))JJEz &D%%%##rm   c                     t                                          |          }| j        |j        st	          | j                  |d<   | j        |j        st	          | j                  |d<   |S )N	maxlength	minlength)rf   r^   r   	is_hiddenr   r   rh   rL   r_   rb   s      rl   r^   zCharField.widget_attrs"  sg    $$V,,?&v/?&!$T_!5!5E+?&v/?&!$T_!5!5E+rm   )r   r   r   rg   ru   r^   r   r   s   @rl   r-   r-   	  sz         T2M M M M M M M          rm   r-   c                   p     e Zd ZeZd ed          iZ ed          Zdddd fd
Z	 fdZ
 fdZ xZS )	r.   invalidzEnter a whole number.z\.0*\s*$N)	max_value	min_value	step_sizec                   |||c| _         | _        | _        |                    d          r7| j        t
          k    r'|                    dt                      j                    t                      j        di | |,| j	        
                    t          j        |                     |,| j	        
                    t          j        |                     |0| j	        
                    t          j        ||                     d S d S )NrR   rL   )offsetrK   )r   r   r   getrL   r   
setdefaultrf   rg   r	   r   MaxValueValidatorMinValueValidatorStepValueValidator)rh   r   r   r   r   rb   s        rl   rg   zIntegerField.__init__4  s   9BIy6::j!! 	8dk[&@&@h777""6""" O"":#?	#J#JKKK O"":#?	#J#JKKK O""-i	JJJ     ! rm   c                 f   t                                          |          }|| j        v rdS | j        rt	          j        |          }	 t          | j                            dt          |                              }n1# t          t          f$ r t          | j        d         d          w xY w|S )z~
        Validate that int() can be called on the input. Return the result
        of int() or None for empty values.
        NrJ   r   rx   )rf   ru   rz   rR   r"   sanitize_separatorsr   
re_decimalsubr   
ValueError	TypeErrorr
   rP   rh   rq   rb   s     rl   ru   zIntegerField.to_pythonD  s    
 !!%((D%%%4= 	7/66E	R++BE

;;<<EEI& 	R 	R 	R!$"5i"@yQQQQ	Rs   
5B   .B.c                     t                                          |          }t          |t                    r3| j        
| j        |d<   | j        
| j        |d<   | j        
| j        |d<   |S )Nminmaxstep)rf   r^   rX   r   r   r   r   r   s      rl   r^   zIntegerField.widget_attrsU  sj    $$V,,fk** 	/~)#~e~)#~e~) $frm   )r   r   r   r   rL   r   rW   r)   r   rg   ru   r^   r   r   s   @rl   r.   r.   -  s        F11,-- "!+..J$(DD            "	 	 	 	 	 	 	 	 	rm   r.   c                   L     e Zd Zd ed          iZ fdZ fdZ fdZ xZS )r>   r   Enter a number.c                 (   t          t          |                               |          }|| j        v rdS | j        rt          j        |          }	 t          |          }n1# t          t          f$ r t          | j        d         d          w xY w|S )z
        Validate that float() can be called on the input. Return the result
        of float() or None for empty values.
        Nr   rx   )rf   r.   ru   rz   rR   r"   r   floatr   r   r
   rP   r   s     rl   ru   zFloatField.to_pythonf  s    
 lD))33E::D%%%4= 	7/66E	R%LLEEI& 	R 	R 	R!$"5i"@yQQQQ	Rs   A! !.Bc                     t                                          |           || j        v rd S t          j        |          st          | j        d         d          d S Nr   rx   )rf   r{   rz   mathisfiniter
   rP   r   s     rl   r{   zFloatField.validatev  sh    D%%%F}U## 	R!$"5i"@yQQQQ	R 	Rrm   c                     t                                          |          }t          |t                    r=d|j        vr4| j        t          | j                  }nd}|                    d|           |S )Nr   any)rf   r^   rX   r   r_   r   r   r   rh   rL   r_   r   rb   s       rl   r^   zFloatField.widget_attrs}  sq    $$V,,fk** 	+vV\/I/I~)4>**VT***rm   )	r   r   r   r   rW   ru   r{   r^   r   r   s   @rl   r>   r>   a  s        11&''     R R R R R        rm   r>   c                   ^     e Zd Zd ed          iZddddd fd
Zd Z fdZ fdZ xZ	S )	r?   r   r   N)r   r   
max_digitsdecimal_placesc                    ||c| _         | _         t                      j        d||d| | j                            t	          j        ||                     d S )N)r   r   rK   )r   r   rf   rg   r	   r   DecimalValidator)rh   r   r   r   r   r   rb   s         rl   rg   zDecimalField.__init__  sc     0:>,,L9	LLVLLLz::~VVWWWWWrm   c                     || j         v rdS | j        rt          j        |          }	 t	          t          |                    }n*# t          $ r t          | j        d         d          w xY w|S )a  
        Validate that the input is a decimal number. Return a Decimal
        instance or None for empty values. Ensure that there are no more
        than max_digits in the number and no more than decimal_places digits
        after the decimal point.
        Nr   rx   )	rz   rR   r"   r   r   r   r   r
   rP   rp   s     rl   ru   zDecimalField.to_python  s     D%%%4= 	7/66E	RCJJ''EE 	R 	R 	R!$"5i"@yQQQQ	Rs   A 'A,c                     t                                          |           || j        v rd S |                                st	          | j        d         dd|i          d S )Nr   rq   ry   params)rf   r{   rz   	is_finiter
   rP   r   s     rl   r{   zDecimalField.validate  sw    D%%%F   	!#I.'   	 	rm   c                 T   t                                          |          }t          |t                    rpd|j        vrg| j        Ht          t          d                              | j                             	                                }nd}|
                    d|           |S )Nr      r   )rf   r^   rX   r   r_   r   r   r   scaleblowerr   r   s       rl   r^   zDecimalField.widget_attrs  s    $$V,,fk** 	+vV\/I/I". 71::,,d.A-ABBCCIIKKVT***rm   )
r   r   r   r   rW   rg   ru   r{   r^   r   r   s   @rl   r?   r?     s        11&'' X X X X X X X  "	 	 	 	 	
 
 
 
 
 
 
 
 
rm   r?   c                   0     e Zd Zdd fd
Zd Zd Z xZS )BaseTemporalFieldN)input_formatsc                P     t                      j        di | |	|| _        d S d S r   )rf   rg   r   )rh   r   r   rb   s      rl   rg   zBaseTemporalField.__init__  s<    ""6"""$!.D %$rm   c                     |                                 }| j        D ]1}	 |                     ||          c S # t          t          f$ r Y .w xY wt          | j        d         d          r   )r   r   strptimer   r   r
   rP   rh   rq   formats      rl   ru   zBaseTemporalField.to_python  s    ( 	 	F}}UF33333	*   d1)<9MMMMs   7A
Ac                      t          d          )Nz#Subclasses must define this method.NotImplementedErrorr   s      rl   r   zBaseTemporalField.strptime  s    !"GHHHrm   )r   r   r   rg   ru   r   r   r   s   @rl   r   r     sm        (, / / / / / / /
N N NI I I I I I Irm   r   c                   b     e Zd ZeZ ej        d          Zd ed          iZ	 fdZ
d Z xZS )r/   DATE_INPUT_FORMATSr   Enter a valid date.c                     || j         v rdS t          |t          j                  r|                                S t          |t          j                  r|S t	                                          |          S )zs
        Validate that the input can be converted to a date. Return a Python
        datetime.date object.
        N)rz   rX   datetimedaterf   ru   r   s     rl   ru   zDateField.to_python  sl    
 D%%%4eX.// 	 ::<<eX]++ 	Lww  '''rm   c                 f    t           j                             ||                                          S ro   )r   r   r   r   s      rl   r   zDateField.strptime  '     ))%88==???rm   )r   r   r   r   rL   r"   get_format_lazyr   r   rW   ru   r   r   r   s   @rl   r/   r/     s~        F+G+,@AAM11*++( ( ( ( (@ @ @ @ @ @ @rm   r/   c                   b     e Zd ZeZ ej        d          Zd ed          iZ	 fdZ
d Z xZS )r0   TIME_INPUT_FORMATSr   Enter a valid time.c                     || j         v rdS t          |t          j                  r|S t	                                          |          S )zs
        Validate that the input can be converted to a time. Return a Python
        datetime.time object.
        N)rz   rX   r   timerf   ru   r   s     rl   ru   zTimeField.to_python  sI    
 D%%%4eX]++ 	Lww  '''rm   c                 f    t           j                             ||                                          S ro   )r   r   r  r   s      rl   r   zTimeField.strptime  r   rm   )r   r   r   r    rL   r"   r   r   r   rW   ru   r   r   r   s   @rl   r0   r0     s|        F+G+,@AAM'+@)A)AB	( 	( 	( 	( 	(@ @ @ @ @ @ @rm   r0   c                       e Zd Zd ZdS )DateTimeFormatsIteratorc              #   r   K   t          j        d          E d {V  t          j        d          E d {V  d S )NDATETIME_INPUT_FORMATSr   )r"   
get_formatrh   s    rl   __iter__z DateTimeFormatsIterator.__iter__  sT      %&>?????????%&:;;;;;;;;;;;rm   N)r   r   r   r	  rK   rm   rl   r  r    s#        < < < < <rm   r  c                   \     e Zd ZeZ e            Zd ed          iZd Z	 fdZ
d Z xZS )r1   r   zEnter a valid date/time.c                 X    t          |t          j                  rt          |          }|S ro   )rX   r   r   rp   s     rl   rr   zDateTimeField.prepare_value  s)    eX.// 	/'..Erm   c                    || j         v rdS t          |t          j                  rt          |          S t          |t          j                  r4t          j        |j        |j        |j                  }t          |          S 	 t          |	                                          }n*# t          $ r t          | j        d         d          w xY w|s!t                                          |          }t          |          S )z{
        Validate that the input can be converted to a datetime. Return a
        Python datetime.datetime object.
        Nr   rx   )rz   rX   r   r   r   yearmonthdayr$   r   r   r
   rP   rf   ru   )rh   rq   r   rb   s      rl   ru   zDateTimeField.to_python  s    
 D%%%4eX.// 	0(///eX]++ 	1&uz5;	JJF(000	R#EKKMM22FF 	R 	R 	R!$"5i"@yQQQQ	R 	.WW&&u--F$V,,,s   !B' ''Cc                 B    t           j                             ||          S ro   )r   r   r   s      rl   r   zDateTimeField.strptime)  s     ))%888rm   )r   r   r   r   rL   r  r   r   rW   rr   ru   r   r   r   s   @rl   r1   r1   	  s        F++--M11/00  
- - - - -(9 9 9 9 9 9 9rm   r1   c                   H    e Zd Z ed           ed          dZd Zd ZdS )r2   zEnter a valid duration.z=The number of days must be between {min_days} and {max_days}.)r   overflowc                 X    t          |t          j                  rt          |          S |S ro   )rX   r   	timedeltar'   rp   s     rl   rr   zDurationField.prepare_value3  s*    eX/00 	*"5)))rm   c                    || j         v rd S t          |t          j                  r|S 	 t	          t          |                    }ng# t          $ rZ t          | j        d         	                    t          j        j
        j        t          j        j        j                  d          w xY w|t          | j        d         d          |S )Nr  )min_daysmax_daysrx   r   )rz   rX   r   r  r%   r   OverflowErrorr
   rP   r   r   daysr   rp   s     rl   ru   zDurationField.to_python8  s    D%%%4eX/00 	L		"3u::..EE 	 	 	!#J/66%/38%/38 7       	 =!$"5i"@yQQQQs   A A$B*N)r   r   r   r   rW   rr   ru   rK   rm   rl   r2   r2   -  s[        1.//AUVV 
  
    rm   r2   c                   B     e Zd Z fdZd Zd Z eee          Z xZS )r3   c                     |                     dd            t                      j        di | |                     |           dS )zW
        regex can be either a string or a compiled regular expression object.
        r   FNrK   )r   rf   rg   
_set_regex)rh   regexr   rb   s      rl   rg   zRegexField.__init__M  sP     	'5)))""6"""rm   c                     | j         S ro   )_regexr  s    rl   
_get_regexzRegexField._get_regexU  s
    {rm   c                 R   t          |t                    rt          j        |          }|| _        t          | d          r-| j        | j        v r| j                            | j                   t          j	        |          | _        | j        
                    | j                   d S )N_regex_validator)r  )rX   r   recompiler  r}   r"  r	   removeRegexValidatorr   )rh   r  s     rl   r  zRegexField._set_regexX  s    eS!! 	&Ju%%ED,--	:%88O""4#8999 * 9 F F Ft455555rm   )	r   r   r   rg   r   r  propertyr  r   r   s   @rl   r3   r3   L  s]              
6 
6 
6 HZ,,EEEEErm   r3   c                   2     e Zd ZeZej        gZ fdZ xZ	S )r4   c                 j    |                     dd            t                      j        dddi| d S )Nr   i@  r   TrK   )r   rf   rg   )rh   r   rb   s     rl   rg   zEmailField.__init__k  sC     	,,,,..t.v.....rm   )
r   r   r   r   rL   r	   validate_emailre   rg   r   r   s   @rl   r4   r4   g  sI        F$34/ / / / / / / / /rm   r4   c                        e Zd ZeZ ed           ed           ed           eddd           ed          dZd	d
d fd
Zd Z	d fd	Z
d Zd Z xZS )r5   z;No file was submitted. Check the encoding type on the form.zNo file was submitted.zThe submitted file is empty.zGEnsure this filename has at most %(max)d character (it has %(length)d).zHEnsure this filename has at most %(max)d characters (it has %(length)d).r   zBPlease either submit a file or check the clear checkbox, not both.)r   missingemptyr   contradictionNF)r   allow_empty_filec                V    || _         || _         t                      j        di | d S r   )r   r/  rf   rg   )rh   r   r/  r   rb   s       rl   rg   zFileField.__init__  s5    $ 0""6"""""rm   c                    || j         v rd S 	 |j        }|j        }n*# t          $ r t	          | j        d         d          w xY w| j        Lt          |          | j        k    r4| j        t          |          d}t	          | j        d         d|          |st	          | j        d         d          | j        s|st	          | j        d         d          |S )Nr   rx   )r   lengthr   r   r-  )	rz   namesizeAttributeErrorr
   rP   r   lenr/  )rh   r   	file_name	file_sizer   s        rl   ru   zFileField.to_python  s   4$$$4	R	I	II 	R 	R 	R!$"5i"@yQQQQ	R ?&3y>>DO+K+K!_IGGF!#L1V     	R!$"5i"@yQQQQ$ 	NY 	N!$"5g">WMMMMs	    'Ac                     |t           u rt          | j        d         d          |du r| j        sdS d }|s|r|S t	                                          |          S )Nr.  rx   F)r   r
   rP   rI   rf   r   )rh   r   rN   rb   s      rl   r   zFileField.clean  s~    +++!#O4?   
 5=== u D 	 	Nww}}T"""rm   c                     |S ro   rK   )rh   r   rN   s      rl   r   zFileField.bound_data  s    rm   c                     | j          o|d uS ro   r   rh   rN   r   s      rl   r   zFileField.has_changed  s    = 5T%55rm   ro   )r   r   r   r   rL   r   r+   rW   rg   ru   r   r   r   r   r   s   @rl   r5   r5   r  s        F1RSS1-..122#mUV
 

 P
 
  &*E # # # # # # #
  .# # # # # #*  6 6 6 6 6 6 6rm   r5   c                   R     e Zd Zej        gZd ed          iZ fdZ fdZ	 xZ
S )r6   invalid_imagezYUpload a valid image. The file you uploaded was either not an image or a corrupted image.c                    t                                          |          }|dS ddlm} t	          |d          r|                                }nGt	          |d          r"t          |                                          }nt          |d                   }	 |                    |          }|	                                 ||_
        |j                            |j                  |_        n/# t          $ r"}t!          | j        d         d          |d}~ww xY wt	          |d	          r)t%          |j                  r|                    d           |S )
z
        Check that the file-upload field data contains a valid image (GIF, JPG,
        PNG, etc. -- whatever Pillow supports).
        Nr   )Imagetemporary_file_pathreadcontentr>  rx   seek)rf   ru   PILr@  r}   rA  r   rB  openverifyimageMIMEr   r   content_type	Exceptionr
   rP   callablerD  )rh   r   fr@  filerH  excrb   s          rl   ru   zImageField.to_python  se   
 GGd##94 4.// 	0++--DDtV$$ 0tyy{{++tI//	 JJt$$ELLNNN AG #Z^^EL99ANN 	 	 	!#O4$   	 1f 	(16"2"2 	FF1IIIs   AC/ /
D9DDc                     t                                          |          }t          |t                    rd|j        vr|                    dd           |S )Nacceptzimage/*)rf   r^   rX   r   r_   r   r   s      rl   r^   zImageField.widget_attrs  sS    $$V,,fi(( 	2XV\-I-IXy111rm   )r   r   r   r	   validate_image_file_extensionre   r   rW   ru   r^   r   r   s   @rl   r6   r6     s|        $BC*
 
) ) ) ) )V        rm   r6   c                   l     e Zd ZeZd ed          iZ ej                    gZ	dd fd
Z
 fdZ xZS )r7   r   zEnter a valid URL.N)assume_schemec                    |-t           j        rd}nt          j        dt          d           d}|| _         t                      j        dddi| d S )	Nhttpsa	  The default scheme will be changed from 'http' to 'https' in Django 6.0. Pass the forms.URLField.assume_scheme argument to silence this warning, or set the FORMS_URLFIELD_ASSUME_HTTPS transitional setting to True to opt into using 'https' as the new default scheme.   )
stacklevelhttpr   TrK   )r   FORMS_URLFIELD_ASSUME_HTTPSwarningswarnr&   rT  rf   rg   )rh   rT  r   rb   s      rl   rg   zURLField.__init__  sz     3 ' '&
 -     !' +..t.v.....rm   c                      fd}t                                          |          }|r\ ||          }|d         s
 j        |d<   |d         s(|d         |d<   d|d<    |t          |                    }t          |          }|S )Nc                     	 t          t          |                     S # t          $ r t          j        d         d          w xY w)z
            Return a list of url parts via urlparse.urlsplit(), or raise
            ValidationError for some malformed URLs.
            r   rx   )r   r   r   r
   rP   )urlrh   s    rl   	split_urlz%URLField.to_python.<locals>.split_url  sY    
VHSMM*** V V V &d&9)&D9UUUUVs	    'Ar   r   rW  rJ   )rf   ru   rT  r   )rh   rq   r`  
url_fieldsrb   s   `   rl   ru   zURLField.to_python  s    
	V 
	V 
	V 
	V 
	V !!%(( 	+"5))Ja= 3 $ 2
1a= ? !+1
1 "
1 'Yz*'='=>>
z**Erm   )r   r   r   r!   rL   r   rW   r	   URLValidatorre   rg   ru   r   r   s   @rl   r7   r7     s        F11)** 2*1334(, / / / / / / /(        rm   r7   c                   .     e Zd ZeZ fdZd Zd Z xZS )r8   c                     t          |t                    r|                                dv rd}nt          |          }t	                                          |          S )zReturn a Python boolean object.)false0F)rX   r   r   boolrf   ru   r   s     rl   ru   zBooleanField.to_python2  sS     eS!! 	 ekkmm~&E&EEEKKEww  '''rm   c                 T    |s#| j         rt          | j        d         d          d S d S rw   )rI   r
   rP   rp   s     rl   r{   zBooleanField.validate>  sH     	T 	T!$"5j"A
SSSS	T 	T 	T 	Trm   c                 l    | j         rdS |                     |          |                     |          k    S )NF)rS   ru   r<  s      rl   r   zBooleanField.has_changedB  s6    = 	5 ~~g&&$..*>*>>>rm   )	r   r   r   r   rL   ru   r{   r   r   r   s   @rl   r8   r8   /  s^        F
( 
( 
( 
( 
(T T T? ? ? ? ? ? ?rm   r8   c                   "    e Zd ZdZeZd Zd ZdS )r9   za
    A field whose valid values are None, True, and False. Clean invalid values
    to None.
    c                     |dv rdS |dv rdS dS )a  
        Explicitly check for the string 'True' and 'False', which is what a
        hidden field will submit for True and False, for 'true' and 'false',
        which are likely to be returned by JavaScript serializations of forms,
        and for '1' and '0', which is what a RadioField will submit. Unlike
        the Booleanfield, this field must check for True because it doesn't
        use the bool() function.
        )TTruetrue1T)FFalsere  rf  FNrK   rp   s     rl   ru   zNullBooleanField.to_pythonR  s+     ///444454rm   c                     d S ro   rK   rp   s     rl   r{   zNullBooleanField.validateb      rm   N)r   r   r   __doc__r   rL   ru   r{   rK   rm   rl   r9   r9   J  sC         
 F       rm   r9   c                        e Zd ZeZd ed          iZdd fd
Z fdZe	d             Z
e
j        d             Z
d	 Z fd
Zd Z xZS )r:   invalid_choiceESelect a valid choice. %(value)s is not one of the available choices.rK   )choicesc                H     t                      j        di | || _        d S r   )rf   rg   rv  )rh   rv  r   rb   s      rl   rg   zChoiceField.__init__n  s+    ""6"""rm   c                     t                                          |          }t          j        | j        |          |_        |S ro   )rf   r   rZ   r[   _choicesrh   r   r   rb   s      rl   r   zChoiceField.__deepcopy__r  s4    %%d++-t<<rm   c                     | j         S ro   )ry  r  s    rl   rv  zChoiceField.choicesw  s
    }rm   c                 F    t          |          x| _        | j        _        d S ro   )r#   ry  rL   rv  rp   s     rl   rv  zChoiceField.choices{  s$     /@.F.FF+++rm   c                 6    || j         v rdS t          |          S )r   rJ   )rz   r   rp   s     rl   ru   zChoiceField.to_python  s!    D%%%25zzrm   c                     t                                          |           |r4|                     |          s!t          | j        d         dd|i          dS dS )z+Validate that the input is in self.choices.rt  rq   r   N)rf   r{   valid_valuer
   rP   r   s     rl   r{   zChoiceField.validate  sz     	))%00 	!#$45%'   	 	 	 	rm   c                     t          |          }| j        D ]c\  }}t          |t          t          f          r&|D ]"\  }}||k    s|t          |          k    r  dS #G||k    s|t          |          k    r dS ddS )z5Check to see if the provided value is a valid choice.TF)r   rv  rX   r   tuple)rh   rq   
text_valuekr   k2v2s          rl   r  zChoiceField.valid_value  s    ZZ
L 	  	 DAq!dE]++   $ $FB{{jCGG&;&;#ttt '<$ A::s1vv!5!544 "6urm   )r   r   r   r   rL   r   rW   rg   r   r'  rv  setterru   r{   r  r   r   s   @rl   r:   r:   f  s        F!!S
 
 #%           
   X ^G G ^G
            rm   r:   c                   8     e Zd Zd dd fd
Zd Z fdZ xZS )rE   c                     | S ro   rK   vals    rl   <lambda>zTypedChoiceField.<lambda>      S rm   rJ   )coercer   c                V    || _         || _         t                      j        di | d S r   )r  r   rf   rg   )rh   r  r   r   rb   s       rl   rg   zTypedChoiceField.__init__  s5    &""6"""""rm   c                     || j         k    s	|| j        v r| j         S 	 |                     |          }n:# t          t          t
          f$ r  t          | j        d         dd|i          w xY w|S )zZ
        Validate that the value can be coerced to the right type (if not empty).
        rt  rq   r   )r   rz   r  r   r   r
   rP   rp   s     rl   r   zTypedChoiceField._coerce  s     D$$$1B(B(B##	KK&&EEI7 	 	 	!#$45%'   	 s	   3 7A*c                 p    t                                          |          }|                     |          S ro   rf   r   r   r   s     rl   r   zTypedChoiceField.clean  *    e$$||E"""rm   )r   r   r   rg   r   r   r   r   s   @rl   rE   rE     sq        !0b # # # # # # #
   # # # # # # # # #rm   rE   c                   V    e Zd ZeZeZ ed           ed          dZd Z	d Z
d ZdS )r;   ru  Enter a list of values.)rt  invalid_listc                     |sg S t          |t          t          f          st          | j        d         d          d |D             S )Nr  rx   c                 ,    g | ]}t          |          S rK   r   ).0r  s     rl   
<listcomp>z1MultipleChoiceField.to_python.<locals>.<listcomp>  s    ***SC***rm   )rX   r   r  r
   rP   rp   s     rl   ru   zMultipleChoiceField.to_python  s_     	IED%=11 	!#N3.    +*E****rm   c                     | j         r|st          | j        d         d          |D ]6}|                     |          st          | j        d         dd|i          7dS )z+Validate that the input is a list or tuple.rI   rx   rt  rq   r   N)rI   r
   rP   r  )rh   rq   r  s      rl   r{   zMultipleChoiceField.validate  s    = 	T 	T!$"5j"A
SSSS 	 	C##C(( %'(89)#S>   	 	rm   c                     | j         rdS |g }|g }t          |          t          |          k    rdS d |D             }d |D             }||k    S )NFTc                 ,    h | ]}t          |          S rK   r  r  rq   s     rl   	<setcomp>z2MultipleChoiceField.has_changed.<locals>.<setcomp>  s    777es5zz777rm   c                 ,    h | ]}t          |          S rK   r  r  s     rl   r  z2MultipleChoiceField.has_changed.<locals>.<setcomp>  s    1115CJJ111rm   )rS   r6  )rh   rN   r   initial_setdata_sets        rl   r   zMultipleChoiceField.has_changed  sr    = 	5?G<Dw<<3t99$$477w77711D111;&&rm   N)r   r   r   r   r   r   rL   r   rW   ru   r{   r   rK   rm   rl   r;   r;     sz        'MF!S
 
 344	 + + +  ' ' ' ' 'rm   r;   c                   @     e Zd Zd d fd
Zd Z fdZ fdZ xZS )rF   c                     | S ro   rK   r  s    rl   r  z!TypedMultipleChoiceField.<lambda>  r  rm   )r  c                ~    || _         |                    dg           | _         t                      j        di | d S )Nr   rK   )r  popr   rf   rg   )rh   r  r   rb   s      rl   rg   z!TypedMultipleChoiceField.__init__  sC    !::mR88""6"""""rm   c                    || j         k    s	|| j        v r| j         S g }|D ]e}	 |                    |                     |                     ,# t          t
          t          f$ r  t          | j        d         dd|i          w xY w|S )zl
        Validate that the values are in self.choices and can be coerced to the
        right type.
        rt  rq   r   )r   rz   r   r  r   r   r
   rP   )rh   rq   	new_valuechoices       rl   r   z TypedMultipleChoiceField._coerce  s    
 D$$$1B(B(B##	 	 	F  V!4!45555	?;   %'(89)#V,    s   (A7Bc                 p    t                                          |          }|                     |          S ro   r  r   s     rl   r   zTypedMultipleChoiceField.clean  r  rm   c                     || j         k    r#t                                          |           d S | j        rt	          | j        d         d          d S rw   )r   rf   r{   rI   r
   rP   r   s     rl   r{   z!TypedMultipleChoiceField.validate  sa    D$$$GGU#####] 	T!$"5j"A
SSSS	T 	Trm   )r   r   r   rg   r   r   r{   r   r   s   @rl   rF   rF     s        !0 # # # # # # #
  &# # # # #T T T T T T T T Trm   rF   c                   ,     e Zd ZdZ fdZ fdZ xZS )r<   zL
    A Field whose clean() method calls multiple Field clean() methods.
    c                 `     t                      j        di | |D ]	}d|_        
|| _        d S )NFrK   )rf   rg   rI   fields)rh   r  r   rM  rb   s       rl   rg   zComboField.__init__  sE    ""6"""  	 	AAJJrm   c                     t                                          |           | j        D ]}|                    |          }|S )zr
        Validate the given value against all of self.fields, which is a
        list of Field instances.
        )rf   r   r  )rh   rq   fieldrb   s      rl   r   zComboField.clean  sD    
 	e[ 	' 	'EKK&&EErm   )r   r   r   rr  rg   r   r   r   s   @rl   r<   r<     s[                     rm   r<   c                   x     e Zd ZdZ ed           ed          dZdd fd
Z fdZd	 Zd
 Z	d Z
d Z xZS )r=   a  
    Aggregate the logic of multiple Fields.

    Its clean() method takes a "decompressed" list of values, which are then
    cleaned into a single value according to self.fields. Each value in
    this list is cleaned by the corresponding field -- the first value is
    cleaned by the first field, the second value is cleaned by the second
    field, etc. Once all fields are cleaned, the list of clean values is
    "compressed" into a single value.

    Subclasses should not have to implement clean(). Instead, they must
    implement compress(), which takes a list of valid values and returns a
    "compressed" version of those values -- a single value.

    You'll probably want to use this with MultiWidget.
    r  zEnter a complete value.)r   
incompleteT)require_all_fieldsc                    || _          t                      j        di | |D ]D}|j                            d| j        d                    | j        rd|_        | j         rd|_        E|| _        d S )Nr  TFrK   )r  rf   rg   rP   r   rS   rI   r  )rh   r  r  r   rM  rb   s        rl   rg   zMultiValueField.__init__=  s    "4""6""" 	# 	#A''d6I,6WXXX} "!
& # #
rm   c                     t                                                    }t          fd| j        D                       |_        |S )Nc              3   B   K   | ]}|                               V  d S ro   )r   )r  xr   s     rl   	<genexpr>z/MultiValueField.__deepcopy__.<locals>.<genexpr>M  s/      HHqannT22HHHHHHrm   )rf   r   r  r  rz  s    ` rl   r   zMultiValueField.__deepcopy__K  sF    %%d++HHHHDKHHHHHrm   c                     d S ro   rK   rp   s     rl   r{   zMultiValueField.validateP  rq  rm   c                 2    g }g  j         r/t          |t                    s j                            |          }|rt          |t          t
          f          rI|r fd|D             s8 j        rt           j        d         d           	                    g           S nt           j        d         d          t           j                  D ]\  }}	 ||         }n# t          $ r d}Y nw xY w| j        v rb j        r$ j        rt           j        d         d          n7|j        r0|j        d         vr                     |j        d                    	 |                    |                    |                     # t          $ r0}                    fd|j        D                        Y d}~d}~ww xY wrt                     	                    |          }                     |                                |           |S )aI  
        Validate every value in the given list. A value is validated against
        the corresponding Field in self.fields.

        For example, if this MultiValueField was instantiated with
        fields=(DateField(), TimeField()), clean() would call
        DateField.clean(value[0]) and TimeField.clean(value[1]).
        c                 &    g | ]}|j         v|S rK   )rz   )r  r   rh   s     rl   r  z)MultiValueField.clean.<locals>.<listcomp>a  s&     P P PqQd>O5O5O5O5O5Orm   rI   rx   r   Nr  c              3   $   K   | ]
}|v|V  d S ro   rK   )r  mr   s     rl   r  z(MultiValueField.clean.<locals>.<genexpr>  s'      IIA&aIIrm   )rS   rX   r   rL   
decompressr  rI   r
   rP   compress	enumerater  
IndexErrorrz   r  r   r   r   r   r{   r   )	rh   rq   
clean_datair  field_valuer   outr   s	   `       @rl   r   zMultiValueField.cleanS  s    
= 	2E4!8!8 	2K**511E 		R
54-88 		R - P P P PE P P P -= -)+J7j     ==,,,- "$"5i"@yQQQQ!$+.. 	J 	JHAu##Ah # # #"#d///*  } - /
;*    ^  +L9GGe&:<&HIIIJ!!%++k":":;;;;" J J J IIIIIIIIIIIIIII	J
  	*!&)))mmJ''cC   
s*   C##C21C2!(F


G&F??Gc                      t          d          )aD  
        Return a single value for the given list of values. The values can be
        assumed to be valid.

        For example, if this MultiValueField was instantiated with
        fields=(DateField(), TimeField()), this might return a datetime
        object created by combining the date and time in data_list.
        z&Subclasses must implement this method.r   )rh   	data_lists     rl   r  zMultiValueField.compress  s     ""JKKKrm   c                    | j         rdS |(d t          dt          |                    D             }n/t          |t                    s| j                            |          }t          | j        ||          D ]H\  }}}	 |	                    |          }n# t          $ r Y  dS w xY w|                    ||          r dS IdS )NFc                     g | ]}d S )rJ   rK   )r  r  s     rl   r  z/MultiValueField.has_changed.<locals>.<listcomp>  s    777ar777rm   r   T)rS   ranger6  rX   r   rL   r  zipr  ru   r
   r   )rh   rN   r   r  s       rl   r   zMultiValueField.has_changed  s    = 	5?775CII#6#6777GGgt,, :+0099$'Wd$C$C 	 	 E7D//'22"   ttt  $// ttus    B
B%$B%)r   r   r   rr  r   rW   rg   r   r{   r   r  r   r   r   s   @rl   r=   r=   &  s         $ 1.//a122 
 6:           
  8 8 8t	L 	L 	L      rm   r=   c                   *     e Zd Zddddd fd
Z xZS )rB   NFT)match	recursiveallow_filesallow_foldersc          
         |||c| _         | _        | _        ||c| _        | _         t                      j        dddi| | j        rg | _        ndg| _        | j        t          j
        | j                  | _        |rNt          t          j        | j                             D ]$\  }}}	| j        rt          |	          D ]t}
| j        | j                            |
          rQt          j                             ||
          }
| j                            |
|
                    |dd          f           u| j        rt          |          D ]{}
|
dk    r	| j        | j                            |
          rQt          j                             ||
          }
| j                            |
|
                    |dd          f           |&ng }t          j        | j                   5 }|D ]}
|
j        dk    r| j        r|
                                s| j        r[|
                                rG| j        | j                            |
j                  r!|                    |
j         |
j        f           	 d d d            n# 1 swxY w Y   |                    t1          j        d                     | j                            |           | j        | j        _        d S )Nrv  rK   )rJ   z	---------rJ   r   __pycache__)key)pathr  r  r  r  rf   rg   rI   rv  r#  r$  match_resortedoswalksearchjoinr   replacescandirr3  is_fileis_dirsortoperator
itemgetterr   rL   )rh   r  r  r  r  r  r   rootdirsfilesrM  rv  entriesrb   s                rl   rg   zFilePathField.__init__  s    15eY-	4:t~/:M,$,...v...= 	/DLL-.DL:!Jtz22DM 	)%+BGDI,>,>%?%? M M!dE# M#E]] M M:-1E1Ea1H1H- "T1 5 5A L//AIIdB4J4J0KLLL% M#D\\ M M--$:-1E1Ea1H1H- "T1 5 5A L//AIIdB4J4J0KLLLM GDI&& 9'  9 9Av.. )9./iikk9 .93488::9  :-1E1Eaf1M1M-'788899 9 9 9 9 9 9 9 9 9 9 9 9 9 9 LLX033L444L((("ls   *BJJ
J
)r   r   r   rg   r   r   s   @rl   rB   rB     sP        
 2+ 2+ 2+ 2+ 2+ 2+ 2+ 2+ 2+ 2+ 2+rm   rB   c                   b     e Zd ZeZeZ ed           ed          dZddd fd
Z	d Z
 xZS )r@   r   r   )invalid_dateinvalid_timeN)input_date_formatsinput_time_formatsc                @   | j                                         }d|v r|                    |d                    |                    dd          }t	          |d|d         i|          t          |d|d         i|          f} t                      j        |fi | d S )NrP   rR   Fr   r  )r   rP   rR   r  )rW   rZ   r`   r   r/   r0   rf   rg   )rh   r  r  r   r   rR   r  rb   s          rl   rg   zSplitDateTimeField.__init__  s    ,1133v%%MM&!12333::j%000 )6.+AB!  
 0 )6.+AB!  
 	**6*****rm   c                     |rx|d         | j         v rt          | j        d         d          |d         | j         v rt          | j        d         d          t          j        j        | }t          |          S d S )Nr   r  rx   r   r  )rz   r
   rP   r   combiner   )rh   r  r   s      rl   r  zSplitDateTimeField.compress  s     	1 |t000%'7n    |t000%'7n    &.	:F(000trm   )r   r   r   r   rL   r   r   r   rW   rg   r  r   r   s   @rl   r@   r@     s         F-M/00/00 
 .2d + + + + + + +&      rm   r@   c                   ,     e Zd Zddd fd
Zd Z xZS )rA   bothF)protocolunpack_ipv4c                    || _         t          j        ||          d         | _         t	                      j        di | d S )Nr   rK   )r  r	   ip_address_validatorsre   rf   rg   )rh   r  r  r   rb   s       rl   rg   zGenericIPAddressField.__init__  sR    &","Bk#
 #

# 	""6"""""rm   c                 z    || j         v rdS |                                }|rd|v rt          || j                  S |S )NrJ   :)rz   r   r(   r  rp   s     rl   ru   zGenericIPAddressField.to_python  sJ    D%%%2 	?SE\\%eT-=>>>rm   )r   r   r   rg   ru   r   r   s   @rl   rA   rA     sV        #)u # # # # # # #      rm   rA   c                   4     e Zd Zej        gZdd fd
Z xZS )rD   F)allow_unicodec                z    || _         | j         rt          j        g| _         t	                      j        di | d S r   )r  r	   validate_unicode_slugre   rf   rg   )rh   r  r   rb   s      rl   rg   zSlugField.__init__   sH    * 	I'1'G&HD#""6"""""rm   )r   r   r   r	   validate_slugre   rg   r   r   s   @rl   rD   rD     sQ        $23(- # # # # # # # # # # #rm   rD   c                   >     e Zd Zd ed          iZd Z fdZ xZS )rG   r   zEnter a valid UUID.c                 X    t          |t          j                  rt          |          S |S ro   )rX   uuidUUIDr   rp   s     rl   rr   zUUIDField.prepare_value,  s'    eTY'' 	u::rm   c                    t                                          |          }|| j        v rd S t          |t          j                  s@	 t	          j        |          }n*# t          $ r t          | j        d         d          w xY w|S r   )	rf   ru   rz   rX   r  r  r   r
   rP   r   s     rl   ru   zUUIDField.to_python1  s    !!%((D%%%4%++ 	VV	%(( V V V%d&9)&D9UUUUVs   	A 'B)r   r   r   r   rW   rr   ru   r   r   s   @rl   rG   rG   '  s_        11*++  
	 	 	 	 	 	 	 	 	rm   rG   c                       e Zd ZdS )InvalidJSONInputNr   r   r   rK   rm   rl   r  r  =          Drm   r  c                       e Zd ZdS )
JSONStringNr  rK   rm   rl   r  r  A  r  rm   r  c                   Z     e Zd Zd ed          iZeZd	 fd	Zd Zd Z	d Z
 fdZ xZS )
rC   r   zEnter a valid JSON.Nc                 V    || _         || _         t                      j        di | d S r   )encoderdecoderrf   rg   )rh   r  r	  r   rb   s       rl   rg   zJSONField.__init__K  s4    ""6"""""rm   c                 t   | j         r|S || j        v rd S t          |t          t          t
          t          t          f          r|S 	 t          j	        || j
                  }n2# t          j        $ r  t          | j        d         dd|i          w xY wt          |t                    rt          |          S |S )Nclsr   rq   r   )rS   rz   rX   r   dictr   r   r  jsonloadsr	  JSONDecodeErrorr
   rP   r   )rh   rq   	converteds      rl   ru   zJSONField.to_pythonP  s    = 	LD%%%4dC
CDD 	L	
5dl;;;II# 	 	 	!#I.'   	 i%% 	i(((s   A" "/Bc                     | j         r|S |d S 	 t          j        || j                  S # t          j        $ r t          |          cY S w xY w)Nr  )rS   r  r  r	  r  r  r   s      rl   r   zJSONField.bound_datad  si    = 	N<4	*:d5555# 	* 	* 	*#D)))))	*s   * A
Ac                 h    t          |t                    r|S t          j        |d| j                  S )NF)ensure_asciir  )rX   r  r  dumpsr  rp   s     rl   rr   zJSONField.prepare_valuen  s3    e-.. 	Lz%eFFFFrm   c                     t                                          ||          rdS t          j        |d| j                  t          j        |                     |          d| j                  k    S )NT)	sort_keysr  )rf   r   r  r  r  ru   )rh   rN   r   rb   s      rl   r   zJSONField.has_changeds  sq    77w-- 	4 z'Tt|DDD
NN4  DdlI
 I
 I
 
 	
rm   )NN)r   r   r   r   rW   r   rL   rg   ru   r   rr   r   r   r   s   @rl   rC   rC   E  s        11*++ F# # # # # #
  (* * *G G G

 
 
 
 
 
 
 
 
rm   rC   )frr  rZ   r   r  r   r  r  r#  r  r[  decimalr   r   ior   urllib.parser   r   django.confr   django.corer	   django.core.exceptionsr
   django.forms.boundfieldr   django.forms.utilsr   r   django.forms.widgetsr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   django.utilsr"   django.utils.choicesr#   django.utils.dateparser$   r%   django.utils.deprecationr&   django.utils.durationr'   django.utils.ipv6r(   django.utils.regex_helperr)   django.utils.translationr*   r   r+   __all__r,   r-   r.   r>   r?   r   r/   r0   r  r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   rE   r;   rF   r<   r=   rB   r@   rA   rD   rG   r   r  r  rC   rK   rm   rl   <module>r*     s         				 				   - - - - - - - -       - - - - - - - -             " " " " " " 2 2 2 2 2 2 . . . . . . I I I I I I I I                                         * !           2 2 2 2 2 2 A A A A A A A A = = = = = = 1 1 1 1 1 1 0 0 0 0 0 0 6 6 6 6 6 6 6 6 6 6 6 6 2 2 2 2 2 2@p p p p p p p pf! ! ! ! ! ! ! !H1 1 1 1 15 1 1 1h$ $ $ $ $ $ $ $N8 8 8 8 8< 8 8 8vI I I I I I I I(@ @ @ @ @! @ @ @0@ @ @ @ @! @ @ @(< < < < < < < <!9 !9 !9 !9 !9% !9 !9 !9H    E   >- - - - - - - -6/ / / / / / / /E6 E6 E6 E6 E6 E6 E6 E6P8 8 8 8 8 8 8 8v7 7 7 7 7y 7 7 7t? ? ? ? ?5 ? ? ?6    |   87 7 7 7 7% 7 7 7t# # # # #{ # # #6+' +' +' +' +'+ +' +' +'\!T !T !T !T !T2 !T !T !TH       2A A A A Ae A A AH3+ 3+ 3+ 3+ 3+K 3+ 3+ 3+l) ) ) ) ) ) ) )X    I   "# # # # #	 # # #    	   ,	 	 	 	 	s 	 	 		 	 	 	 	 	 	 	5
 5
 5
 5
 5
	 5
 5
 5
 5
 5
rm   