fume-manage-python.git

U  
£ý°dÄã@sdZdZddlZddlZddlmZddlmZddlmZddlm    Z    e    j
Zdd    Zd
dZ edeZe d eZedeZe deZddZddZddZddZddZddZdHddZeejeZeejeZeejeZeejeZeejeejZ eejeejZ!eej"dZ#eej$d Z%eej"d!Z&eej$d"Z'eZ(eZ)eejee*Z+dId#d$Z,dJd%d&Z-d'd(Z.d)d*Z/e 0d+ej1¡Z2d,d-Z3d.d/Z4d0d1Z5d2d3Z6d4d5Z7d6d7Z8d8d9Z9dKd:d;Z:d<d=Z;d>d?Z<d@dAZ=dBdCZ>dDdEZ?dFdGZ@e@ZAdS)LaÏ    Code for decoding protocol buffer primitives.
 
This code is very similar to encoder.py -- read the docs for that module first.
 
A "decoder" is a function with the signature:
  Decode(buffer, pos, end, message, field_dict)
The arguments are:
  buffer:     The string containing the encoded message.
  pos:        The current position in the string.
  end:        The position in the string where the current message ends.  May be
              less than len(buffer) if we're reading a sub-message.
  message:    The message object into which we're parsing.
  field_dict: message._fields (avoids a hashtable lookup).
The decoder reads the field and stores it into field_dict, returning the new
buffer position.  A decoder for a repeated field may proactively decode all of
the elements of that field, if they appear consecutively.
 
Note that decoders may throw any of the following:
  IndexError:  Indicates a truncated message.
  struct.error:  Unpacking of a fixed-width field failed.
  message.DecodeError:  Other errors.
 
Decoders are expected to raise an exception if they are called with pos > end.
This allows callers to be lax about bounds checking:  it's fineto read past
"end" as long as you are sure that someone else will notice and throw an
exception later on.
 
Something up the call stack is expected to catch IndexError and struct.error
and convert them to message.DecodeError.
 
Decoders are constructed using decoder constructors with the signature:
  MakeDecoder(field_number, is_repeated, is_packed, key, new_default)
The arguments are:
  field_number:  The field number of the field we want to decode.
  is_repeated:   Is the field a repeated field? (bool)
  is_packed:     Is the field a packed field? (bool)
  key:           The key to use when looking up the field within field_dict.
                 (This is actually the FieldDescriptor but nothing in this
                 file should depend on that.)
  new_default:   A function which takes a message object as a parameter and
                 returns a new instance of the default value for this field.
                 (This is called for repeated fields and sub-messages, when an
                 instance does not already exist.)
 
As with encoders, we define a decoder constructor for every type of field.
Then, for every field of every message class we construct an actual decoder.
That decoder goes into a dict indexed by tag, so when we decode a message
we repeatedly read a tag, look up the corresponding decoder, and invoke it.
z kenton@google.com (Kenton Varda)éN)Ú
containers)Úencoder)Úwire_format)Úmessagecsfdd}|S)a¢Return an encoder for a basic varint value (does not include tag).
 
  Decoded values will be bitwise-anded with the given mask before being
  returned, e.g. to limit them to 32 bits.  The returned decoder does not
  take the usual "end" parameter -- the caller is expected to do bounds checking
  after the fact (often the caller can defer such checking until later).  The
  decoder returns a (value, new_pos) pair.
  csfd}d}||}||d@|>O}|d7}|d@sH|M}|}||fS|d7}|dkrtdqdS©Nrééééé@z$Too many bytes when decoding varint.©Ú_DecodeError©ÚbufferÚposÚresultÚshiftÚb©ÚmaskÚresult_type©úWd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\google/protobuf/internal/decoder.pyÚDecodeVarintksz$_VarintDecoder.<locals>.DecodeVarintr)rrrrrrÚ_VarintDecoderas
rcs,d|d>d|>dfdd}|S)z0Like _VarintDecoder() but decodes signed values.rcsrd}d}||}||d@|>O}|d7}|d@sT|M}|A}|}||fS|d7}|dkrtdqdSrrr©rrZsignbitrrrsz*_SignedVarintDecoder.<locals>.DecodeVarintr)ÚbitsrrrrrÚ_SignedVarintDecoder|srlÿÿÿÿrlÿÿé cCs:|}||d@r|d7}q|d7}||| ¡}||fS)aRead a tag from the memoryview, and return a (tag_bytes, new_pos) tuple.
 
  We return the raw bytes of the tag rather than decoding them.  The raw
  bytes can then be used to look up the proper decoder.  This effectively allows
  us to trade some work that would be done in pure-python (decoding a varint)
  for work that is done in C (searching for a byte string in a hash table).
  In a low-level language it would be much cheaper to decode the varint and
  use that, but not in Python.
 
  Args:
    buffer: memoryview object of the encoded bytes
    pos: int of the current position to start from
 
  Returns:
    Tuple[bytes, int] of the tag data and new position.
  r    r)Útobytes)rrÚstartÚ    tag_bytesrrrÚReadTags
