
    eThv                        S r SSKrSSKrSSKrSSKrSSKJ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JrJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#  \(       a  \" 5       (       a  SSK$r$\"RJ                  " \&5      r'\S   r( " S	 S
\5      r) " S S\5      r*\" \*RV                  5      \*l+        \*RV                  R                   b5  \*RV                  R                   RY                  SSSS9\*RV                  l         gg)zH
Feature extraction saving/loading class for common feature extractors.
    N)UserDict)TYPE_CHECKINGAnyOptionalUnion   )custom_object_save)FEATURE_EXTRACTOR_NAMEPushToHubMixin
TensorTypeadd_model_info_to_auto_map"add_model_info_to_custom_pipelinescached_file	copy_funcdownload_urlis_flax_availableis_jax_tensoris_numpy_arrayis_offline_modeis_remote_urlis_tf_availableis_torch_availableis_torch_deviceis_torch_dtypeloggingrequires_backendsSequenceFeatureExtractorc                      ^  \ rS rSrSrSS\\\\4      S\	S\\
4   4U 4S jjjrS\S\	\   4S	 jrS\4S
 jrS rS rS rS rS rSS\\	\\
4      4S jjrSS\\	\\
4      4S jjrSS jrSrU =r$ )BatchFeature=   a-  
Holds the output of the [`~SequenceFeatureExtractor.pad`] and feature extractor specific `__call__` methods.

This class is derived from a python dictionary and can be used as a dictionary.

Args:
    data (`dict`, *optional*):
        Dictionary of lists/arrays/tensors returned by the __call__/pad methods ('input_values', 'attention_mask',
        etc.).
    tensor_type (`Union[None, str, TensorType]`, *optional*):
        You can give a tensor_type here to convert the lists of integers in PyTorch/TensorFlow/Numpy Tensors at
        initialization.
Ndatatensor_typec                 B   > [         TU ]  U5        U R                  US9  g )N)r"   )super__init__convert_to_tensors)selfr!   r"   	__class__s      ]/var/www/auris/envauris/lib/python3.13/site-packages/transformers/feature_extraction_utils.pyr%   BatchFeature.__init__L   s!    K8    itemreturnc                 `    [        U[        5      (       a  U R                  U   $ [        S5      e)zu
If the key is a string, returns the value of the dict associated to `key` ('input_values', 'attention_mask',
etc.).
zRIndexing with integers is not available when using Python based feature extractors)
isinstancestrr!   KeyErrorr'   r,   s     r)   __getitem__BatchFeature.__getitem__P   s+    
 dC  99T?"oppr+   c                 J     U R                   U   $ ! [         a    [        ef = fN)r!   r1   AttributeErrorr2   s     r)   __getattr__BatchFeature.__getattr__Z   s*    	!99T?" 	!  	!s    "c                     SU R                   0$ Nr!   r!   r'   s    r)   __getstate__BatchFeature.__getstate__`   s    		""r+   c                 &    SU;   a  US   U l         g g r;   r<   )r'   states     r)   __setstate__BatchFeature.__setstate__c   s    U?fDI r+   c                 6    U R                   R                  5       $ r6   )r!   keysr=   s    r)   rE   BatchFeature.keysh   s    yy~~r+   c                 6    U R                   R                  5       $ r6   )r!   valuesr=   s    r)   rH   BatchFeature.valuesl   s    yy!!r+   c                 6    U R                   R                  5       $ r6   )r!   itemsr=   s    r)   rK   BatchFeature.itemsp   s    yy  r+   c                 2  ^^ Uc  g[        U[        5      (       d  [        U5      nU[        R                  :X  a:  [        5       (       d  [	        S5      eSS KnUR                  mUR                  nUT4$ U[        R                  :X  a4  [        5       (       d  [	        S5      eSS K
