
    2yiX                       U d Z ddlm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 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 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 ddlmZ ddlmZ ddlm Z  ddl!m"Z" e#e$e%e&e&e%ee%   f      Z' ejP                  e)      Z*ejV                  hZ,de-d<   de-d<   ej\                  	 	 	 	 	 	 d d       Z/d!dZ0d"dZ1 G d d      Z2 G d d      Z3	 	 	 	 	 	 d#dZ4	 	 	 	 	 	 d$dZ5y)%z$Checker Manager and Checker classes.    )annotationsN)	Generator)Sequence)Any)Optional)defaults)
exceptions)	processor)utils)FSTRING_START)TSTRING_START)expand_paths)
parse_args)Checkers)LoadedPlugin)StyleGuideManagerr   _mp_pluginsargparse.Namespace_mp_optionsc              #  2   K   | |ca a	 d  b by # b bw xY wwN)r   r   )pluginsoptionss     P/var/www/html/content_weaver/venv/lib/python3.12/site-packages/flake8/checker.py_mp_preforkr   4   s&       'K%Ks    c                    t        j                   t         j                  t         j                         	 t        t        f y # t
        $ r  t        |       \  }}|j                  |caaY y w xY wr   )signalSIGINTSIG_IGNr   r   	NameErrorr   checkers)argvr   r   s      r   _mp_initr#   A   sW     MM&--0=[  =%d+#*#3#3W [=s   A &A*)A*c                J    t        | t        t              j                         S )Nfilenamer   r   )FileCheckerr   r   
run_checksr&   s    r   _mp_runr*   O   s    ;jl    c                  p    e Zd ZdZ	 	 	 	 	 	 	 	 ddZddZddZddZddZddZ	ddZ
dd	Zdd
ZddZy)ManageraR  Manage the parallelism and checker instances for each plugin and file.

    This class will be responsible for the following:

    - Determining the parallelism of Flake8, e.g.:

      * Do we use :mod:`multiprocessing` or is it unavailable?

      * Do we automatically decide on the number of jobs to use or did the
        user provide that?

    - Falling back to a serial way of processing files if we run into an
      OSError related to :mod:`multiprocessing`

    - Organizing the results of each checker so we can group the output
      together and make our output deterministic.
    c                   || _         |j                  | _        || _        | j                         | _        ddddd| _        g | j                  j                  | j                  j                  | _        || _        g | _	        y)z Initialize our Manager instance.r   )fileslogical linesphysical linestokensN)
style_guider   r   
_job_countjobs
statisticsexcludeextend_excluder"   results)selfr3   r   r"   s       r   __init__zManager.__init__h   sy     '"**OO%		
 M--L0K0KL	BDr+   c                    | j                   D ]5  \  }}}t        j                  D ]  }| j                  |xx   ||   z  cc<    7 | j                  dxx   t	        | j
                        z  cc<   y )Nr/   )r9   r   STATISTIC_NAMESr6   len	filenames)r:   _r6   	statistics       r   _process_statisticszManager._process_statistics}   sm     $ 	DAq*%55 D		*j.CC*D	D 	 C$77 r+   c                $   t        j                  | j                  j                        rt        j                  d       y| j                  j                  }|j                  r	 t        j                         S |j                  S # t        $ r Y yw xY w)Nz]The --jobs option is not compatible with supplying input using - . Ignoring --jobs arguments.r   )r   is_using_stdinr   r?   LOGwarningr5   is_automultiprocessing	cpu_countNotImplementedErrorn_jobs)r:   r5   s     r   r4   zManager._job_count   s~      6 67KK= ||   <<&0022 {{ ' s   #B 	BBc           
     p    | j                   }d}|D ]"  \  }}}}}	||j                  ||||||	      z  }$ |S )Nr   )coder&   line_numbercolumn_numbertextphysical_line)r3   handle_error)
r:   r&   r9   r3   reported_results_count
error_coderN   columnrP   rQ   s
             r   _handle_resultszManager._handle_results   sd    &&!"DK 	@JVT="k&>&>!'$+ '? ' "	 &%r+   c                   dx}}| j                   j                  t        j                  d             | j                   D ]s  \  }}}|j                  t        j                  dd             | j                  j                  |      5  || j                  ||      z  }ddd       |t        |      z  }u ||fS # 1 sw Y   xY w)a  Report all of the errors found in the managed file checkers.

        This iterates over each of the checkers and reports the errors sorted
        by line number.

        :returns:
            A tuple of the total results found and the results reported.
        r   )key      N)r9   sortoperator