r"csdfdd    }|S)zØReturn a constructor for a decoder for fields of a particular type.
 
  Args:
      wire_type:  The field's wire type.
      decode_value:  A function which decodes an individual value, e.g.
        _DecodeVarint()
  Fc    sf|rtfdd}|S|rNt |¡tfdd}|Sfdd}|SdS)Ncs| ¡}|dkr"| |¡}||\}}||7}||krHtd||krj||\}}| |¡qH||kr|d=td|S)NúTruncated message.éÿÿÿÿúPacked element was truncated.©ÚgetÚ
setdefaultr Úappend)rrÚendrÚ
field_dictÚvalueÚendpointÚelement)Údecode_valueÚkeyÚlocal_DecodeVarintÚnew_defaultrrÚDecodePackedFieldÆs
zB_SimpleDecoder.<locals>.SpecificDecoder.<locals>.DecodePackedFieldcst| ¡}|dkr"| |¡}||\}}| |¡|}|||ksZ||kr"||krjtd|Sq"dS©Nr#)r'r(r)r ©rrr*rr+r,r.Únew_pos)r/r0r2r!Útag_lenrrÚDecodeRepeatedFieldÙs
 
zD_SimpleDecoder.<locals>.SpecificDecoder.<locals>.DecodeRepeatedFieldcs@||\}}||krtdr4|s4| d¡n||<|Sr4©r Úpop)rrr*rr+Ú    new_value)Úclear_if_defaultr/r0rrÚDecodeFieldêsz<_SimpleDecoder.<locals>.SpecificDecoder.<locals>.DecodeField)Ú _DecodeVarintrÚTagBytesÚlen©    Úfield_numberÚis_repeatedÚ    is_packedr0r2r<r3r8r=©r/Ú    wire_type©r<r0r1r2r!r7rÚSpecificDecoderÂs    z'_SimpleDecoder.<locals>.SpecificDecoder)Fr)rFr/rHrrErÚ_SimpleDecoder¹s
ÿ3rIcsfdd}t||S)zLike SimpleDecoder but additionally invokes modify_value on every value
  before storing it.  Usually modify_value is ZigZagDecode.
  cs||\}}||fS)Nr)rrrr6©r/Úmodify_valuerrÚInnerDecodesz%_ModifiedDecoder.<locals>.InnerDecode)rI)rFr/rKrLrrJrÚ_ModifiedDecoderøsrMcs*t ¡tjfdd}t||S)zReturn a constructor for a decoder for a fixed-width field.
 
  Args:
      wire_type:  The field's wire type.
      format:  The format string to pass to struct.unpack().
  cs&|}|||d}||fS)Nrr)rrr6r©ÚformatÚlocal_unpackZ
value_sizerrrLsz'_StructPackDecoder.<locals>.InnerDecode)ÚstructÚcalcsizeÚunpackrI)rFrOrLrrNrÚ_StructPackDecoders
    rTcstjfdd}ttj|S)zReturns a decoder for a float field.
 
  This code works around a bug in struct.unpack for non-finite 32-bit
  floating-point values.
  cs|d}||| ¡}|dddkrx|dddkrx|dddkrRtj|fS|dddkrntj|fStj|fSd    |d}||fS)
a#Decode serialized float to a float and new position.
 
    Args:
      buffer: memoryview of the serialized bytes
      pos: int, position in the memory view to start at.
 
    Returns:
      Tuple[float, int] of the deserialized float value and new position
      in the serialized data.
    ééóÿéórsóÿz<f)rÚmathÚnanÚinf)rrr6Zfloat_bytesr©rPrrrL(s  
 
z"_FloatDecoder.<locals>.InnerDecode)rQrSrIrÚWIRETYPE_FIXED32©rLrr^rÚ _FloatDecoders!racstjfdd}ttj|S)zkReturns a decoder for a double field.
 
  This code works around a bug in struct.unpack for not-a-number.
  csh|d}||| ¡}|dddkrR|dddkrR|dddkrRtj|fSd|d}||fS)    a"Decode serialized double to a double and new position.
 
    Args:
      buffer: memoryview of the serialized bytes.
      pos: int, position in the memory view to start at.
 
    Returns:
      Tuple[float, int] of the decoded double value and new position
      in the serialized data.
    ér