mU4S jmTR                  nUT4$ U[        R                  :X  a6  [        5       (       d  [	        S5      eSS KJn  UR                  m[         nUT4$ SU4S jjm["        nUT4$ )	NNNzSUnable to convert output to TensorFlow tensors format, TensorFlow is not installed.r   zMUnable to convert output to PyTorch tensors format, PyTorch is not installed.c                 &  > [        U [        [        45      (       a  [        U 5      S:  a  [        U S   [        R
                  5      (       a  [        R                  " U 5      n Ok[        U S   [        [        45      (       aM  [        U S   5      S:  a;  [        U S   S   [        R
                  5      (       a  [        R                  " U 5      n [        U [        R
                  5      (       a  TR                  " U 5      $ TR                  " U 5      $ )Nr   )	r/   listtuplelennpndarrayarray
from_numpytensor)valuetorchs    r)   	as_tensor5BatchFeature._get_is_as_tensor_fns.<locals>.as_tensor   s    edE]33E
Q!%(BJJ77 ""58dE];;aMA-&uQx{BJJ?? "eRZZ00 ++E22 <<..r+   zEUnable to convert output to JAX tensors format, JAX is not installed.c                   > [        U [        [        45      (       a  [        U S   [        [        [        R                  45      (       af  U  Vs/ s H  n[        U5      PM     nn[        [        U5      5      S:  a3  Uc0  T" U  Vs/ s H  n[        R                  " U5      PM     sn[        S9n [        R                  " XS9$ s  snf s  snf )Nr   r   )dtype)	r/   rP   rQ   rS   rT   rR   setasarrayobject)rX   r]   val
value_lensrZ   s       r)   rZ   r[      s    edE]33
58dTY[][e[eMf8g8g6;!<es#c(eJ!<3z?+a/EM )e*Les2::c?e*LTZ [zz%55	 "= +Ms   C C	r6   )r/   r   
TENSORFLOWr   ImportError
tensorflowconstant	is_tensorPYTORCHr   rY   JAXr   	jax.numpynumpyrU   r   r   )r'   r"   tfrg   jnprZ   rY   s        @@r)   _get_is_as_tensor_fns"BatchFeature._get_is_as_tensor_fnss   s    +z22$[1K *///"$$!i  $IIP )##O J...%''!"qrr/ I& )##% JNN*$&&!"ijj#		I%I )##6 'I)##r+   c                     Uc  U $ U R                  U5      u  p#U R                  5        H!  u  pE U" U5      (       d  U" U5      nX`U'   M!  M#     U $ !   US:X  a  [        S5      e[        S5      e= f)a  
Convert the inner content to tensors.

Args:
    tensor_type (`str` or [`~utils.TensorType`], *optional*):
        The type of tensors to use. If `str`, should be one of the values of the enum [`~utils.TensorType`]. If
        `None`, no modification is done.
overflowing_valueszKUnable to create tensor returning overflowing values of different lengths. zUnable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.)rn   rK   
ValueError)r'   r"   rg   rZ   keyrX   rW   s          r)   r&   BatchFeature.convert_to_tensors   s     K#99+F	 **,JC ''&u-F &I ( ' ..$%rss X s   AA.c                    [        U S/5        SSKn0 nUR                  S5      nUR                  SS5      nUcz  [        U5      S:  ak  US   n[	        U5      (       a  OU[        U[        5      (       d%  [        U5      (       d  [        U[        5      (       a  UnO[        S[        U5       S35      eU R                  5        H  u  p[        XR                  5      (       a-  UR                  " U	5      (       a  U	R                  " U0 UD6XH'   ML  [        XR                  5      (       a  Ub  U	R                  XVS	9XH'   M|  XU'   M     X@l        U $ )
a)  
Send all values to device by calling `v.to(*args, **kwargs)` (PyTorch only). This should support casting in
different `dtypes` and sending the `BatchFeature` to a different `device`.

Args:
    args (`Tuple`):
        Will be passed to the `to(...)` function of the tensors.
    kwargs (`Dict`, *optional*):
        Will be passed to the `to(...)` function of the tensors.
        To enable asynchronous data transfer, set the `non_blocking` flag in `kwargs` (defaults to `False`).

Returns:
    [`BatchFeature`]: The same instance after modification.
rY   r   Ndevicenon_blockingFz*Attempting to cast a BatchFeature to type z. This is not supported.)rv   rw   )r   rY   getrR   r   r/   r0   r   intrr   rK   Tensoris_floating_pointtor!   )
r'   argskwargsrY   new_datarv   rw   argkvs
             r)   r|   BatchFeature.to   s!    	$	*H%zz.%8>c$i!mq'Cc""C%%)=)=CQTAUAU !#McRUhZWo!pqqJJLDA!\\**u/F/Fq/I/IddD3F3A||,,1Cdd&dL ! 	r+   r<   rN   r6   )r-   r   )__name__
__module____qualname____firstlineno____doc__r   dictr0   r   r   r   r%   r3   r8   r>   rB   rE   rH   rK   rn   r&   r|   __static_attributes____classcell__)r(   s   @r)   r   r   =   s    9Xd38n5 95QUWZ\fQfKg 9 9q qc
 q! !#&
 "!9$%Z:P1Q 9$vhuS*_7M.N >, ,r+   r   c                      \ rS rSrSrSrS rS\4S jr\	     SS\
\\R                  4   S\\
\\R                  4      S	\S
\S\\
\\4      S\4S jj5       rSS\
\\R                  4   S\4S jjr\	S\
\\R                  4   S\\\\4   \\\4   4   4S j5       r\	S\\\4   S\4S j5       rS\\\4   4S jr\	S\
\\R                  4   S\4S j5       rS\4S jrS\
\\R                  4   4S jrS r\	S S j5       rSrg)!FeatureExtractionMixin   z~
This is a feature extraction mixin used to provide saving/loading functionality for sequential and image feature
extractors.
Nc           
          UR                  SS5      U l        UR                  5        H  u  p# [        XU5        M     g! [         a%  n[
        R                  SU SU SU  35        UeSnAff = f)z'Set elements of `kwargs` as attributes.processor_classNz
Can't set z with value z for )pop_processor_classrK   setattrr7   loggererror)r'   r~   rs   rX   errs        r)   r%   FeatureExtractionMixin.__init__  so     !'

+<d C ,,.JC5) ) " z#l5'tfMN	s   ?
A.	 A))A.r   c                     Xl         g)z%Sets processor class as an attribute.Nr   )r'   r   s     r)   _set_processor_class+FeatureExtractionMixin._set_processor_class  s     /r+   pretrained_model_name_or_path	cache_dirforce_downloadlocal_files_onlytokenrevisionc                     X'S'   X7S'   XGS'   XgS'   UR                  SS5      nUb+  [        R                  " S[        5        Ub  [	        S5      eUnUb  XWS	'   U R
                  " U40 UD6u  pU R                  " U	40 UD6$ )
a  
Instantiate a type of [`~feature_extraction_utils.FeatureExtractionMixin`] from a feature extractor, *e.g.* a
derived class of [`SequenceFeatureExtractor`].

Args:
    pretrained_model_name_or_path (`str` or `os.PathLike`):
        This can be either:

        - a string, the *model id* of a pretrained feature_extractor hosted inside a model repo on
          huggingface.co.
        - a path to a *directory* containing a feature extractor file saved using the
          [`~feature_extraction_utils.FeatureExtractionMixin.save_pretrained`] method, e.g.,
          `./my_model_directory/`.
        - a path or url to a saved feature extractor JSON *file*, e.g.,
          `./my_model_directory/preprocessor_config.json`.
    cache_dir (`str` or `os.PathLike`, *optional*):
        Path to a directory in which a downloaded pretrained model feature extractor should be cached if the
        standard cache should not be used.
    force_download (`bool`, *optional*, defaults to `False`):
        Whether or not to force to (re-)download the feature extractor files and override the cached versions
        if they exist.
    resume_download:
        Deprecated and ignored. All downloads are now resumed by default when possible.
        Will be removed in v5 of Transformers.
    proxies (`Dict[str, str]`, *optional*):
        A dictionary of proxy servers to use by protocol or endpoint, e.g., `{'http': 'foo.bar:3128',
        'http://hostname': 'foo.bar:4012'}.` The proxies are used on each request.
    token (`str` or `bool`, *optional*):
        The token to use as HTTP bearer authorization for remote files. If `True`, or not specified, will use
        the token generated when running `huggingface-cli login` (stored in `~/.huggingface`).
    revision (`str`, *optional*, defaults to `"main"`):
        The specific model version to use. It can be a branch name, a tag name, or a commit id, since we use a
        git-based system for storing models and other artifacts on huggingface.co, so `revision` can be any
        identifier allowed by git.


        <Tip>

        To test a pull request you made on the Hub, you can pass `revision="refs/pr/<pr_number>"`.

        </Tip>

    return_unused_kwargs (`bool`, *optional*, defaults to `False`):
        If `False`, then this function returns just the final feature extractor object. If `True`, then this
        functions returns a `Tuple(feature_extractor, unused_kwargs)` where *unused_kwargs* is a dictionary
        consisting of the key/value pairs whose keys are not feature extractor attributes: i.e., the part of
        `kwargs` which has not been used to update `feature_extractor` and is otherwise ignored.
    kwargs (`Dict[str, Any]`, *optional*):
        The values in kwargs of any keys which are feature extractor attributes will be used to override the
        loaded values. Behavior concerning key/value pairs whose keys are *not* feature extractor attributes is
        controlled by the `return_unused_kwargs` keyword parameter.

Returns:
    A feature extractor of type [`~feature_extraction_utils.FeatureExtractionMixin`].

Examples:

```python
# We can't instantiate directly the base class *FeatureExtractionMixin* nor *SequenceFeatureExtractor* so let's show the examples on a
# derived class: *Wav2Vec2FeatureExtractor*
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
    "facebook/wav2vec2-base-960h"
)  # Download feature_extraction_config from huggingface.co and cache.
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
    "./test/saved_model/"
)  # E.g. feature_extractor (or model) was saved using *save_pretrained('./test/saved_model/')*
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained("./test/saved_model/preprocessor_config.json")
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
    "facebook/wav2vec2-base-960h", return_attention_mask=False, foo=False
)
assert feature_extractor.return_attention_mask is False
feature_extractor, unused_kwargs = Wav2Vec2FeatureExtractor.from_pretrained(
    "facebook/wav2vec2-base-960h", return_attention_mask=False, foo=False, return_unused_kwargs=True
)
assert feature_extractor.return_attention_mask is False
assert unused_kwargs == {"foo": False}
```r   r   r   r   use_auth_tokenNrThe `use_auth_token` argument is deprecated and will be removed in v5 of Transformers. Please use `token` instead.V`token` and `use_auth_token` are both specified. Please set only the argument `token`.r   )r   warningswarnFutureWarningrr   get_feature_extractor_dict	from_dict)
clsr   r   r   r   r   r   r~   r   feature_extractor_dicts
             r)   from_pretrained&FeatureExtractionMixin.from_pretrained  s    p ({#1 %5!"%z$4d;%MM E   l  #E#7O),)G)GHe)pio)p&}}3>v>>r+   save_directorypush_to_hubc           	      H   UR                  SS5      nUb=  [        R                  " S[        5        UR	                  SS5      b  [        S5      eXCS'   [        R                  R                  U5      (       a  [        SU S35      e[        R                  " USS	9  U(       ar  UR                  S
S5      nUR                  SUR                  [        R                  R                  5      S   5      nU R                  " U40 UD6nU R                  U5      nU R                  b
  [!        XU S9  [        R                  R#                  U[$        5      nU R'                  U5        [(        R+                  SU 35        U(       a"  U R-                  UWWWUR	                  S5      S9  U/$ )a  
Save a feature_extractor object to the directory `save_directory`, so that it can be re-loaded using the
[`~feature_extraction_utils.FeatureExtractionMixin.from_pretrained`] class method.

Args:
    save_directory (`str` or `os.PathLike`):
        Directory where the feature extractor JSON file will be saved (will be created if it does not exist).
    push_to_hub (`bool`, *optional*, defaults to `False`):
        Whether or not to push your model to the Hugging Face model hub after saving it. You can specify the
        repository you want to push to with `repo_id` (will default to the name of `save_directory` in your
        namespace).
    kwargs (`Dict[str, Any]`, *optional*):
        Additional key word arguments passed along to the [`~utils.PushToHubMixin.push_to_hub`] method.
r   Nr   r   r   zProvided path (z#) should be a directory, not a fileT)exist_okcommit_messagerepo_id)configzFeature extractor saved in )r   r   )r   r   r   r   rx   rr   ospathisfileAssertionErrormakedirssplitsep_create_repo_get_files_timestamps_auto_classr	   joinr
   to_json_filer   info_upload_modified_files)	r'   r   r   r~   r   r   r   files_timestampsoutput_feature_extractor_files	            r)   save_pretrained&FeatureExtractionMixin.save_pretrained  s     $4d;%MM E zz'4(4 l  -7O77>>.)) ?>2BBe!fgg
NT2#ZZ(8$?NjjN,@,@,Mb,QRG'':6:G#99.I 'tDA )+^E[(\%7812O1PQR'' -jj) (  ...r+   r-   c                 4   UR                  SS5      nUR                  SS5      nUR                  SS5      nUR                  SS5      nUR                  SS5      nUR                  SS5      nUR                  S	S5      n	UR                  S
S5      n
UR                  SS5      nU	b+  [        R                  " S[        5        Ub  [	        S5      eU	nUR                  SS5      nUR                  SS5      nSUS.nUb  XS'   [        5       (       a  U
(       d  [        R                  S5        Sn
[        U5      n[        R                  R                  U5      n[        R                  R                  U5      (       a$  [        R                  R                  U[        5      n[        R                  R                  U5      (       a  UnSnO8[        U5      (       a  Un[!        U5      nO[        n [#        UUUUUUU
UUUUS9n [)        USS9 nUR+                  5       nSSS5        [,        R.                  " W5      nU(       a  [        R                  SU 35        O[        R                  SW SU 35        U(       d0  S U;   a  [3        US    U5      US '   S!U;   a  [5        US!   U5      US!'   UU4$ ! [$         a    e [&         a    [%        SU SU S[         S35      ef = f! , (       d  f       N= f! [,        R0                   a    [%        SU S35      ef = f)"a  
From a `pretrained_model_name_or_path`, resolve to a dictionary of parameters, to be used for instantiating a
feature extractor of type [`~feature_extraction_utils.FeatureExtractionMixin`] using `from_dict`.

Parameters:
    pretrained_model_name_or_path (`str` or `os.PathLike`):
        The identifier of the pre-trained checkpoint from which we want the dictionary of parameters.

Returns:
    `Tuple[Dict, Dict]`: The dictionary(ies) that will be used to instantiate the feature extractor object.
r   Nr   Fresume_downloadproxies	subfolderr   r   r   r   r   r   _from_pipeline
_from_autofeature extractor)	file_typefrom_auto_classusing_pipelinez+Offline mode: forcing local_files_only=TrueT)	r   r   r   r   r   r   r   
user_agentr   z"Can't load feature extractor for 'z'. If you were trying to load it from 'https://huggingface.co/models', make sure you don't have a local directory with the same name. Otherwise, make sure 'z2' is the correct path to a directory containing a z fileutf-8encodingz"It looks like the config file at 'z' is not a valid JSON file.zloading configuration file z from cache at auto_mapcustom_pipelines)r   r   r   r   rr   r   r   r   r0   r   r   isdirr   r
   r   r   r   r   OSError	ExceptionopenreadjsonloadsJSONDecodeErrorr   r   )r   r   r~   r   r   r   r   r   r   r   r   r   from_pipeliner   r   is_localfeature_extractor_fileresolved_feature_extractor_filereadertextr   s                        r)   r   1FeatureExtractionMixin.get_feature_extractor_dict  sF    JJ{D1	$4e< **%6=**Y-JJ{D1	

7D)$4d;!::&8%@::j$/%MM E   l  #E

#3T: **\59#6?[
$+8'(%5KKEF#(+,I(J%77==!>?77==677%'WW\\2OQg%h"77>>788.K+H899%B".:;X.Y+%;"2=1*'#1#$3%5')%3/4		5HF{{} I%)ZZ%5" KK56U5VWXKK-.D-E_UtTuv 335O*:68U6&z2 "%;;=_*+=>@]>&'9: &v--S    89V8W X99V8W X//E.FeM  IH ## 	45T4UUpq 	s0   .J1 
K3 K"K3 1.K"
K0,K3 3$Lr   c                 "   UR                  SS5      n/ nUR                  5        H!  u  pVXQ;   d  M  XaU'   UR                  U5        M#     U H  nUR                  US5        M     U " S0 UD6n[        R	                  SU 35        U(       a  Xr4$ U$ )a  
Instantiates a type of [`~feature_extraction_utils.FeatureExtractionMixin`] from a Python dictionary of
parameters.

Args:
    feature_extractor_dict (`Dict[str, Any]`):
        Dictionary that will be used to instantiate the feature extractor object. Such a dictionary can be
        retrieved from a pretrained checkpoint by leveraging the
        [`~feature_extraction_utils.FeatureExtractionMixin.to_dict`] method.
    kwargs (`Dict[str, Any]`):
        Additional parameters from which to initialize the feature extractor object.

Returns:
    [`~feature_extraction_utils.FeatureExtractionMixin`]: The feature extractor object instantiated from those
    parameters.
return_unused_kwargsFNzFeature extractor  )r   rK   appendr   r   )r   r   r~   r   	to_removers   rX   feature_extractors           r)   r    FeatureExtractionMixin.from_dict6  s    $  &zz*@%H 	 ,,.JC,.3s+  % ) CJJsD!   9"89():(;<=$,,$$r+   c                     [         R                  " U R                  5      nU R                  R                  US'   SU;   a  US	 SU;   a  US	 U$ )z
Serializes this instance to a Python dictionary. Returns:
    `Dict[str, Any]`: Dictionary of all the attributes that make up this configuration instance.
feature_extractor_typemel_filterswindow)copydeepcopy__dict__r(   r   )r'   outputs     r)   to_dictFeatureExtractionMixin.to_dict[  sP    
 t}}-+/>>+B+B'(F"}%vx r+   	json_filec                     [        USS9 nUR                  5       nSSS5        [        R                  " W5      nU " S0 UD6$ ! , (       d  f       N,= f)a  
Instantiates a feature extractor of type [`~feature_extraction_utils.FeatureExtractionMixin`] from the path to
a JSON file of parameters.

Args:
    json_file (`str` or `os.PathLike`):
        Path to the JSON file containing the parameters.

Returns:
    A feature extractor of type [`~feature_extraction_utils.FeatureExtractionMixin`]: The feature_extractor
    object instantiated from that JSON file.
r   r   Nr   )r   r   r   r   )r   r   r   r   r   s        r)   from_json_file%FeatureExtractionMixin.from_json_fileh  sG     )g.&;;=D /!%D!1,+,, /.s   A
Ac                    U R                  5       nUR                  5        H8  u  p#[        U[        R                  5      (       d  M&  UR                  5       X'   M:     UR                  SS5      nUb  XAS'   [        R                  " USSS9S-   $ )z
Serializes this instance to a JSON string.

Returns:
    `str`: String containing all the attributes that make up this feature_extractor instance in JSON format.
r   Nr      T)indent	sort_keys
)	r   rK   r/   rS   rT   tolistr   r   dumps)r'   
dictionaryrs   rX   r   s        r)   to_json_string%FeatureExtractionMixin.to_json_string{  s}     \\^
$**,JC%,,"',,.
 - &>>*<dC',<()zz*Q$?$FFr+   json_file_pathc                     [        USSS9 nUR                  U R                  5       5        SSS5        g! , (       d  f       g= f)z
Save this instance to a JSON file.

Args:
    json_file_path (`str` or `os.PathLike`):
        Path to the JSON file in which this feature_extractor instance's parameters will be saved.
wr   r   N)r   writer  )r'   r  writers      r)   r   #FeatureExtractionMixin.to_json_file  s3     .#8FLL,,./ 988s	    5
Ac                 T    U R                   R                   SU R                  5        3$ )N )r(   r   r  r=   s    r)   __repr__FeatureExtractionMixin.__repr__  s(    ..))*!D,?,?,A+BCCr+   c                     [        U[        5      (       d  UR                  nSSKJs  Jn  [        X!5      (       d  [        U S35      eXl        g)a  
Register this class with a given auto class. This should only be used for custom feature extractors as the ones
in the library are already mapped with `AutoFeatureExtractor`.

<Tip warning={true}>

This API is experimental and may have some slight breaking changes in the next releases.

</Tip>

Args:
    auto_class (`str` or `type`, *optional*, defaults to `"AutoFeatureExtractor"`):
        The auto class to register this new feature extractor with.
r   Nz is not a valid auto class.)	r/   r0   r   transformers.models.automodelsautohasattrrr   r   )r   
auto_classauto_modules      r)   register_for_auto_class.FeatureExtractionMixin.register_for_auto_class  sE      *c**#,,J66{//
|+FGHH$r+   r   )NFFNmain)F)AutoFeatureExtractor)r   r   r   r   r   r   r%   r0   r   classmethodr   r   PathLiker   boolr   r   rQ   r   r   r   PreTrainedFeatureExtractorr   r   r   r  r   r  r  r   r   r+   r)   r   r      s   
 K
0C 0  8<$!&,0m?',S"++-='>m? E#r{{"234m? 	m?
 m? c4i()m? m? m?^;/eC4D.E ;/TX ;/z r.,1#r{{2B,Cr.	tCH~tCH~-	.r. r.h "%tCH~ "%Lf "% "%Hc3h  -uS"++-='> -C] - -$G G*	05bkk1A+B 	0D % %r+   r   r   r  zfeature extractor file)r`   object_classobject_files)-r   r   r   r   r   collectionsr   typingr   r   r   r   rk   rS   dynamic_module_utilsr	   utilsr
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rY   
get_loggerr   r   r  r   r   r   formatr   r+   r)   <module>r(     s      	    6 6  4     .  
		H	%"#=> |8 |~z%^ z%z &//E/Q/Q%R  "%%--91G1S1S1[1[1b1b"1GVn 2c 2&&. :r+   