itemgetterr3   processing_filerV   r>   )r:   results_reportedresults_foundr&   r9   r@   s         r   reportzManager.report   s     ,-,=h11!45$(LL 	* HgqLLX00A6L7!!11(; L D$8$87$KK LS\)M		*
 /00L Ls   B::C	c                   t        | j                  | j                        5  t        | j                  | j
                        }ddd       | j                          yd}	 t        |j                  t        | j                              | _        |j                          |j                          d}|s!|j                          |j                          yy# 1 sw Y   xY w# |s!|j                          |j                          w w xY w)zRun the checkers in parallel.NFT)r   r   r   _try_initialize_processpoolr5   r"   
run_seriallistimap_unorderedr*   r?   r9   closejoin	terminate)r:   poolpool_closeds      r   run_parallelzManager.run_parallel   s    t||4 	E.tyy$))DD	E <OO	 3 3GT^^ LMDLJJLIIKK 		 	E 	E  		 s   !C AC  C %Dc                    | j                   D cg c]2  }t        || j                  | j                        j	                         4 c}| _        yc c}w )zRun the checkers in serial.r%   N)r?   r'   r   r   r(   r9   )r:   r&   s     r   rd   zManager.run_serial   sM     !NN
  ! jl	
 
s   7Ac                   	 | j                   dkD  r)t        | j                        dkD  r| j                          y| j	                          y# t
        $ r+ t        j                  d       t        j                  d      w xY w)a#  Run all the checkers.

        This will intelligently decide whether to run the checks in parallel
        or whether to run them in serial.

        If running the checks in parallel causes a problem (e.g.,
        :issue:`117`) this also implements fallback to serial processing.
        rY   z"Flake8 was interrupted by the userzEarly quit while running checksN)
r5   r>   r?   rl   rd   KeyboardInterruptrE   rF   r	   	EarlyQuitr:   s    r   runzManager.run   si    	Jyy1}T^^!4q!8!!#!  	JKK<=&&'HII	Js   7A A 4A?c                P   t         j                  d       t        t        | j                  j
                  | j                  j                  | j                  j                  | j                              | _        t        t        | j
                        | j                        | _        y)zStart checking files.

        :param paths:
            Path names to check. This is passed directly to
            :meth:`~Manager.make_checkers`.
        zMaking checkers)pathsstdin_display_namefilename_patternsr7   N)rE   infotupler   r   r?   ru   r&   r7   minr>   r5   rq   s    r   startzManager.start   sp     	"#ll,,#'<<#B#B"&,,"7"7	
 DNN+TYY7	r+   c                $    | j                          y)zStop checking files.N)rB   rq   s    r   stopzManager.stop  s      "r+   N)r3   r   r   r   r"   Sequence[str]returnNoner~   r   )r~   int)r&   strr9   Resultsr~   r   )r~   tuple[int, int])__name__
__module____qualname____doc__r;   rB   r4   rV   ra   rl   rd   rr   rz   r|    r+   r   r-   r-   U   se    $E&E E 	E
 
E*8<&1$(	
J$8$#r+   r-   c                      e Zd ZdZ	 	 	 	 	 	 	 	 ddZddZddZ	 	 	 	 	 	 	 	 	 	 ddZddZe	dd       Z
ddZdd	Zdd
ZddZddZddZ	 	 	 	 	 	 ddZy)r'   z;Manage running checks for a file and aggregate the results.c                  || _         || _        || _        g | _        dddd| _        | j                         | _        || _        d| _        | j                  h| j                  j                  | _        | j                  j                          | _        t        | j                  j                        | j                  d<   yy)zInitialize our file checker.r   )r2   r0   r1   FNr1   )r   r&   r   r9   r6   _make_processorr
   display_nameshould_processshould_ignore_filer>   lines)r:   r&   r   r   s       r   r;   zFileChecker.__init__  s       "

 --/$#>>% $ 7 7D&*nn&G&G&I"ID03DNN4H4H0IDOO,- &r+   c                     d| j                    S )z)Provide helpful debugging representation.zFileChecker for r)   rq   s    r   __repr__zFileChecker.__repr__%  s    !$--11r+   c           	         	 t        j                  | j                  | j                        S # t        $ r6}| j                  dddt        |      j                   d|        Y d }~y d }~ww xY w)NE902r   : )r
   FileProcessorr&   r   OSErrorra   typer   )r:   es     r   r   zFileChecker._make_processor)  s_    
	**4==$,,GG 	 KK1a)9)9(:"QC&@A	s   ), 	A+,A&&A+c                    ||j                  dd      \  }}t        | d      r(| j                  | j                  j                  |      }nd}| j                  j                  |||||f       |S )z2Report an error by storing it in the results list.N rY   r
   )splithasattrr
   noqa_line_forr9   append)r:   rT   rN   rU   rP   lines         r   ra   zFileChecker.report6  sp     #zz#q1J 4%$..*D>>//<DDZfdDIJr+   c                   | j                   J | j                         	 | j                   j                  |j                  |      }	  |j                  di ||S # t        $ r&}t        j                  |j                  |      d}~ww xY w# t        $ rS}t        j                  d|j                  d       t        j                  | j                  |j                  |      d}~ww xY w)z!Run the check in a single plugin.N)plugin_name	exceptionz(Plugin %s raised an unexpected exceptionT)exc_info)r&   r   r   r   )r
   r&   keyword_arguments_for