rWéóðrsðz<d)rr[r\)rrr6Zdouble_bytesrr^rrrLTs ÿþ
z#_DoubleDecoder.<locals>.InnerDecode)rQrSrIrÚWIRETYPE_FIXED64r`rr^rÚ_DoubleDecoderLsrfFc    stj|r&tfdd}|S|rZt tj¡tfdd}|Sfdd}|SdS)z!Returns a decoder for enum field.c
s| ¡}|dkr"| |¡}||\}}||7}||krHtd||krÖ|}t||\}}|jkrx| |¡qH|jsg|_t t    j
¡}    |j |    ||| ¡f¡|jdkrÂt  ¡|_|j t    j
|¡qH||kr|jkrò|d=n|jd=|jjd=td|S)a±Decode serialized packed enum to its value and a new position.
 
      Args:
        buffer: memoryview of the serialized bytes.
        pos: int, position in the memory view to start at.
        end: int, end position of serialized data
        message: Message object to store unknown fields in
        field_dict: Map[Descriptor, Any] to store decoded values in.
 
      Returns:
        int, new position in serialized data.
      Nr#r$r%)r'r(r Ú_DecodeSignedVarint32Úvalues_by_numberr)Ú_unknown_fieldsrr?rÚWIRETYPE_VARINTrÚ_unknown_field_setrÚUnknownFieldSetÚ_addZ_values)
rrr*rr+r,r-Úvalue_start_posr.r!)Ú    enum_typerBr0r1r2rrr3zsD 
 
ÿÿ
 
ÿ
 
 
z&EnumDecoder.<locals>.DecodePackedFieldcsÎ| ¡}|dkr"| |¡}t||\}}|jkrF| |¡nN|jsRg|_|j ||| ¡f¡|jdkrt     ¡|_|j 
tj|¡|}|||ks´||kr"||krÄt d|Sq"dS)á³Decode serialized repeated enum to its value and a new position.
 
      Args:
        buffer: memoryview of the serialized bytes.
        pos: int, position in the memory view to start at.
        end: int, end position of serialized data
        message: Message object to store unknown fields in
        field_dict: Map[Descriptor, Any] to store decoded values in.
 
      Returns:
        int, new position in serialized data.
      Nr#)r'r(rgrhr)rirrkrrlrmrrjr r5)rorBr0r2r!r7rrr8¯s. 
 
ÿ
 
ÿz(EnumDecoder.<locals>.DecodeRepeatedFieldcs®|}t||\}}||kr"tdr:|s:| d¡|S|jkrN||<n\|jsZg|_t tj¡}|j     |||| 
¡f¡|jdkrt  ¡|_|j tj|¡|S)rpr#N)rgr r:rhrirr?rrjr)rrkrrlrm)rrr*rr+rnZ
enum_valuer!)r<rorBr0rrr=Øs2 
 
ÿÿ
 
ÿz EnumDecoder.<locals>.DecodeFieldN)ror>rr?rrjr@rAr)r<rorBr0r1r2r!r7rÚEnumDecoderts1'$rqú<Iú<Qz<iz<qcsftfdd|rt|rLt |tj¡tfdd}|Sfdd}|SdS)z%Returns a decoder for a string field.c
sP| ¡}zt|d}Wn4tk
rJ}zd|jf|_W5d}~XYnX|S)zConvert byte to unicode.zutf-8z%s in field: %sN)rÚstrÚUnicodeDecodeErrorZ    full_nameÚreason)ZmemviewÚbyte_strr,Úe)r0rrÚ_ConvertToUnicode%sz(StringDecoder.<locals>._ConvertToUnicodecs| ¡}|dkr"| |¡}||\}}||}||krHtd| |||¡|}|||ks~||kr"|Sq"dS©NzTruncated string.r&©rrr*rr+r,Úsizer6)ryr0r1r2r!r7rrr86s
z*StringDecoder.<locals>.DecodeRepeatedFieldcsT||\}}||}||kr&tdr<|s<| d¡n||||<|Srzr9©rrr*rr+r|r6)ryr<r0r1rrr=Gsz"StringDecoder.<locals>.DecodeFieldN©r>ÚAssertionErrorrr?rÚWIRETYPE_LENGTH_DELIMITEDr@©rBrCrDr0r2r<r8r=r)ryr<r0r1r2r!r7rÚ StringDecodersÿ
rcsVt|rt|r>t |tj¡tfdd}|Sfdd}|SdS)z$Returns a decoder for a bytes field.cs| ¡}|dkr"| |¡}||\}}||}||krHtd| ||| ¡¡|}|||ks~||kr"|Sq"dSrz)r'r(r r)rr{©r0r1r2r!r7rrr8_s
z)BytesDecoder.<locals>.DecodeRepeatedFieldcsT||\}}||}||kr&tdr<|s<| d¡n||| ¡|<|Srz)r r:rr})r<r0r1rrr=psz!BytesDecoder.<locals>.DecodeFieldNr~rrrGrÚBytesDecoderTsÿ
rcslt |tj¡t|rt|rRt |tj¡tfdd}|Sfdd}|SdS)z$Returns a decoder for a group field.cs¨| ¡}|dkr"| |¡}| ¡}|dkrD| |¡}| ¡ |||¡}|}|||ksv||kr~td|}|||ks||kr"|Sq"dS©NúMissing group end tag.)r'r(ÚaddÚ_InternalParser ©rrr*rr+r,r6©Ú end_tag_bytesÚend_tag_lenr0r2r!r7rrr8s
 
