
    fTh8                        S r SSKrSSKrSSKJrJrJrJr  SSKr	SSK
Jr  SSKJrJrJrJrJr  SSKJrJrJrJrJr  SSKJr  \" 5       (       a  SSKr\R6                  " \5      rS	S
0rS rS r \" SS9 " S S\5      5       r!S/r"g)z!Tokenization class for Pop2Piano.    N)ListOptionalTupleUnion   )BatchFeature)
AddedTokenBatchEncodingPaddingStrategyPreTrainedTokenizerTruncationStrategy)
TensorTypeis_pretty_midi_availableloggingrequires_backendsto_numpy)requiresvocabz
vocab.jsonc                 *    X -  nUb  [        X!5      nU$ N)minnumbercutoff_time_idxcurrent_idxs      l/var/www/auris/envauris/lib/python3.13/site-packages/transformers/models/pop2piano/tokenization_pop2piano.pytoken_time_to_noter   (   s     K"+7    c                 t    X0   b.  X0   nXd:  a#  UnUR                  XgX/5        US:X  a  S OUnXU '   U$ XCU '   U$ )Nr   )append)	r   current_velocitydefault_velocitynote_onsets_readyr   notes	onset_idx
offset_idxonsets_readys	            r   token_note_to_noter(   0   s[     ,%-	"$JLL)JK#3q#84kL(4f% L %0&!Lr   )pretty_miditorch)backendsc                   V  ^  \ rS rSrSrSS/r\r      S*U 4S jjr\	S 5       r
S rS\S	\4S
 jrS+S	\4S jjrS\R"                  S\S\S\4S jr   S,S\R"                  S\R"                  S\S\S\4
S jjr S-S\R"                  S\S\\   4S jjrS.S\R"                  S\R"                  S\4S jjrS-S\S\\   S	\\   4S jjr  S/S\\R"                  \\R<                     4   S\\   S\\   S	\ 4S jjr!  S/S\\R"                  \\R<                     4   S\\   S\\   S	\ 4S jjr"       S0S\\R"                  \\R<                     \\\R<                        4   S\\#\\$4   S \\#\\4   S\\   S!\\   S"\\#   S#\\\\%4      S$\#S	\ 4S% jjr& S1S&\'S'\#4S( jjr(S)r)U =r*$ )2Pop2PianoTokenizer?   aF  
Constructs a Pop2Piano tokenizer. This tokenizer does not require training.

This tokenizer inherits from [`PreTrainedTokenizer`] which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.

Args:
    vocab (`str`):
        Path to the vocab file which contains the vocabulary.
    default_velocity (`int`, *optional*, defaults to 77):
        Determines the default velocity to be used while creating midi Notes.
    num_bars (`int`, *optional*, defaults to 2):
        Determines cutoff_time_idx in for each token.
    unk_token (`str` or `tokenizers.AddedToken`, *optional*, defaults to `"-1"`):
        The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
        token instead.
    eos_token (`str` or `tokenizers.AddedToken`, *optional*, defaults to 1):
        The end of sequence token.
    pad_token (`str` or `tokenizers.AddedToken`, *optional*, defaults to 0):
         A special token used to make arrays of tokens the same size for batching purpose. Will then be ignored by
        attention mechanisms or loss computation.
    bos_token (`str` or `tokenizers.AddedToken`, *optional*, defaults to 2):
        The beginning of sequence token that was used during pretraining. Can be used a sequence classifier token.
	token_idsattention_maskc                 N  > [        U[        5      (       a  [        USSS9OUn[        U[        5      (       a  [        USSS9OUn[        U[        5      (       a  [        USSS9OUn[        U[        5      (       a  [        USSS9OUnX l        X0l        [        US5       n	[        R                  " U	5      U l        S S S 5        U R                  R                  5        V
Vs0 s H  u  pX_M	     snn
U l
        [        TU ]0  " SUUUUS.UD6  g ! , (       d  f       NX= fs  snn
f )NF)lstriprstriprb)	unk_token	eos_token	pad_token	bos_token )
isinstancestrr	   r"   num_barsopenjsonloadencoderitemsdecodersuper__init__)selfr   r"   r<   r5   r6   r7   r8   kwargsfilekv	__class__s               r   rD   Pop2PianoTokenizer.__init__]   s    JTT]_bIcIcJyuEir	IST]_bIcIcJyuEir	IST]_bIcIcJyuEir	IST]_bIcIcJyuEir	 0  %$99T?DL  *.););)=>)=)=> 	
		

 	
  ?s   "D#D!
Dc                 ,    [        U R                  5      $ )z-Returns the vocabulary size of the tokenizer.)lenr@   rE   s    r   
vocab_sizePop2PianoTokenizer.vocab_size   s     4<<  r   c                 B    [        U R                  40 U R                  D6$ )z(Returns the vocabulary of the tokenizer.)dictr@   added_tokens_encoderrN   s    r   	get_vocabPop2PianoTokenizer.get_vocab   s    DLL>D$=$=>>r   token_idreturnc                     U R                   R                  XR                   S35      nUR                  S5      nSR	                  USS 5      [        US   5      pCX4/$ )a  
Decodes the token ids generated by the transformer into notes.

Args:
    token_id (`int`):
        This denotes the ids generated by the transformers to be converted to Midi tokens.

Returns:
    `List`: A list consists of token_type (`str`) and value (`int`).
_TOKEN_TIME_   Nr   )rB   getr5   splitjoinint)rE   rV   token_type_value
token_typevalues        r   _convert_id_to_token'Pop2PianoTokenizer._convert_id_to_token   sc      <<++H8H6TU+11#6HH%5ab%9:C@PQR@S<TE""r   c                 j    U R                   R                  U SU 3[        U R                  5      5      $ )ai  
Encodes the Midi tokens to transformer generated token ids.

Args:
    token (`int`):
        This denotes the token value.
    token_type (`str`):
        This denotes the type of the token. There are four types of midi tokens such as "TOKEN_TIME",
        "TOKEN_VELOCITY", "TOKEN_NOTE" and "TOKEN_SPECIAL".

Returns:
    `int`: returns the id of the token.
rZ   )r@   r\   r_   r5   )rE   tokenra   s      r   _convert_token_to_id'Pop2PianoTokenizer._convert_token_to_id   s/     ||5':, 7T^^9LMMr   tokensbeat_offset_idxbars_per_batchr   c                     Sn[        [        U5      5       HT  nX   nX&U-  S-  -   nXH-   n	U R                  UUU	S9n
[        U
5      S:X  a  M7  Uc  U
nM>  [        R                  " XZ4SS9nMV     Uc  / $ U$ )a  
Converts relative tokens to notes which are then used to generate pretty midi object.

Args:
    tokens (`numpy.ndarray`):
        Tokens to be converted to notes.
    beat_offset_idx (`int`):
        Denotes beat offset index for each note in generated Midi.
    bars_per_batch (`int`):
        A parameter to control the Midi output generation.
    cutoff_time_idx (`int`):
        Denotes the cutoff time index for each note in generated Midi.
N   )	start_idxr   r   )axis)rangerM   relative_tokens_ids_to_notesnpconcatenate)rE   ri   rj   rk   r   r$   index_tokens
_start_idx_cutoff_time_idx_notess              r   "relative_batch_tokens_ids_to_notes5Pop2PianoTokenizer.relative_batch_tokens_ids_to_notes   s    * 3v;'EmG(>+AA+EEJ.;66$ 0 7 F 6{aQ? (" =Ir   beatstepc                 \    Uc  SOUnU R                  UUUUS9nU R                  XbX#   S9nU$ )a  
Converts tokens to Midi. This method calls `relative_batch_tokens_ids_to_notes` method to convert batch tokens
to notes then uses `notes_to_midi` method to convert them to Midi.

Args:
    tokens (`numpy.ndarray`):
        Denotes tokens which alongside beatstep will be converted to Midi.
    beatstep (`np.ndarray`):
        We get beatstep from feature extractor which is also used to get Midi.
    beat_offset_idx (`int`, *optional*, defaults to 0):
        Denotes beat offset index for each note in generated Midi.
    bars_per_batch (`int`, *optional*, defaults to 2):
        A parameter to control the Midi output generation.
    cutoff_time_idx (`int`, *optional*, defaults to 12):
        Denotes the cutoff time index for each note in generated Midi.
r   )ri   rj   rk   r   )
offset_sec)ry   notes_to_midi)rE   ri   r{   rj   rk   r   r$   midis           r   !relative_batch_tokens_ids_to_midi4Pop2PianoTokenizer.relative_batch_tokens_ids_to_midi   sP    0  /6!O77+)+	 8 
 !!%h>W!Xr   rn   c           
      @   U Vs/ s H  o@R                  U5      PM     nnUnSn[        [        U R                  R	                  5        Vs/ s H  oR                  S5      PM     sn5      S-   5       V	s/ s H  n	SPM     n
n	/ nU HZ  u  pUS:X  a
  US:X  a    OKM  US:X  a  [        XUS9nM'  US:X  a  UnM1  US	:X  a  [        UUU R                  U
UUS
9nMQ  [        S5      e   [        U
5       HK  u  pUc  M
  Uc  US-   nO[        X?S-   5      n[        UU5      nUR                  UUXR                  /5        MM     [        U5      S:X  a  / $ [        R                  " U5      nUSS2S4   S-  USS2S4   -   nUUR!                  5          nU$ s  snf s  snf s  sn	f )an  
Converts relative tokens to notes which will then be used to create Pretty Midi objects.

Args:
    tokens (`numpy.ndarray`):
        Relative Tokens which will be converted to notes.
    start_idx (`float`):
        A parameter which denotes the starting index.
    cutoff_time_idx (`float`, *optional*):
        A parameter used while converting tokens to notes.
r   NOTEr[   NTOKEN_SPECIAL
TOKEN_TIMEr   TOKEN_VELOCITY
TOKEN_NOTE)r   r!   r"   r#   r   r$   zToken type not understood!   )rc   rp   sumr@   keysendswithr   r(   r"   
ValueError	enumeratemaxr    rM   rr   arrayargsort)rE   ri   rn   r   rf   wordsr   r!   rH   ir#   r$   ra   r   pitch
note_onsetcutoffr&   
note_orders                      r   rq   /Pop2PianoTokenizer.relative_tokens_ids_to_notes   s    @FFve**51vF+0RVR^R^RcRcRe5fReQjj6HRe5f1gjk1k+lm+laT+lm"'J_,Q; |+0!P[ //#) |+*!%5%)%:%:&7 + !!=>>+ #(. "++<!=E%"*'!^F q.AF f5
j*e=R=RST "> u:?IHHUOEq!ts*U1a4[8J*,,./EL] G 6gms   FF5Fr$   r}   c                 T   [        U S/5        [        R                  " SSS9n[        R                  " SS9n/ nU H8  u  pxp[        R                  " U
U	X'   U-
  X(   U-
  S9nUR                  U5        M:     Xel        UR                  R                  U5        UR                  5         U$ )as  
Converts notes to Midi.

Args:
    notes (`numpy.ndarray`):
        This is used to create Pretty Midi objects.
    beatstep (`numpy.ndarray`):
        This is the extrapolated beatstep that we get from feature extractor.
    offset_sec (`int`, *optional*, defaults to 0.0):
        This represents the offset seconds which is used while creating each Pretty Midi Note.
r)   i  g      ^@)
resolutioninitial_tempor   )program)velocityr   startend)	r   r)   
PrettyMIDI
InstrumentNoter    r$   instrumentsremove_invalid_notes)rE   r$   r{   r}   new_pmnew_inst	new_notesr%   r&   r   r   new_notes               r   r~    Pop2PianoTokenizer.notes_to_midi8  s     	$0''3eL))!4	6;2I5"''!)J6(:5	H X& 7< #!!(+##%r   save_directoryfilename_prefixc                    [         R                  R                  U5      (       d  [        R	                  SU S35        g[         R                  R                  X(       a  US-   OS[        S   -   5      n[        US5       nUR                  [        R                  " U R                  5      5        SSS5        U4$ ! , (       d  f       U4$ = f)aE  
Saves the tokenizer's vocabulary dictionary to the provided save_directory.