parametersAttributeErrorr	    PluginRequestedUnknownParametersr   obj	ExceptionrE   criticalPluginExecutionFailed)r:   plugin	argumentsparamsaeall_excs         r   	run_checkzFileChecker.run_checkK  s    ~~)84==8)	^^99!!9F	6::4	4V44  	=="//2 	  
	LL:##  
 22"//! 
	s0   &A B 	B	#!BB		C(AC##C(c                   t        | j                        dkD  rB| j                  d   r3t        | j                  d         dkD  r| j                  d   }|dd \  }}nit        | t        j                        rHt        | j                        dk(  r0t        | j                  d         dk(  rd}| j                  d   \  }}nd}d\  }}|dkD  rz|rxt        | t
              rht        |      dk(  rZd}d}|d   }|E|j                  d      j                  d      }t        |      dz
  }|d   }t        |      }	||	kD  r|	}||z  }||z  }||fS )	NrY   rZ      r   )rY   r   r      
)r>   args
isinstancetokenize
TokenErrorSyntaxErrorrstripr   )
r   tokenrowrU   column_offset
row_offsetrQ   r   logical_linelogical_line_lengths
             r   _extract_syntax_informationz'FileChecker._extract_syntax_informationd  sZ    	!#q!INN1%&*NN1%E!*KCy("5"56INN#q(INN1%&!+E#..+KCE KC QJ9k2E
a
 MJ "!HM
 (
 &,,T288> Z!^
$Qx&),&7#//0F:Cm#FF{r+   c                T   | j                   J | j                         | j                   j                         }| j                  j                  D ]G  }| j                  ||      }	 |j                         }|D ]  \  }}}}| j                  d|||        I y# t        $ r |}Y 1w xY w)z1Run all checks expecting an abstract syntax tree.N)treerT   rN   rU   rP   )	r
   r&   	build_astr   r   r   rr   r   ra   )	r:   astr   checkerrunnerrN   offsetrP   r@   s	            r   run_ast_checkszFileChecker.run_ast_checks  s    ~~)84==8)nn&&(ll'' 	FnnV#n6G!  17 ,VT1# +!	  	 " ! !s   %BB'&B'c                R   | j                   J | j                   j                         \  }}}|sy| j                   j                  |       t        j	                  d|j                                | j                  j                  D ]  }| j                   j                  |       | j                  ||      xs d}|D ]M  \  }}t        ||      \  }}	||	cxk(  rdk(  rn nt        j                  d|       | j                  d||	|       O  | j                   j                          y)z(Run all checks expecting a logical line.NzLogical line: "%s")r   r   r   z#position of error out of bounds: %sr   )r
   build_logical_lineupdate_staterE   debugr   r   r   update_checker_state_forr   find_offsetrF   ra   next_logical_line)
r:   commentsr   mappingr   r9   r   rP   rN   r   s
             r   run_logical_checkszFileChecker.run_logical_checks  s   ~~)))*...*K*K*M',##G,		&(;(;(=>ll// 	FNN33F;nnV,nGM2G ' 	-8-I*]-414KK EvN# +(	  			 	((*r+   c                   | j                   J | j                  j                  D ]  }| j                   j                  |       | j	                  ||      }|4d}	 |d   }t        |t              r|f}|D ]0  }|\  }}| j                  d| j                   j                  ||       2  y# t
        t        f$ r Y \w xY w)zoRun all checks for a given physical line.

        A single physical check may return multiple errors.
        N)rQ   r   r   )r
   r   rQ   r   r   
IndexError	TypeErrorr   r   ra   rN   )r:   rQ   r   resultr   result_singlerP   s          r   run_physical_checkszFileChecker.run_physical_checks  s    
 ~~)))ll00 	FNN33F;^^F-^HF! $$*1IM mS1$YF%+ M*7'M4KK#'$(NN$>$>,!	   !	 #I. s   B,,B>=B>c                   | j                   J d}| j                  }| j                   }d}|j                         D ]  }|dxx   dz  cc<   | j                  ||       |dd \  }}|t        j
                  k(  rt        j                  ||      }n+|dk(  r&t        j                  |      r| j                  |       |d   } |j                  r/| j                  |j                  d          | j                          yy)	zProcess tokens and trigger checks.

        Instead of using this directly, you should use
        :meth:`flake8.checker.FileChecker.run_checks`.
        Nr    r2   rY   rZ   r   )r
   r6   generate_tokenscheck_physical_eolr   OPcount_parenthesestoken_is_newlinehandle_newliner2   r   r   r   )r:   parensr6   file_processorprev_physicalr   