z)GroupDecoder.<locals>.DecodeRepeatedFieldcs\| ¡}|dkr"| |¡}| |||¡}|}|||ksP||krXtd|Sr)r'r(rr r)rrr0r2rrr=s
z!GroupDecoder.<locals>.DecodeFieldN)rr?rÚWIRETYPE_END_GROUPr@rÚWIRETYPE_START_GROUP©rBrCrDr0r2r8r=rrrÚGroupDecoder}sÿÿrcsVt|rt|r>t |tj¡tfdd}|Sfdd}|SdS)z&Returns a decoder for a message field.cs| ¡}|dkr"| |¡}||\}}||}||krHtd| ¡ |||¡|krftd|}|||ks||kr"|Sq"dS©Nr#úUnexpected end-group tag.)r'r(r rrr{rrrr8¶s
z+MessageDecoder.<locals>.DecodeRepeatedFieldcsf| ¡}|dkr"| |¡}||\}}||}||krHtd| |||¡|krbtd|Sr)r'r(r rr{)r0r1r2rrr=Ìs
z#MessageDecoder.<locals>.DecodeFieldNr~rrrrÚMessageDecoder¬sÿrrcsNt dtj¡t dtj¡t dtj¡ttt}fdd}|S)aReturns a decoder for a MessageSet item.
 
  The parameter is the message Descriptor.
 
  The message set message looks like this:
    message MessageSet {
      repeated group Item = 1 {
        required int32 type_id = 2;
        required string message = 3;
      }
    }
  rXrVrcs|}d}d}d}||\}    }|    kr6||\}}q|    krZ||\}
}||
}}q|    krfqqt||||    }|dkrtdq||krtd|dkr¦td|dkr¶td|j |¡}|dk    r*| |¡}|dkr|j} t| dsü|j | ¡|     ||  
¡¡}| |||¡|krtdn^|js8g|_|j  t||| ¡f¡|jdkrjt ¡|_|j |tj||| ¡¡|S)    aDecode serialized message set to its value and new position.
 
    Args:
      buffer: memoryview of the serialized bytes.
      pos: int, position in the memory view to start at.
      end: int, end position of serialized data
      message: Message object to store unknown fields in
      field_dict: Map[Descriptor, Any] to store decoded values in.
 
    Returns:
      int, new position in serialized data.
    r$rr#z MessageSet item missing type_id.z MessageSet item missing message.NÚ_concrete_classr)Ú    SkipFieldr Z
