,h*:UddlmZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z ddlmZddlmZmZdd lmZmZdd lmZmZmZmZerdd lmZmZmZmZmZdd l m!Z!Gd deZ"GddedZ#GddedZ$GddedZ%GddeZ&GddedZ'GddeZ(Gdde(eZ)Gdd e(eZ*ee)gdfZ+ee*gdfZ,ed!Z-d"e.d#<e/Z0Gd$d%e Z1Gd&d'e Z2dZ3d(Z4d)Z5d*Z6d+Z7d,Z8d-Z9d.Z:d/Z;d0Ze?d2Z@dDd3ZAGd4d5ZBGd6d7ZCGd8d9ZDGd:d;eDZEGd<d=eDZFGd>d?eDZGGd@dAZHdif dEdBZI dF dGdCZJy)H) annotationsN)Message)IntEnum)BufferedRandomBytesIO)Number) TYPE_CHECKINGcast) Base64DecoderQuotedPrintableDecoder) FileErrorFormParserErrorMultipartParseErrorQuerystringParseError)AnyCallableLiteralProtocol TypedDict) TypeAliasceZdZddZy) SupportsReadcyN)self_SupportsRead__ns \/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/python_multipart/multipart.pyreadzSupportsRead.readN)rintreturnbytes)__name__ __module__ __qualname__r rr"rrrs.r"rc@eZdZUded<ded<ded<ded<ded<y) QuerystringCallbacksCallable[[], None]on_field_start!Callable[[bytes, int, int], None] on_field_name on_field_data on_field_endon_endNr&r'r(__annotations__rr"rr*r*s **8888((""r"r*F)totalc,eZdZUded<ded<ded<y)OctetStreamCallbacksr+on_startr-on_datar1Nr2rr"rr6r6 s$$22""r"r6cheZdZUded<ded<ded<ded<ded<ded<ded <ded <ded <y ) MultipartCallbacksr+ on_part_beginr- on_part_data on_part_endon_header_beginon_header_fieldon_header_value on_header_endon_headers_finishedr1Nr2rr"rr:r:%s8))77''++::::))//""r"r:cJeZdZUded<ded<ded<ded<ded<d ed <y ) FormParserConfigz str | None UPLOAD_DIRboolUPLOAD_KEEP_FILENAMEUPLOAD_KEEP_EXTENSIONSUPLOAD_ERROR_ON_BAD_CTEr#MAX_MEMORY_FILE_SIZEfloat MAX_BODY_SIZENr2rr"rrDrD0s&"" $$!%%!!r"rDc@eZdZUded<ded<ded<ded<ded<y ) FileConfigstr | bytes | NonerErFUPLOAD_DELETE_TMPrGrHr#rJNr2rr"rrNrN8s &&"" $$!!r"rNc$eZdZddZddZddZy) _FormProtocolcyrrrdatas rwritez_FormProtocol.write@r!r"cyrrrs rfinalizez_FormProtocol.finalizeBr!r"cyrrrXs rclosez_FormProtocol.closeDr!r"NrUr%r$r#r$None)r&r'r(rVrYr[rr"rrRrR?s 0'$r"rRceZdZddZddZy) FieldProtocolcyrrrnames r__init__zFieldProtocol.__init__Gr!r"cyrrrXs rset_nonezFieldProtocol.set_noneIr!r"Nrc bytes | Noner$r^r])r&r'r(rdrfrr"rr`r`Fs;'r"r`ceZdZddZy) FileProtocolcyrr)r file_name field_nameconfigs rrdzFileProtocol.__init__Lr!r"NrlrhrmrhrnrNr$r^)r&r'r(rdrr"rrjrjKsnr"rj)startrUend field_startrm field_data field_end part_begin part_datapart_end header_begin header_field header_value header_endheaders_finishedr CallbackNameceZdZdZdZdZdZy)QuerystringStatezQuerystring parser states. These are used to keep track of the state of the parser, and are used to determine what to do when new data is encountered. rr N)r&r'r(__doc__ BEFORE_FIELD FIELD_NAME FIELD_DATArr"rrrgs LJJr"rcDeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZy)MultipartStatezMultipart parser states. These are used to keep track of the state of the parser, and are used to determine what to do when new data is encountered. rr r N)r&r'r(rSTARTSTART_BOUNDARYHEADER_FIELD_START HEADER_FIELDHEADER_VALUE_START HEADER_VALUEHEADER_VALUE_ALMOST_DONEHEADERS_ALMOST_DONEPART_DATA_START PART_DATA PART_DATA_END END_BOUNDARYENDrr"rrrssN ENLL OIML Cr"rr r: -&;azsMABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'*+-.^_`|~c`|sdifSt|tr|jd}t|tsJdd|vr/|j j j difSt}||d<|j}|sJd|jddj d}i}|D]h}|\}}t|tr|d}|d k(r$|d d d k(s|d ddk(r|jdd}|j d||j d<j||fS)z`Parses a Content-Type header into a value in the following format: (content_type, {parameters}).r"latin-1zValue should be a string by now;z content-typez1At least the content type value should be presentrfilenamer rz:\Nrz\\\) isinstancer%decodestrlowerstripencoder get_paramspoptuplesplit)valuemessageparamsctypeoptionsparamkeys rparse_options_headerrsM Ry% Y' eS !D#DD % ##%,,Y7<<iG#GN    !F FFF JJqM!  # #I .E"$G A U eU #"IE * QqzU"eBQi6&9 D)"-).i)@ 9%& A '>r"ceZdZdZddZeddZddZddZddZ ddZ ddZ dd Z e dd Ze dd Zdd Zdd Zy)FieldaA Field object represents a (parsed) form field. It represents a single field with a corresponding name and value. The name that a :class:`Field` will be instantiated with is the same name that would be found in the following HTML:: This class defines two methods, :meth:`on_data` and :meth:`on_end`, that will be called when data is written to the Field, and when the Field is finalized, respectively. Args: name: The name of the form field. c6||_g|_t|_yr)_name_value_missing_cacherbs rrdzField.__init__s #%  r"c~||}||jn|j||j|S)aCreate an instance of a :class:`Field`, and set the corresponding value - either None or an actual value. This method will also finalize the Field itself. Args: name: the name of the form field. value: the value of the form field - either a bytestring or None. Returns: A new instance of a [`Field`][python_multipart.Field]. )rfrVrY)clsrcrfs r from_valuezField.from_values4 I = JJL GGEN r"c$|j|S)zWrite some data into the form field. Args: data: The data to write to the field. Returns: The number of bytes written. r8rTs rrVz Field.writes||D!!r"cd|jj|t|_t |S)zThis method is a callback that will be called whenever data is written to the Field. Args: data: The data to write to the field. Returns: The number of bytes written. )rappendrrlenrTs rr8z Field.on_data s' 4  4yr"cj|jtur!dj|j|_yy)6This method is called whenever the Field is finalized.r"NrrjoinrrXs rr1z Field.on_ends' ;;( "((4;;/DK #r"c$|jy)zFinalize the form field.Nr1rXs rrYzField.finalizes  r"cl|jtur dj|j|_|`y)z=Close the Field object. This will free any underlying cache.r"NrrXs rr[z Field.close"s) ;;( "((4;;/DK Kr"cd|_y)aSome fields in a querystring can possibly have a value of None - for example, the string "foo&bar=&baz=asdf" will have a field with the name "foo" and value None, one with name "bar" and value "", and one with name "baz" and value "asdf". Since the write() interface doesn't support writing None, this function will set the field value to None. N)rrXs rrfzField.set_none*s  r"c|jS)z,This property returns the name of the field.)rrXs rrmzField.field_name3szzr"c|jtur dj|j|_t |jt s|jJ|jS)z2This property returns the value of the form field.r")rrrrrr%rXs rrz Field.value8sH ;;( "((4;;/DK$++u-1DD{{r"ct|tr4|j|jk(xr|j|jk(StSr)rrrmrNotImplemented)rothers r__eq__z Field.__eq__As9 eU #??e&6&66T4::;T T! !r"c|j7t|jdkDrt|jdddddz}nt|j}dj|jj |j |S)Nrrz...'z{}(field_name={!r}, value={}))rrreprformat __class__r&rm)rvs r__repr__zField.__repr__Gso :: !c$**o&:TZZ_%cr*V3ATZZ A.55dnn6M6Mt`abbr"Nrg)rcr%rrhr$rr\r]r$rh)robjectr$rFr$r)r&r'r(rrd classmethodrrVr8r1rYr[rfpropertyrmrrrrr"rrrsq * " 0 " cr"rceZdZdZdifddZeddZeddZeddZeddZ eddZ edd Z dd Z dd Z dd Zdd ZddZddZddZddZy)Filea[This class represents an uploaded file. It handles writing file data to either an in-memory file or a temporary file on-disk, if the optional threshold is passed. There are some options that can be passed to the File to change behavior of the class. Valid options are as follows: | Name | Type | Default | Description | |-----------------------|-------|---------|-------------| | UPLOAD_DIR | `str` | None | The directory to store uploaded files in. If this is None, a temporary file will be created in the system's standard location. | | UPLOAD_DELETE_TMP | `bool`| True | Delete automatically created TMP file | | UPLOAD_KEEP_FILENAME | `bool`| False | Whether or not to keep the filename of the uploaded file. If True, then the filename will be converted to a safe representation (e.g. by removing any invalid path segments), and then saved with the same name). Otherwise, a temporary name will be used. | | UPLOAD_KEEP_EXTENSIONS| `bool`| False | Whether or not to keep the uploaded file's extension. If False, the file will be saved with the default temporary extension (usually ".tmp"). Otherwise, the file's extension will be maintained. Note that this will properly combine with the UPLOAD_KEEP_FILENAME setting. | | MAX_MEMORY_FILE_SIZE | `int` | 1 MiB | The maximum number of bytes of a File to keep in memory. By default, the contents of a File are kept into memory until a certain limit is reached, after which the contents of the File are written to a temporary file. This behavior can be disabled by setting this value to an appropriately large value (or, for example, infinity, such as `float('inf')`. | Args: file_name: The name of the file that this [`File`][python_multipart.File] represents. field_name: The name of the form field that this file was uploaded with. This can be None, if, for example, the file was uploaded with Content-Type application/octet-stream. config: The configuration for this File. See above for valid configuration keys and their corresponding values. Nctjt|_||_d|_d|_t|_||_ ||_ d|_ |1tjj|\}}||_||_yy)NTr)logging getLoggerr&logger_config _in_memory_bytes_writtenr_fileobj _field_name _file_name_actual_file_nameospathsplitext _file_base_ext)rrlrmrnbaseexts rrdz File.__init__is''1  29) &#04  ((3ID#"DODI !r"c|jS)zThe form field associated with this file. May be None if there isn't one, for example when we have an application/octet-stream upload. )rrXs rrmzFile.field_names r"c|jS)z*The file name given in the upload request.)rrXs rrlzFile.file_namesr"c|jS)zmThe file name that this file is saved as. Will be None if it's not currently saved on disk. )rrXs ractual_file_namezFile.actual_file_names %%%r"c|jS)zThe file object that we're currently writing to. Note that this will either be an instance of a :class:`io.BytesIO`, or a regular file object. )rrXs r file_objectzFile.file_objects }}r"c|jS)zzThe total size of this file, counted as the number of bytes that currently have been written to the file. )rrXs rsizez File.sizes """r"c|jS)zqA boolean representing whether or not this file object is currently stored in-memory or on-disk. )rrXs r in_memoryzFile.in_memorys r"ct|js|jjdy|jj d|j }t j|j||j |j|j}||_d|_|jy)aFIf the file is already on-disk, do nothing. Otherwise, copy from the in-memory buffer to a disk file, and then reassign our internal file object to this new disk file. Note that if you attempt to flush a file that is already on-disk, a warning will be logged to this module's logger. z0Trying to flush to disk when we're not in memoryNrF) rrwarningrseek_get_disk_fileshutil copyfileobjrr[)rnew_file old_fileobjs r flush_to_diskzFile.flush_to_disks KK   R S  1&&( 4==(3  d))*mm     r"cX|jjd|jjd}|jjdd}|jjdd}|jjdd}d}||r|jjd ||r|j|j zn |j}t jj||} |jjd |t|d }n|r-|j jtjnd}|d} n6t!|t"r$|jtj} n|} |jjd||| d t%t&t)j*||| }|Jt!|j,t.r.|j,j1tj}nt%t"|j,}||_|S#t$r,d}|jjd td |zwxYw#t$r'|jjdtdwxYw)zFThis function is responsible for getting a file object on-disk for us.zOpening a file on diskrErGFrHrPTNzSaving with filename in: %rzOpening file: %rzw+bzError opening temporary filez Error opening temporary file: %rz*Creating a temporary file with options: %r)suffixdeletedirz#Error creating named temporary file)rinforgetrrrrropenOSError exceptionrrsysgetfilesystemencodingrr%r rtempfileNamedTemporaryFilercrrr) rfile_dir keep_filenamekeep_extensions delete_tmptmp_filefnamerrrs rrzFile._get_disk_filesH 12<<##L1 (()?G ,,**+CUK\\%%&94@ *.  M KK  :H E4CDOOdii/E77<<%0D K   !3T:e,GVTYY%%c&?&?&AB[_FHe,ooc&?&?&AB KK  <[enq>r  G0K0KSYblru0vw ' '(--- ,,S-F-F-HIUHMM2!&I K %%&DE BT IJJ  K0 G %%&KL EFF Gs5(I,&I95I690J)c$|j|S)zHWrite some data to the File. :param data: a bytestring rrTs rrVz File.writes ||D!!r"c|jj|}|t|k7r(|jj d|t||S|xj |z c_|j jd}|jr<|:|j |kDr+|jjd|j|S)zThis method is a callback that will be called whenever data is written to the File. Args: data: The data to write to the file. Returns: The number of bytes written. z bwritten != len(data) (%d != %d)rJzFlushing to disk) rrVrrrrrrrrr )rrUbwrittenmax_memory_file_sizes rr8z File.on_data s==&&t, s4y KK   BHcRVi XO x' $||//0FG ??3?TEXEX[oEo KK  / 0    r"c8|jjy)rN)rflushrXs rr1z File.on_end*s r"c$|jy)zFinalize the form file. This will not close the underlying file, but simply signal that we are finished writing to the File. NrrXs rrYz File.finalize/s  r"c8|jjy)zClose the File object. This will actually close the underlying file object (whether it's a :class:`io.BytesIO` or an actual file object). N)rr[rXs rr[z File.close5s r"cxdj|jj|j|jS)Nz#{}(file_name={!r}, field_name={!r}))rrr&rlrmrXs rrz File.__repr__<s/4;;DNNr$r^)rcr}r5zCallable[..., Any] | Noner$r^r) r&r'r(rrdr3r6r[rYrrr"rr+r+@sU(^ jn (4DN\f < 4  0r"r+cNeZdZdZiedfdfd ZddZd dZd dZxZ S) OctetStreamParseraBThis parser parses an octet-stream request body and calls callbacks when incoming data is received. Callbacks are as follows: | Callback Name | Parameters | Description | |----------------|-----------------|-----------------------------------------------------| | on_start | None | Called when the first data is parsed. | | on_data | data, start, end| Called for each data chunk that is parsed. | | on_end | None | Called when the parser is finished parsing all data.| Args: callbacks: A dictionary of callbacks. See the documentation for [`BaseParser`][python_multipart.BaseParser]. max_size: The maximum size of body to parse. Defaults to infinity - i.e. unbounded. infct|||_d|_t |t r|dkrt d|z||_d|_yNFr *max_size must be a positive number, not %rr) superrdr-_startedrr ValueErrormax_size _current_size)rr-rHrs rrdzOctetStreamParser.__init__sL " (F+x!|IHTU U%- r"c|js|jdd|_t|}|j|z|jkDrWt |j|jz }|j jd|j|j|||}|xj|z c_|jd|d||S)aWrite some data to the parser, which will perform size verification, and then pass the data to the underlying callback. Args: data: The data to write to the parser. Returns: The number of bytes written. rpTDCurrent size is %d (max %d), so truncating data length from %d to %drUr)rFr3rrIrHr#rr)rrUdata_lennew_sizes rrVzOctetStreamParser.writes}} MM' " DMt9    )T]] :4==4+=+==>H KK  V""    H h& fdAx0r"c&|jdy)ztFinalize this parser, which signals to that we are finished parsing, and sends the on_end callback. rqN)r3rXs rrYzOctetStreamParser.finalizes er"c4d|jjzSr;r<rXs rrzOctetStreamParser.__repr__r=r")r-r6rHrKr\r]r) r&r'r(rrKrdrVrYr __classcell__rs@rr@r@s) :H KK  V""    H  $$$T84A   ! #    ! #  B++Cc|j}|j}|j}d}||kr||}|tjk(ry|t k(s |t k(r=|r7|rtd|z}||_||jjd|nd}n|jd|dz}tj}d}n|tjk(r|jd|} | dk(r|jd |} | dk7r|jd || } n|jd |} | dk7r(|jd ||| | }tj}nW|sX| dk7r<|jd ||| |jd | dz }tj}n|jd ||||}n| dk7rtd |fz}||_||jd ||||}n|tjk(r|jd|} | dk(r|jd |} | dk7r;|jd||| |jd | dz }tj}nM|jd||||}n6d||fz} |jj| t| }||_||dz }||kr||_||_t!|S)Nrz,Skipping duplicate ampersand/semicolon at %dTrrr F&r;=rmrtz{When strict_parsing is True, we require an equals sign in all field chunks. Did not find one in the chunk that starts at %drs!Reached an unknown state %d at %d)rTrWrVrr AMPERSAND SEMICOLONroffsetrr0r3rfindrrr) rrUlengthrTrW found_sepichesep_pos equals_posmsgs rrZz!QuerystringParser._internal_write"s ,,OO &jaB(555?bIo ) 56dgh6h iA'(AH"#G KK--.\^_` %) MM-0FA,77E %I*555))D!,b="iia0G b=!%4G!> NN # #T%8%8$--  r")r-r*rWrFrHrKr$r^r\rUr%rhr#r$r#r]r) r&r'r(rr3rKrdrVrZrYrrPrQs@rrSrSs\* 135dijodp---DH-\a- -$"HHT r"rScdeZdZdZiedf dfd Zd dZd dZd dZd dZ xZ S) MultipartParseraEThis class is a streaming multipart/form-data parser. | Callback Name | Parameters | Description | |--------------------|-----------------|-------------| | on_part_begin | None | Called when a new part of the multipart message is encountered. | | on_part_data | data, start, end| Called when a portion of a part's data is encountered. | | on_part_end | None | Called when the end of a part is reached. | | on_header_begin | None | Called when we've found a new header in a part of a multipart message | | on_header_field | data, start, end| Called each time an additional portion of a header is read (i.e. the part of the header that is before the colon; the "Foo" in "Foo: Bar"). | | on_header_value | data, start, end| Called when we get data for a header. | | on_header_end | None | Called when the current header is finished - i.e. we've reached the newline at the end of the header. | | on_headers_finished| None | Called when all headers are finished, and before the part data starts. | | on_end | None | Called when the parser is finished parsing all data. | Args: boundary: The multipart boundary. This is required, and must match what is given in the HTTP request - usually in the Content-Type header. callbacks: A dictionary of callbacks. See the documentation for [`BaseParser`][python_multipart.BaseParser]. max_size: The maximum size of body to parse. Defaults to infinity - i.e. unbounded. rAc<t|tj|_dx|_|_||_t|tr|dkrtd|z||_ d|_ i|_ t|tr|jd}d|z|_y)Nrr rDrs --)rErdrrrTindexflagsr-rrrGrHrImarksrrboundary)rryr-rHrs rrdzMultipartParser.__init__s #)) "## TZ"(F+x!|IHTU U  &(  h $y1H!H, r"ct|}|j|z|jkDrWt|j|jz }|jj d|j|j|||}d} |j ||}|xj|z c_|S#|xj|z c_wxYw)a3Write some data to the parser, which will perform size verification, and then parse the data into the appropriate location (e.g. header, data, etc.), and pass this on to the underlying callback. If an error is encountered, a MultipartParseError will be raised. The "offset" attribute on the raised exception will be set to the offset of the byte in the input chunk that caused the error. Args: data: The data to write to the parser. Returns: The number of bytes written. rKrrYr[s rrVzMultipartParser.writer]r^cjj}j}j}ddfd }ddfd }ddfd }kr8} |tj k(r1| t k(s | tk(rdz 6d}tj}dzn|tjk(r9|tdz k(r_| tk(rtj}n>| t k7r5dfz} jj| t| } | _| |dz }n_|tdz dzk(rc| tk7r5dfz} jj| t| } | _| d}j!d tj"}n| |dzk7r@d |dz| |dzfz} jj| t| } | _| |dz }n|tj"k(r;d}|d | t k7rj!d tj$}dznH|tj$k(r| t k(r$|dk(r|d tj&}dz *|dz }| t(k(rU|dk(r5d fz} jj| t| } | _| |d tj*}n| t,vrd| fz} jj| t| } | _| |tj*k(r/| t.k(rdz |dtj0}dzn$|tj0k(r6| t k(r|dj!dtj2}n|tj2k(rP| tk7r5d| d} jj| t| } | _| tj"}nx|tj&k(ra| tk7r5d| d} jj| t| } | _| j!dtj4}n|tj4k(r|dtj6}dzn|tj6k(r|} t} }|dk(rfj9|}|dk\r| dz }|| zdz n;t;|| z |dz kr$dk7rdz |dz kr dk7r} || kr|| k(r|dz }nd}n|| k(r.|dz }| t k(r |t<z}n| tk(r |t>z}nd}n|| dzk(r|t<zrg| tk(rQ|t<z}|d|z j!dj!d d}tj"}dz d}|t<z}nS|t>zrJ| tk(r?|d|z j!dj!dtj@}nd}|dk(r)| dkDr#d} dzn|tjk(ry|tdz dzk(r| tk7r5dfz} jj| t| } | _| |dz }j!dtj@}n|tj@k(rE| t k(rdzkrdztk(rdz މjjdnBd|fz} jj| t| } | _| dz kr8|d d|dd|d|z d|_|_|_S) Nrc$j|<yr)rx)rcrjrs rset_markz1MultipartParser._internal_write..set_marks DJJt r"c>jj|dyr)rxr)rcresetrs r delete_markz4MultipartParser._internal_write..delete_marks JJNN4 &r"cL jj|}|y||krn|dk\r j|||n| }|tkr j|d|nu jt zrdz} j||d|nH jt zrdz} j||d|n jjd|dkDr j|d||r|z j|<y jj|dy)Nrs s-- zLook-back buffer error) rxrr3rrwFLAG_PART_BOUNDARYFLAG_LAST_BOUNDARYrrr) rcend_i remaining marked_indexlookbehind_lenlookbackryrUrhrs r data_callbackz6MultipartParser._internal_write..data_callback&s::>>$/L# $" dD,> #/!S]2MM$!^DZZ"44''1HMM$!^DZZ"44')3HMM$!^DKK''(@A19MM$a7#(6> 4  tT*r"r rz'Did not find CR at end of boundary (%d)z'Did not find LF at end of boundary (%d)ruz2Expected boundary character %r, got %r at index %dryrxzFound 0-length header at %dz*Found invalid character %r in header at %drzr{z2Did not find LF character at end of header (found )z)Did not find LF at end of headers (found r|rvrwrqz&Did not find - at end of boundary (%d)z!Skipping data after last boundaryrcT)rcrr$r^)F)rcrrrFr$r^)rcr}rr#rrFr$r^)!ryrTrvrwrrCRLFrrHYPHENrrrrrfr3rrrCOLONrTOKEN_CHARS_SETSPACErrrrrgmaxrrr)rrUrhrTrvrwr}rrcrorl prev_indexboundary_length data_lengthi0ryrjs``` @@rrZzMultipartParser._internal_write s==     ! '% +% +P&jQA,,,7a2gFA'55Q.777CMA--F{ . ; ;bG1$N ++C0/4#$QJEc(ma/!33BwG1$N ++C0/4#$EMM,/+==EHUQY//RV^_dgh_hViklnsvwnwUxx ++C0/4#$QJE.;;;( 7MM.1'33Q.5557uz/*>>EFA :z;qdB ++C0/4#$".!4+==Eo-F!QOCKK'',+C0A AHG.;;;:FA('33Q.5557!.!4MM,/*CCE.AAA7XY[CKK'',+C0A AHG '99.<<<7EaU!LCKK'',+C0A AHG 01&66.888%'00Q.222# #&h-$ A:8Q 48    r"cy)a'Finalize this parser, which signals to that we are finished parsing. Note: It does not currently, but in the future, it will verify that we are in the final state of the parser (i.e. the end of the multipart message is well-formed), and, if not, throw an error. NrrXs rrYzMultipartParser.finalizes r"cN|jjd|jdS)Nz (boundary=r)rr&ryrXs rrzMultipartParser.__repr__s%..))**T]]4EQGGr")ryz bytes | strr-r:rHrKr$r^r\rrr]r) r&r'r(rrKrdrVrZrYrrPrQs@rrtrtsU*FH[`af[g-#-0B-SX- -."HcJ  Hr"rtceZdZUdZedddddddZded<dddeeif dd Z dd Z dd Z dd Z dd Z y) FormParsera This class is the all-in-one form parser. Given all the information necessary to parse a form, it will instantiate the correct parser, create the proper :class:`Field` and :class:`File` classes to store the data that is parsed, and call the two given callbacks with each field and file as they become available. Args: content_type: The Content-Type of the incoming request. This is used to select the appropriate parser. on_field: The callback to call when a field has been parsed and is ready for usage. See above for parameters. on_file: The callback to call when a file has been parsed and is ready for usage. See above for parameters. on_end: An optional callback to call when all fields and files in a request has been parsed. Can be None. boundary: If the request is a multipart/form-data request, this should be the boundary of the request, as given in the Content-Type header, as a bytestring. file_name: If the request is of type application/octet-stream, then the body of the request will not contain any information about the uploaded file. In such cases, you can provide the file name of the uploaded file manually. FileClass: The class to use for uploaded files. Defaults to :class:`File`, but you can provide your own class if you wish to customize behaviour. The class will be instantiated as FileClass(file_name, field_name), and it must provide the following functions:: - file_instance.write(data) - file_instance.finalize() - file_instance.close() FieldClass: The class to use for uploaded fields. Defaults to :class:`Field`, but you can provide your own class if you wish to customize behaviour. The class will be instantiated as FieldClass(field_name), and it must provide the following functions:: - field_instance.write(data) - field_instance.finalize() - field_instance.close() - field_instance.set_none() config: Configuration to use for this FormParser. The default values are taken from the DEFAULT_CONFIG value, and then any keys present in this dictionary will overwrite the default values. rANF)rLrJrErGrHrIrDDEFAULT_CONFIGc F !tjt_|_|_d_d___ |_ t_ t_jj!_j"j%| d} |dk(r?ddfd } d fd } dfd } t'| | | dj"d} | _y|d k(s|d k(rMg ddd }d fd }d  fd }d fd }dfd } t)||||| dj"d} | _y|dk(r|&jj+dt-dggidd!ddfd }d !fd }dfd }d fd }d fd }dfd }d!fd }d!fd } t/||||||||| dj"d} | _yjj1d|t-dj3|)!Nrzapplication/octet-streamcDdtdjy)NrNrn)r rn) FileClassfilerlrsrr7z%FormParser.__init__..on_starts DlDKK9XYr"c.j|||yrrV)rUrprqrs rr8z$FormParser.__init__..on_datas 4c?+r"ctjrjjyyrrYr1)ron_filersr_on_endz$FormParser.__init__.._on_ends4 DM;;*KKM+r")r7r8r1rL)r-rHz!application/x-www-form-urlencodedzapplication/x-url-encodedcyrrrr"rr,z+FormParser.__init__..on_field_start5sr"c.j|||yrr)rUrprq name_buffers rr.z*FormParser.__init__..on_field_name8""4c?3r"cjdjdd=j|||yNr")rrV)rUrprq FieldClassrrs rr/z*FormParser.__init__..on_field_data;s49"388K#89A#AU3(r"c,djdd=jjrdyr)rrfrY)rrron_fieldsrr0z)FormParser.__init__..on_field_endBsG9#388K#89A#AJJL QKr"c@jjyyrrrXsrrz$FormParser.__init__.._on_endQs;;*KKM+r")r,r.r/r0r1zmultipart/form-datazNo boundary givenFc iyrr)headerssrr;z*FormParser.__init__..on_part_beginns r"c6Jj|||yrr)rUrprqwriters rr<z)FormParser.__init__..on_part_datass)) T%_-r"ctJjr r yyrtdyy)Nr`)rYr )f_multiis_filerrsrr=z(FormParser.__init__..on_part_endysD**  "(  ow!?@ r"c.j|||yrr)rUrprq header_names rr?z,FormParser.__init__..on_header_fieldrr"c.j|||yrr)rUrprqrzs rr@z,FormParser.__init__..on_header_values##DsO4r"c`djdj<dd=dd=yr)r)rrzrsrrAz*FormParser.__init__..on_header_ends-14,1G-.N Or"cd jd}t|\}}|jd}|jd}| |n!||td jd jdd }|d vr y|d k(r t  y|d k(r t  y j jd | jdrtdj| y)NFsContent-DispositionsnamesfilenamerNrTsContent-Transfer-Encoding7bit)sbinarys8bitrsbase64squoted-printablez%Unknown Content-Transfer-Encoding: %rrIz(Unknown Content-Transfer-Encoding "{!r}") rrr rnr r rrrr) content_dispdisprrmrltransfer_encodingrrrrrrrs rrBz0FormParser.__init__..on_headers_finisheds  '{{+AB 4\ B g%[[1 #KK 4 $(4G' :d._on_ends+%OO%;;*KKM+r")r;r<r=r?r@rArBr1zUnknown Content-Type: %rzUnknown Content-Type: {}r])rUr%rpr#rqr#r$r^)rrr&r content_typerybytes_receivedparserrrr1rrrrrcopyrnupdater@rSerrorrrtrr)"rrrrr1ryrlrrrnrr7r8rr,r.r/r0r;r<r=r?r@rArBrrrrrzrrrrs"` `` ``` @@@@@@@@@rrdzFormParser.__init__sI''1 )   !   )-(;(;(@(@(B  6"QU 5 5!%D Z Z , "''/GwW_5FX O@ @LToDo')K&*A  4 )   " '&4%2%2$0% _5 FB m2 2 !!"56%&9::')K(*L*,G;?GFG   . A A 4 5 $ + )+ )Z "%%2$0#.'6'6%2+>% _5 F&  KK   :L I!"<"C"CL"QR Rr"c|xjt|z c_|jJ|jj|S)zWrite some data. The parser will forward this to the appropriate underlying parser. Args: data: The data to write. Returns: The number of bytes processed. )rrrrVrTs rrVzFormParser.writes; s4y({{&&{{  &&r"c|j2t|jdr|jjyyy)zFinalize the parser.NrY)rhasattrrYrXs rrYzFormParser.finalizes2 ;; "wt{{J'G KK "(H "r"c|j2t|jdr|jjyyy)zClose the parser.Nr[)rrr[rXs rr[zFormParser.closes2 ;; "wt{{G'D KK   (E "r"cxdj|jj|j|jS)Nz"{}(content_type={!r}, parser={!r}))rrr&rrrXs rrzFormParser.__repr__s/3::4>>;R;RTXTeTegkgrgrssr")rrrOnFieldCallback | NonerOnFileCallback | Noner1zCallable[[], None] | Noneryzbytes | str | Nonerlrhrztype[FileProtocol]rztype[FieldProtocol]rndict[Any, Any]r$r^r\r]r)r&r'r(rrKrr3rrrdrVrYr[rrr"rrrsHu / %"'#((N$-1'+"&(,*/!#ii)i' i * i % i i&i(ii iV '#  tr"rc6|jd}|3tjtj dt dt |\}}|jd}|jd}|jd}t||||||} | S)aThis function is a helper function to aid in creating a FormParser instances. Given a dictionary-like headers object, it will determine the correct information needed, instantiate a FormParser with the appropriate values and given callbacks, and then return the corresponding parser. Args: headers: A dictionary-like object of HTTP headers. The only required header is Content-Type. on_field: Callback to call with each parsed field. on_file: Callback to call with each parsed file. trust_x_headers: Whether or not to trust information received from certain X-Headers - for example, the file name from X-File-Name. config: Configuration variables to pass to the FormParser. z Content-TypezNo Content-Type header givenzNo Content-Type header given!sboundaryrz X-File-Name)ryrlrn) rrrr&rrGrrr) rrrtrust_x_headersrnrrryrl form_parsers rcreate_form_parserrs*(/{{>'BL(#++,JK8990 =L&zz+&H &&y1L M*I\8Wx[dmstK r"cRt|||}|jd}| t|}n td}d} tt ||z |}|j |} |j | |t| z }t| |k7s||k(rn]|jy)aThis function is useful if you just want to parse a request body, without too much work. Pass it a dictionary-like object of the request's headers, and a file-like object for the input stream, along with two callbacks that will get called whenever a field or file is parsed. Args: headers: A dictionary-like object of HTTP headers. The only required header is Content-Type. input_stream: A file-like object that represents the request body. The read() method must return bytestrings. on_field: Callback to call with each parsed field. on_file: Callback to call with each parsed file. chunk_size: The maximum size to read from the input stream and write to the parser at one time. Defaults to 1 MiB. zContent-LengthNrAr) rrr#rKminr rVrrY) r input_streamrr chunk_sizercontent_length bytes_read max_readablebuffs r parse_formr"s* 7 ;F29=M1NN!^,uJ 3~ :JGH   .  Tc$i  t9 $ n(D   OOr")rrOr$z tuple[bytes, dict[bytes, bytes]]) rdict[str, bytes]rrrrrrFrnrr$r)r) rrrrrrrrrr#r$r^)K __future__rrrr rr email.messagerenumriorrnumbersrtypingr r decodersr r exceptionsrrrrrrrrrtyping_extensionsrrr*r6r:rDrNrRr`rjOnFieldCallbackOnFileCallbackr}r3rrrrrrrrrrrrdreLOWER_ALOWER_ZNULL frozensetrrrrr+r@rSrtrrrrr"rrsZ" !&&;^^BB+/x/#y##y# #Ye #9"Ye"%%( x( o}ho 45O|nd23N% L)& 8 w  W .        (V}c}c@kvkv\M0M0`A0 A0He e PAHjAHHststt " ) )$)#) )  )  )b / //%/# /  /  /r"