token_typerP   s           r   process_tokenszFileChecker.process_tokens  s     ~~)))__
#335 		%Ex A% ##E=9$QqzJX[[("44VTB1--e4''
3!!HM		%   $$^%9%9"%=>##% !r+   c           
        | j                   | j                  s#| j                  | j                  | j                  fS 	 | j                          | j                          | j                   j                  d   }|| j                  d<   | j                  | j                  | j                  fS # t        t        j                  f$ r}t        |t        j                        rdnd}| j                  |      \  }}| j                  |||t        |      j                   d|j                  d           | j                  | j                  | j                  fcY d}~S d}~ww xY w)zRun checks against the file.Nr   E999r   r   r0   )r
   r   r   r9   r6   r   r   r   r   r   r   r   ra   r   r   r   )r:   r   rM   r   rU   logical_liness         r   r(   zFileChecker.run_checks  s    >>!)<)<$$dllDOOCC	D!! 11/B+8(  $,,?? X001 	D'8+>+>?6VD::1=KCKKc6d1g.>.>-?r!&&)+MN$$dllDOOCC		Ds    B( (EBEEEc                j   | j                   J |t        j                  k(  r+| j                          | j                   j	                          yt        | j                   j                        dk(  r5| j                   j                          | j                   j                          y| j                          y)z3Handle the logic when encountering a newline token.NrY   )	r
   r   NEWLINEr   reset_blank_beforer>   r2   visited_new_blank_linedelete_first_token)r:   r   s     r   r   zFileChecker.handle_newline  s    ~~))))))##%NN--/&&'1,NN113NN--/##%r+   c                B   | j                   J |j                  t        k(  r)| j                   j                  |j                  d          y|j                  t
        k(  r)| j                   j                  |j                  d          yt        j                  |      r=|j                  dk(  r| j                  |       y| j                  |j                         yt        j                  |      r2| j                   j                  |      D ]  }| j                  |        yy)z@Run physical checks if and only if it is at the end of the line.Nr   r   )r
   r   r   fstring_startrz   r   tstring_startis_eol_tokenr   r   is_multiline_stringmultiline_string)r:   r   r   r   s       r   r   zFileChecker.check_physical_eol'  s     ~~)))::&NN((Q8ZZ=(NN((Q8##E* zzR((7((4**51 77> /((./ 2r+   N)r&   r   r   r   r   r   r~   r   )r~   r   )r~   zprocessor.FileProcessor | None)
rT   z
str | NonerN   r   rU   r   rP   r   r~   r   )r   r   r   r   r~   r   )r   r   r~   r   r   )rQ   r   r~   r   )r~   #tuple[str, Results, dict[str, int]])r   r   r~   r   )r   ztokenize.TokenInfor   r   r~   r   )r   r   r   r   r;   r   r   ra   r   staticmethodr   r   r   r   r   r(   r   r   r   r+   r   r'   r'   	  s    EJ J 	J
 $J 
J22  	
  
*2 8 8t*+4>&6@$&/'/8;/	/r+   r'   c                    	 t        j                  | t        |f      S # t        $ r}|j                  t
        vr Y d}~yd}~wt        $ r Y yw xY w)z@Return a new process pool instance if we are able to create one.)initargsN)rH   Poolr#   r   errnoSERIAL_RETRY_ERRNOSImportError)	job_countr"   errs      r   rc   rc   I  sX    
##Ix4'JJ 99// 0
   s    	AA  AAc                    t        | t              r| S |D ]  }|d   }| |k  s|d   } n d}dx} }|d   |d   | z   |z
  fS )z*Find the offset tuple for a single offset.r   rY   )r   r   )r   rx   )r   r   r   token_offsetpositions        r   r   r   Y  sm     &%  "Qx\!QxH	"  !!QK!v-<==r+   )r   r   r   r   r~   zGenerator[None])r"   r}   r~   r   )r&   r   r~   r   )r  r   r"   r}   r~   z multiprocessing.pool.Pool | None)r   r   r   zprocessor._LogicalMappingr~   r   )6r   
__future__r   argparse
contextlibr   loggingmultiprocessing.poolrH   r\   r   r   collections.abcr   r   typingr   r   flake8r   r	   r
   r   flake8._compatr   r   flake8.discover_filesr   flake8.options.parse_argsr   flake8.plugins.finderr   r   flake8.style_guider   re   rx   r   r   r   	getLoggerr   rE   ENOSPCr   __annotations__contextmanagerr   r#   r*   r-   r'   rc   r   r   r+   r   <module>r     s1   * "         % $       ( ( . 0 * . 0
uS#sC#67
8g! 
LL     	%	% 2	%	% 	%=q# q#h}/ }/@

 & >>3>>r+   