ExtensionsZ_FindExtensionByNumberr'Úmessage_typeÚhasattrZ_FACTORYZGetPrototyper(rrrir)ÚMESSAGE_SET_ITEM_TAGrrkrrlrmrr)rrr*rr+Zmessage_set_item_startZtype_idÚ message_startZmessage_endr!r|Ú    extensionr,r©Zitem_end_tag_bytesr1Z local_ReadTagZmessage_tag_bytesZtype_id_tag_bytesrrÚ
DecodeItemøs^ 
 
 
 
 
ÿ
ÿ
ýz)MessageSetItemDecoder.<locals>.DecodeItem)    rr?rrjrrr"r>r)Z
descriptorZlocal_SkipFieldrrrrÚMessageSetItemDecoderâsHrcsB|t |jtj¡tt|jfdd}|S)z"Returns a decoder for a map field.c    sÀ ¡}| ¡}|dkr*| |¡}||\}}||}||krPtd| ¡| |||¡|krrtdr||j |j¡n|j||j<|}|||ks¶||kr*|Sq*dSr)    rr'r(r ZClearrr0ZCopyFromr,)    rrr*rr+Zsubmsgr,r|r6©Úis_message_mapr0r1rr2r!r7rrÚ    DecodeMapOs"
zMapDecoder.<locals>.DecodeMap)rr?Únumberrrr@r>r)Zfield_descriptorr2rr rrrÚ
MapDecoderDsÿr¢cCsBt|||d ¡d@r&|d7}q|d7}||kr>td|S)z/Skip a varint value.  Returns the new position.rr    r#)Úordrr ©rrr*rrrÚ_SkipVarintrs
r¥cCs|d7}||krtd|S)z0Skip a fixed64 value.  Returns the new position.rbr#rr¤rrrÚ_SkipFixed64~sr¦cCs$|d}t d|||¡d|fS)zDecode a fixed64.rbrsr©rQrS©rrr6rrrÚ_DecodeFixed64sr©cCs*t||\}}||7}||kr&td|S)z9Skip a length-delimited value.  Returns the new position.r#)r>r )rrr*r|rrrÚ_SkipLengthDelimiteds
rªcCs2t||\}}t||||}|dkr(|S|}qdS)z*Skip sub-group.  Returns the new position.r$N)r"r)rrr*r!r6rrrÚ
_SkipGroups
r«c
Csvt ¡}|dks||krnt||\}}t|d\}}t |¡\}}|tjkrNqnt|||\}    }| |||    ¡q||fS)zFDecode UnknownFieldSet.  Returns the UnknownFieldSet and new position.Nr)    rrlr"r>rZ    UnpackTagrÚ_DecodeUnknownFieldrm)
rrZend_posZunknown_field_setr!ÚtagÚ_rBrFÚdatarrrÚ_DecodeUnknownFieldSet¢s
r°cCs¼|tjkrt||\}}n|tjkr4t||\}}n|tjkrNt||\}}nf|tjkrt||\}}|||| ¡}||7}n0|tj    krt
||\}}n|tjkr¬dStd||fS)zCDecode a unknown field.  Returns the UnknownField and new position.)rr$zWrong wire type in tag.) rrjr>rer©r_Ú_DecodeFixed32rrrr°rr )rrrFr¯r|rrrr¬³s 
 
 
 
 
 
 
r¬cCsdS)zFSkipping an END_GROUP tag returns -1 to tell the parent loop to break.r$rr¤rrrÚ    _EndGroupÊsr²cCs|d7}||krtd|S)z0Skip a fixed32 value.  Returns the new position.rUr#rr¤rrrÚ_SkipFixed32Ðsr³cCs$|d}t d|||¡d|fS)zDecode a fixed32.rUrrrr§r¨rrrr±Ùsr±cCstddS)z;Skip function for unknown wire types.  Raises an exception.zTag had invalid wire type.Nrr¤rrrÚ_RaiseInvalidWireTypeàsr´cs,ttttttttgtjfdd}|S)z"Constructs the SkipField function.cs$t|dd@}||||S)aSkips a field with the specified tag.
 
    |pos| should point to the byte immediately after the tag.
 
    Returns:
        The new position (after the tag value), or -1 if the tag is an end-group
        tag (in which case the calling loop should break).
    rr)r£)rrr*r!rF©ZWIRETYPE_TO_SKIPPERZ wiretype_maskrrrõsz _FieldSkipper.<locals>.SkipField)    r¥r¦rªr«r²r³r´rZ TAG_TYPE_MASK)rrrµrÚ _FieldSkipperåsør¶)F)F)F)N)BÚ__doc__Ú
__author__r[rQZgoogle.protobuf.internalrrrZgoogle.protobufrÚDecodeErrorr rrÚintr>Z_DecodeSignedVarintZ_DecodeVarint32rgr"rIrMrTrarfrqrjZInt32DecoderZInt64DecoderZ UInt32DecoderZ UInt64DecoderZZigZagDecodeZ SInt32DecoderZ SInt64Decoderr_ZFixed32DecoderreZFixed64DecoderZSFixed32DecoderZSFixed64DecoderZFloatDecoderZ DoubleDecoderÚboolZBoolDecoderrrrrr?rrrr¢r¥r¦r©rªr«r°r¬r²r³r±r´r¶rrrrrÚ<module>s2
 
 
 
?-)ÿ
ÿÿÿÿÿÿ
6ÿ
)/4b.