Args:
    save_directory (`str`):
        A path to the directory where to saved. It will be created if it doesn't exist.
    filename_prefix (`Optional[str]`, *optional*):
        A prefix to add to the names of the files saved by the tokenizer.
zVocabulary path (z) should be a directoryN- r   w)ospathisdirloggererrorr^   VOCAB_FILES_NAMESr=   writer>   dumpsr@   )rE   r   r   out_vocab_filerG   s        r   save_vocabulary"Pop2PianoTokenizer.save_vocabularyX  s     ww}}^,,LL,^,<<STU o_s22QbcjQkk
 .#&$JJtzz$,,/0 '    '&   s    0B;;
Ctruncation_strategy
max_lengthc           	      z   [        U S/5        [        US   [        R                  5      (       ab  [        R
                  " U Vs/ s H0  oUR                  UR                  UR                  UR                  /PM2     sn5      R                  SS5      n[        R                  " U5      R                  [        R                  5      nUSS2SS24   R                  5       n[        US-   5       Vs/ s H  n/ PM     nnU H/  u  ppX   R!                  X/5        X   R!                  US/5        M1     / nSn[#        U5       H  u  p[%        U5      S:X  a  M  UR!                  U R'                  US5      5        U H\  u  p[)        US:  5      nX:w  a#  UnUR!                  U R'                  US	5      5        UR!                  U R'                  US
5      5        M^     M     [%        U5      nU[*        R,                  :w  a*  U(       a#  UU:  a  U R.                  " SUUU-
  US.UD6u  n  n[1        SU05      $ s  snf s  snf )a  
This is the `encode_plus` method for `Pop2PianoTokenizer`. It converts the midi notes to the transformer
generated token ids. It only works on a single batch, to process multiple batches please use
`batch_encode_plus` or `__call__` method.

Args:
    notes (`numpy.ndarray` of shape `[sequence_length, 4]` or `list` of `pretty_midi.Note` objects):
        This represents the midi notes. If `notes` is a `numpy.ndarray`:
            - Each sequence must have 4 values, they are `onset idx`, `offset idx`, `pitch` and `velocity`.
        If `notes` is a `list` containing `pretty_midi.Note` objects:
            - Each sequence must have 4 attributes, they are `start`, `end`, `pitch` and `velocity`.
    truncation_strategy ([`~tokenization_utils_base.TruncationStrategy`], *optional*):
        Indicates the truncation strategy that is going to be used during truncation.
    max_length (`int`, *optional*):
        Maximum length of the returned list and optionally padding length (see above).

Returns:
    `BatchEncoding` containing the tokens ids.
r)   r   rm   N   r[   r   r   r   )idsnum_tokens_to_remover   r/   r9   )r   r:   r)   r   rr   r   r   r   r   r   reshaperoundastypeint32r   rp   r    r   rM   rg   r_   r   DO_NOT_TRUNCATEtruncate_sequencesr
   )rE   r$   r   r   rF   	each_notemax_time_idxr   timesonsetoffsetr   r   ri   r!   time	total_lenrZ   s                     r   encode_plusPop2PianoTokenizer.encode_pluso  s   6 	$0 eAh 0 011HHhmnhm[d//9==)//9CUCUVhmngb!n 
 &&rxx0QU|'')"L1$467667.3*E5L 12M  %, /4  'GA4yA~MM$33A|DE#'x!|,#/'/$MM$";";HFV"WXd77|LM $(	 ( K	 "4"D"DDXadnXn22 %.%;$7 	LFAq k6233I o 8s   7H3.H8c           	          / n[        [        U5      5       H-  nUR                  U R                  " X   4UUS.UD6S   5        M/     [	        SU05      $ )a  
This is the `batch_encode_plus` method for `Pop2PianoTokenizer`. It converts the midi notes to the transformer
generated token ids. It works on multiple batches by calling `encode_plus` multiple times in a loop.

Args:
    notes (`numpy.ndarray` of shape `[batch_size, sequence_length, 4]` or `list` of `pretty_midi.Note` objects):
        This represents the midi notes. If `notes` is a `numpy.ndarray`:
            - Each sequence must have 4 values, they are `onset idx`, `offset idx`, `pitch` and `velocity`.
        If `notes` is a `list` containing `pretty_midi.Note` objects:
            - Each sequence must have 4 attributes, they are `start`, `end`, `pitch` and `velocity`.
    truncation_strategy ([`~tokenization_utils_base.TruncationStrategy`], *optional*):
        Indicates the truncation strategy that is going to be used during truncation.
    max_length (`int`, *optional*):
        Maximum length of the returned list and optionally padding length (see above).

Returns:
    `BatchEncoding` containing the tokens ids.
)r   r   r/   )rp   rM   r    r   r
   )rE   r$   r   r   rF   encoded_batch_token_idsr   s          r   batch_encode_plus$Pop2PianoTokenizer.batch_encode_plus  sp    4 #%s5z"A#**  H(;) 	
  # k+BCDDr   padding
truncationpad_to_multiple_ofreturn_attention_maskreturn_tensorsverbosec	           
      ^   [        U[        R                  5      (       a  UR                  S:H  O[        US   [        5      n
U R
                  " SUUUUUS.U	D6u  ppIU
(       a  Uc  SOUnU R                  " SUUUS.U	D6nOU R                  " SUUUS.U	D6nU R                  UUUUUUUS9nU$ )a  
This is the `__call__` method for `Pop2PianoTokenizer`. It converts the midi notes to the transformer generated
token ids.

Args:
    notes (`numpy.ndarray` of shape `[batch_size, max_sequence_length, 4]` or `list` of `pretty_midi.Note` objects):
        This represents the midi notes.

        If `notes` is a `numpy.ndarray`:
            - Each sequence must have 4 values, they are `onset idx`, `offset idx`, `pitch` and `velocity`.
        If `notes` is a `list` containing `pretty_midi.Note` objects:
            - Each sequence must have 4 attributes, they are `start`, `end`, `pitch` and `velocity`.
    padding (`bool`, `str` or [`~file_utils.PaddingStrategy`], *optional*, defaults to `False`):
        Activates and controls padding. Accepts the following values:

        - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
          sequence if provided).
        - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
          acceptable input length for the model if that argument is not provided.
        - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
          lengths).
    truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):
        Activates and controls truncation. Accepts the following values:

        - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or
          to the maximum acceptable input length for the model if that argument is not provided. This will
          truncate token by token, removing a token from the longest sequence in the pair if a pair of
          sequences (or a batch of pairs) is provided.
        - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the
          maximum acceptable input length for the model if that argument is not provided. This will only
          truncate the first sequence of a pair if a pair of sequences (or a batch of pairs) is provided.
        - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the
          maximum acceptable input length for the model if that argument is not provided. This will only
          truncate the second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.
        - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths
          greater than the model maximum admissible input size).
    max_length (`int`, *optional*):
        Controls the maximum length to use by one of the truncation/padding parameters. If left unset or set to
        `None`, this will use the predefined model maximum length if a maximum length is required by one of the
        truncation/padding parameters. If the model has no specific maximum input length (like XLNet)
        truncation/padding to a maximum length will be deactivated.
    pad_to_multiple_of (`int`, *optional*):
        If set will pad the sequence to a multiple of the provided value. This is especially useful to enable
        the use of Tensor Cores on NVIDIA hardware with compute capability `>= 7.5` (Volta).
    return_attention_mask (`bool`, *optional*):
        Whether to return the attention mask. If left to the default, will return the attention mask according
        to the specific tokenizer's default, defined by the `return_outputs` attribute.

        [What are attention masks?](../glossary#attention-mask)
    return_tensors (`str` or [`~file_utils.TensorType`], *optional*):
        If set, will return tensors instead of list of python integers. Acceptable values are:

        - `'tf'`: Return TensorFlow `tf.constant` objects.
        - `'pt'`: Return PyTorch `torch.Tensor` objects.
        - `'np'`: Return Numpy `np.ndarray` objects.
    verbose (`bool`, *optional*, defaults to `True`):
        Whether or not to print more information and warnings.

Returns:
    `BatchEncoding` containing the token_ids.
r   r   )r   r   r   r   r   T)r$   r   r   )r   r   r   r   r   r   r9   )	r:   rr   ndarrayndimlist"_get_padding_truncation_strategiesr   r   pad)rE   r$   r   r   r   r   r   r   r   rF   
is_batchedpadding_strategyr   r/   s                 r   __call__Pop2PianoTokenizer.__call__  s   d )35"**(E(EUZZ1_:V[\]V^`dKe
 EIDkDk E
!!1E
 E
Az ,A,IDOd!.. $7% 	I (( $7% 	I HH$!1"7)  
	 r   feature_extractor_outputreturn_midic                    [        [        US5      =(       a    [        US5      =(       a    [        US5      5      nU(       d!  US   R                  S   S:  a  [        S5      eU(       a  [	        US   SS2S4   S:H  5      US   R                  S   :w  d&  US   R                  S   US	   R                  S   :w  aA  [        S
UR                  S    SUS   R                  S    SUS	   R                  S    35      eUS   R                  S   UR                  S   :w  a.  [        SUS   R                  S    SUR                  S    35      eO^US   R                  S   S:w  d  US	   R                  S   S:w  a2  [        SUS   R                  S    SUS	   R                  S    S35      eU(       a'  [
        R                  " US   SS2S4   S:H  5      S   nOUR                  S   /n/ n/ nSn[        U5       GH  u  pXU
 nUSS2S[
        R                  " [
        R                  " U[        U R                  5      :H  5      S   5      S-   24   nUS   U	   nUS	   U	   nU(       a|  US   U	   nUS   U	   nUS[
        R                  " [
        R                  " US:H  5      S   5      S-    nUS[
        R                  " [
        R                  " US:H  5      S   5      S-    n[        U5      n[        U5      n[        U5      nU R                  UUU R                  U R                  S-   S-  S9nUR                  S   R                   HD  nU=R                   US   -  sl        U=R"                  US   -  sl        UR%                  U5        MF     UR%                  U5        XS-   -  nGM     U(       a  ['        XgS.5      $ ['        SU05      $ )a  
This is the `batch_decode` method for `Pop2PianoTokenizer`. It converts the token_ids generated by the
transformer to midi_notes and returns them.

Args:
    token_ids (`Union[np.ndarray, torch.Tensor, tf.Tensor]`):
        Output token_ids of `Pop2PianoConditionalGeneration` model.
    feature_extractor_output (`BatchFeature`):
        Denotes the output of `Pop2PianoFeatureExtractor.__call__`. It must contain `"beatstep"` and
        `"extrapolated_beatstep"`. Also `"attention_mask_beatsteps"` and
        `"attention_mask_extrapolated_beatstep"`
         should be present if they were returned by the feature extractor.
    return_midi (`bool`, *optional*, defaults to `True`):
        Whether to return midi object or not.
Returns:
    If `return_midi` is True:
        - `BatchEncoding` containing both `notes` and `pretty_midi.pretty_midi.PrettyMIDI` objects.
    If `return_midi` is False:
        - `BatchEncoding` containing `notes`.
r0   attention_mask_beatsteps$attention_mask_extrapolated_beatstep	beatstepsr   r[   zattention_mask, attention_mask_beatsteps and attention_mask_extrapolated_beatstep must be present for batched inputs! But one of them were not present.Nextrapolated_beatstepzbLength mistamtch between token_ids, beatsteps and extrapolated_beatstep! Found token_ids length - z, beatsteps shape - z$ and extrapolated_beatsteps shape - z!Found attention_mask of length - z but token_ids of length - zLength mistamtch of beatsteps and extrapolated_beatstep! Since attention_mask is not present the number of examples must be 1, But found beatsteps length - z", extrapolated_beatsteps length - .rm   )ri   r{   rk   r   )r$   pretty_midi_objectsr$   )boolhasattrshaper   r   rr   wherer   r   r_   r6   r   r   r<   r   r$   r   r   r    r
   )rE   r/   r   r   attention_masks_present	batch_idx
notes_listpretty_midi_objects_listrn   rt   end_idxeach_tokens_idsr   r   r   r   pretty_midi_objectnotes                     r   batch_decodePop2PianoTokenizer.batch_decodeY  s   8 #',.>? Z02LMZ02XY#
 '+CK+P+V+VWX+Y\]+]H  # ,-=>q!tDIJ+K8>>qAB+K8>>qA+,CDJJ1MN !**3//!*<)==QRjkvRwR}R}~  SA  RB B::RSj:k:q:qrs:t9uw 
 ((89??BiooVWFXX 78PQa8b8h8hij8k7l  mH  IR  IX  IX  YZ  I[  H\  ]  Y )5;;A>!C+,CDJJ1MQRR 44L[4Y4_4_`a4b3c  dF  G_  `w  Gx  G~  G~  @  GA  FB  BCD 
 #!9:J!KAqD!QUV!VWXYZI"+,I
#% 	'	2NE'':O-a1r266"((?VYZ^ZhZhViCi:jkl:m3nqr3r1r.rsO0=eDI$<=T$UV[$\! '+CD^+_`e+f(7O:884 &&^rxx8PTU8U/VWX/Y(Z]^(^_	(=XbffRXX&Ja&OPQRSTWXX)% '7O +I$,-B$C!!%!G!G&.#}}!%!2a 7	 "H " +66q9??

il*
IaL(!!$' @
 %++,>?1$IG 3J  :!ghhgz233r   )rB   r"   r@   r<   )M   r   z-1102)r   )r   r      r   )g        )NN)FNNNNNT)T)+__name__
__module____qualname____firstlineno____doc__model_input_namesr   vocab_files_namesrD   propertyrO   rT   r_   r   rc   rg   rr   r   ry   r   floatr   rq   r~   r;   r   r   r   r   r)   r   r   r
   r   r   r   r   r   r   r   r   __static_attributes____classcell__)rJ   s   @r   r-   r-   ?   s$   2 %&67)
  
D ! !?#S #T #$Nc N *

* * 	*
 *`  !! 

  **  	 
    J X\<jj<-2<EMe_<|2::  QT @!c !HSM !]bcf]g !4 =A$(	E4RZZk&6&6!778E4 &&89E4 SM	E4 
E4T =A$(	%ERZZk&6&6!778%E &&89%E SM	%E 
%E\ 6;;?$(,004;?zJJ!!"k&&'(*
z tS/12z $%778z SMz %SMz  (~z !sJ!78z z 
z@ !	w4 #/w4 	w4 w4r   r-   )#r  r>   r   typingr   r   r   r   numpyrr   feature_extraction_utilsr   tokenization_utilsr	   r
   r   r   r   utilsr   r   r   r   r   utils.import_utilsr   r)   
get_loggerr   r   r   r   r(   r-   __all__r9   r   r   <module>r     s    (  	 / /  4 u u _ _ * 			H	% \ 
 
+,P
4, P
4 -P
4f  
 r   