U di9 @sdZddlZddlZddlZddlZddlZddlZddlZddlm Z ddlm Z m Z m Z m Z mZmZmZddlZddlZddlmZddlmZmZmZerddlmZdd lmZmZmZmZm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.e./e0Z1e*e e2j3Z4d d d dZ5ej6dkr>ej7Z7nej7Z7GdddeddZ8GdddeddZ9GdddeddZ:GdddeddZ;GdddeddZd d!Z?e)e>j@e>_@e>j@jdk re>j@jjAd"d#d$d%e>j@_dS)&z8 Processing saving/loading class for common processors. N)Path)AnyDictListOptionalTuple TypedDictUnion)custom_object_save)ChannelDimensionis_valid_imageis_vision_available)PILImageResampling)PaddingStrategyPreTokenizedInputPreTrainedTokenizerBase TextInputTruncationStrategy) CHAT_TEMPLATE_NAMEPROCESSOR_NAMEPushToHubMixin TensorTypeadd_model_info_to_auto_map"add_model_info_to_custom_pipelines cached_file copy_funcdirect_transformers_import download_urlis_offline_mode is_remote_urlloggingrZFeatureExtractionMixinZImageProcessingMixin)Z AutoTokenizerZAutoFeatureExtractorZAutoImageProcessor) c@s.eZdZUdZeeeeeeeefe d<eeeeeeefe d<eeeeeeeefe d<ee e d<ee e e fe d<ee e e fe d<eee d<eee d <ee e d <eee d <ee e d <ee e d <ee e d<ee e d<ee e d<ee e d<ee e d<ee e d<dS) TextKwargsa Keyword arguments for text processing. For extended documentation, check out tokenization_utils_base methods and docstrings associated. Attributes: add_special_tokens (`bool`, *optional*) Whether or not to add special tokens when encoding the sequences. padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*) Activates and controls padding. truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*): Activates and controls truncation. max_length (`int`, *optional*): Controls the maximum length to use by one of the truncation/padding parameters. stride (`int`, *optional*): If set, the overflowing tokens will contain some tokens from the end of the truncated sequence. is_split_into_words (`bool`, *optional*): Whether or not the input is already pre-tokenized. pad_to_multiple_of (`int`, *optional*): If set, will pad the sequence to a multiple of the provided value. return_token_type_ids (`bool`, *optional*): Whether to return token type IDs. return_attention_mask (`bool`, *optional*): Whether to return the attention mask. return_overflowing_tokens (`bool`, *optional*): Whether or not to return overflowing token sequences. return_special_tokens_mask (`bool`, *optional*): Whether or not to return special tokens mask information. return_offsets_mapping (`bool`, *optional*): Whether or not to return `(char_start, char_end)` for each token. return_length (`bool`, *optional*): Whether or not to return the lengths of the encoded inputs. verbose (`bool`, *optional*): Whether or not to print more information and warnings. padding_side (`str`, *optional*): The side on which padding will be applied. Z text_pairZ text_targetZtext_pair_targetZadd_special_tokenspadding truncation max_lengthZstrideZis_split_into_wordspad_to_multiple_ofZreturn_token_type_idsreturn_attention_maskZreturn_overflowing_tokensZreturn_special_tokens_maskZreturn_offsets_mappingZ return_lengthverboseZ padding_sideN)__name__ __module__ __qualname____doc__rr rrr__annotations__boolstrrrintr3r3A/tmp/pip-unpacked-wheel-bm_b0l5e/transformers/processing_utils.pyr$Qs& %              r$F)totalc@seZdZUdZeeed<eeee fed<ee ed<eeee fed<ee de fed<eeed<ee ed <eeed <ee e e e fed <ee e e e fed <eeed <eeee fed<eeed<ee ed<ee ee fed<dS) ImagesKwargsaW Keyword arguments for image processing. For extended documentation, check the appropriate ImageProcessor class methods and docstrings. Attributes: do_resize (`bool`, *optional*): Whether to resize the image. size (`Dict[str, int]`, *optional*): Resize the shorter side of the input to `size["shortest_edge"]`. size_divisor (`int`, *optional*): The size by which to make sure both the height and width can be divided. crop_size (`Dict[str, int]`, *optional*): Desired output size when applying center-cropping. resample (`PILImageResampling`, *optional*): Resampling filter to use if resizing the image. do_rescale (`bool`, *optional*): Whether to rescale the image by the specified scale `rescale_factor`. rescale_factor (`int` or `float`, *optional*): Scale factor to use if rescaling the image. do_normalize (`bool`, *optional*): Whether to normalize the image. image_mean (`float` or `List[float]`, *optional*): Mean to use if normalizing the image. image_std (`float` or `List[float]`, *optional*): Standard deviation to use if normalizing the image. do_pad (`bool`, *optional*): Whether to pad the image to the `(max_height, max_width)` of the images in the batch. pad_size (`Dict[str, int]`, *optional*): The size `{"height": int, "width" int}` to pad the images to. do_center_crop (`bool`, *optional*): Whether to center crop the image. data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the output image. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the input image. do_resizesize size_divisorZ crop_sizerresample do_rescalerescale_factor do_normalize image_mean image_stddo_padZpad_sizedo_center_crop data_formatinput_data_formatN)r+r,r-r.rr0r/rr1r2r floatrr r3r3r3r4r6s %        r6c@seZdZUdZeeed<eeee fed<ee ed<eded<eeed<ee ed<eeed <ee e e e fed <ee e e e fed <eeed <eeed <ee ed<ee ee fed<dS) VideosKwargsa Keyword arguments for video processing. Attributes: do_resize (`bool`): Whether to resize the image. size (`Dict[str, int]`, *optional*): Resize the shorter side of the input to `size["shortest_edge"]`. size_divisor (`int`, *optional*): The size by which to make sure both the height and width can be divided. resample (`PILImageResampling`, *optional*): Resampling filter to use if resizing the image. do_rescale (`bool`, *optional*): Whether to rescale the image by the specified scale `rescale_factor`. rescale_factor (`int` or `float`, *optional*): Scale factor to use if rescaling the image. do_normalize (`bool`, *optional*): Whether to normalize the image. image_mean (`float` or `List[float]`, *optional*): Mean to use if normalizing the image. image_std (`float` or `List[float]`, *optional*): Standard deviation to use if normalizing the image. do_pad (`bool`, *optional*): Whether to pad the image to the `(max_height, max_width)` of the images in the batch. do_center_crop (`bool`, *optional*): Whether to center crop the image. data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the output image. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the input image. r7r8r9rr:r;r<r=r>r?r@rArBrCN)r+r,r-r.rr0r/rr1r2rDr rr r3r3r3r4rEs          rEc@seZdZUdZeeed<eedee edeee fed<eee e e fed<eeed<ee ed<eeed<ee ed <d S) AudioKwargsa Keyword arguments for audio processing. Attributes: sampling_rate (`int`, *optional*): The sampling rate at which the `raw_speech` input was sampled. raw_speech (`np.ndarray`, `List[float]`, `List[np.ndarray]`, `List[List[float]]`): The sequence or batch of sequences to be padded. Each sequence can be a numpy array, a list of float values, a list of numpy arrays or a list of list of float values. Must be mono channel audio, not stereo, i.e. single float per timestep. padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*): Select a strategy to pad the returned sequences (according to the model's padding side and padding index) among: - `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'` max_length (`int`, *optional*): Maximum length of the returned list and optionally padding length (see above). truncation (`bool`, *optional*): Activates truncation to cut input sequences longer than *max_length* to *max_length*. pad_to_multiple_of (`int`, *optional*): If set, will pad the sequence to a multiple of the provided value. return_attention_mask (`bool`, *optional*): Whether or not [`~ASTFeatureExtractor.__call__`] should return `attention_mask`. Z sampling_ratez np.ndarrayZ raw_speechr%r'r&r(r)N) r+r,r-r.rr2r/r rrDr0r1rr3r3r3r4rFs  (   rFc@s"eZdZUeeeefed<dS) CommonKwargsZreturn_tensorsN)r+r,r-rr r1rr/r3r3r3r4rGs rGc@sbeZdZUdZejZeed<ejZeed<e jZ e ed<e jZ e ed<e jZe ed<dS)ProcessingKwargsa' Base class for kwargs passing to processors. A model should have its own `ModelProcessorKwargs` class that inherits from `ProcessingKwargs` to provide: 1) Additional typed keys and that this model requires to process inputs. 2) Default values for existing keys under a `_defaults` attribute. New keys have to be defined as follows to ensure type hinting is done correctly. ```python # adding a new image kwarg for this model class ModelImagesKwargs(ImagesKwargs, total=False): new_image_kwarg: Optional[bool] class ModelProcessorKwargs(ProcessingKwargs, total=False): images_kwargs: ModelImagesKwargs _defaults = { "images_kwargs: { "new_image_kwarg": False, } "text_kwargs": { "padding": "max_length", }, } ``` For Python 3.8 compatibility, when inheriting from this class and overriding one of the kwargs, you need to manually update the __annotations__ dictionary. This can be done as follows: ```python class CustomProcessorKwargs(ProcessingKwargs, total=False): images_kwargs: CustomImagesKwargs CustomProcessorKwargs.__annotations__["images_kwargs"] = CustomImagesKwargs # python 3.8 compatibility ```python common_kwargs text_kwargs images_kwargs videos_kwargs audio_kwargsN)r+r,r-r.rGr/rIr$rJr6rKrErLrFrMr3r3r3r4rHs &    rHc @seZdZUdZddgZdgZgZeee d<dZ dZ dZ gZ eee d<dd Zeeefd d d Zed d dZeeejfdddZddZd3edddZeeeejfeeeefeeeffdddZeeeefdddZd4eeeeeefddd Z ed5eeejfeeeejfeeeeeefed"d#d$Z!ed6d&d'Z"ed(d)Z#e$d*d+Z%e&d,d-Z'd.d/Z(d7eeeeefeeeed0d1d2Z)dS)8ProcessorMixinza This is a mixin used to provide saving/loading functionality for all processor classes. feature_extractor tokenizer chat_templateoptional_call_argsN valid_kwargsc OsR|jD]}t||||dq|D]}||jkr$td|dq$t||jD]*\}}||krrtd|dqP|||<qPt|t|jkrtdt|jdd|jdt|d| D]\}}t ||d }t ||}t |trtd d |D}n t t|}t ||s@td t|jd |d|dt|||qdS)NzUnexpected keyword argument .z!Got multiple values for argument zThis processor requires z arguments: , z. Got z arguments instead._classcss |]}|dk rtt|VqdSNgetattrtransformers_module.0nr3r3r4 ~sz*ProcessorMixin.__init__..z Received a z for argument z, but a z was expected.)optional_attributessetattrpop attributes TypeErrorziplen ValueErrorjoinitemsrYAUTO_TO_BASE_CLASS_MAPPINGget isinstancetuplerZtyper+) selfargskwargsZoptional_attributekeyargattribute_name class_nameZ proper_classr3r3r4__init__cs0   (    zProcessorMixin.__init__returncstj}tj}|jfddDdg7fdd|D}jj |d<d|krj|d=d|krx|d=d |kr|d =d |kr|d =d d|D}|S) z Serializes this instance to a Python dictionary. Returns: `Dict[str, Any]`: Dictionary of all the attributes that make up this processor instance. csg|]}|jjkr|qSr3) __class__rb)r\xrnr3r4 s z*ProcessorMixin.to_dict..auto_mapcsi|]\}}|kr||qSr3r3r\kv) attrs_to_saver3r4 sz*ProcessorMixin.to_dict..processor_classrPZimage_processorrOrQcSs,i|]$\}}t|ts|jjdks||qS)ZBeamSearchDecoderCTC)rkrrxr+r}r3r3r4rs  ) copydeepcopy__dict__inspect signatureru parametersrhrxr+)rnoutputsigr3)rrnr4to_dicts&    zProcessorMixin.to_dictcCs|}tj|ddddS)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. Tindent sort_keys )rjsondumps)rn dictionaryr3r3r4to_json_stringszProcessorMixin.to_json_string)json_file_pathc Cs,t|ddd}||W5QRXdS)z Save this instance to a JSON file. Args: json_file_path (`str` or `os.PathLike`): Path to the JSON file in which this processor instance's parameters will be saved. wutf-8encodingN)openwriter)rnrwriterr3r3r4 to_json_fileszProcessorMixin.to_json_filecs:fddjD}d|}jjd|dS)Nc s&g|]}d|dtt|qS)z- z: )reprrY)r\namerzr3r4r{sz+ProcessorMixin.__repr__..rz: z )rbrgrxr+r)rnZattributes_reprr3rzr4__repr__s zProcessorMixin.__repr__F) push_to_hubc s0|dd}|dk r@tdt|dddk r8td||d<tj|dd|r|dd}|d |tj j d }j |f|} |}j dk rԇfd d jD}d d |D} | t|| djD]2} t| } t| dr| jj| |qڈj dk rFjD]$} t| } t| tr | jd=q tj |t} tj |t} }jdk rtj djidddd}t!| ddd}|"|W5QRXt#$d| t%|&dhkr'| t#$d| |rj(|||||ddt%|&dhkr*gS| gS)a Saves the attributes of this processor (feature extractor, tokenizer...) in the specified directory so that it can be reloaded using the [`~ProcessorMixin.from_pretrained`] method. This class method is simply calling [`~feature_extraction_utils.FeatureExtractionMixin.save_pretrained`] and [`~tokenization_utils_base.PreTrainedTokenizerBase.save_pretrained`]. Please refer to the docstrings of the methods above for more information. Args: save_directory (`str` or `os.PathLike`): Directory where the feature extractor JSON file and the tokenizer files will be saved (directory 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. use_auth_tokenNrThe `use_auth_token` argument is deprecated and will be removed in v5 of Transformers. Please use `token` instead.tokenV`token` and `use_auth_token` are both specified. Please set only the argument `token`.T)exist_okcommit_messagerepo_idcsg|]}t|qSr3)rY)r\rsrzr3r4r{sz2ProcessorMixin.save_pretrained..cSs g|]}t|tr|jn|qSr3)rkr init_kwargs)r\ar3r3r4r{s)config_set_processor_classr|rQrrrrrrzchat template saved in rzprocessor saved in )rr))rawarningswarn FutureWarningrjrfosmakedirssplitpathsepZ _create_repoZ_get_files_timestamps _auto_classrbappendr rYhasattrrrxr+save_pretrainedrkrrrgrrrrQrrrrloggerinfosetkeysrZ_upload_modified_files)rnZsave_directoryrrprrrZfiles_timestampsattrsZconfigsrs attributeZoutput_processor_fileZoutput_chat_template_fileprocessor_dictZchat_template_json_stringrr3rzr4rsn                zProcessorMixin.save_pretrained)pretrained_model_name_or_pathrwcKs|dd}|dd}|dd}|dd}|dd}|dd}|d d} |d d } |d d} |d d} d| d} | dk r| | d<tr|stdd}t|}tj|}tj|rtj|t }tj|d}tj |r|}d}d}nt |r|}t |}d}nt }t }zDt||||||||| | | dd }t||||||||| | | dd }WnHtk rYn2tk rtd|d|dt dYnXd}|dk rt|ddd}|}W5QRXt|d}||d<|dkr i|fSz0t|ddd}|}W5QRXt|}Wn(tjk rdtd|dYnX|r~td|ntd|d |d|kr|ddk rtd!|sd"|krt|d"||d"<d#|krt|d#||d#<||fS)$a From a `pretrained_model_name_or_path`, resolve to a dictionary of parameters, to be used for instantiating a processor of type [`~processing_utils.ProcessingMixin`] using `from_args_and_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. subfolder (`str`, *optional*, defaults to `""`): In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you can specify the folder name here. Returns: `Tuple[Dict, Dict]`: The dictionary(ies) that will be used to instantiate the processor object. cache_dirNforce_downloadFresume_downloadproxiesrlocal_files_onlyrevision subfolderZ_from_pipelineZ _from_auto processor) file_typefrom_auto_classZusing_pipelinez+Offline mode: forcing local_files_only=TrueTzchat_template.json) rrrrrr user_agentrrZ%_raise_exceptions_for_missing_entrieszCan't load processor 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 filerrrrQz"It looks like the config file at 'z' is not a valid JSON file.zloading configuration file z from cache at zChat templates should be in a 'chat_template.json' file but found key='chat_template' in the processor's config. Make sure to move your template to its own file.r|Zcustom_pipelines)rarrrr1rrisdirrgrisfiler rrrEnvironmentError ExceptionrreadrloadsJSONDecodeError warning_oncerr)clsrrprrrrrrrrZ from_pipelinerris_localZprocessor_fileZchat_template_fileZresolved_processor_fileZresolved_chat_template_filerQreadertextrr3r3r4get_processor_dict2s                       z!ProcessorMixin.get_processor_dict)rc Ks|}|dd}|dd}d|kr.|d=d|kr<|d=|j||jd}|||}|dk rjt|d|t|D] }t||rvt||||qv||t d||r||fS|SdS) a Instantiates a type of [`~processing_utils.ProcessingMixin`] from a Python dictionary of parameters. Args: processor_dict (`Dict[str, Any]`): Dictionary that will be used to instantiate the processor object. Such a dictionary can be retrieved from a pretrained checkpoint by leveraging the [`~processing_utils.ProcessingMixin.to_dict`] method. kwargs (`Dict[str, Any]`): Additional parameters from which to initialize the processor object. Returns: [`~processing_utils.ProcessingMixin`]: The processor object instantiated from those parameters. return_unused_kwargsFrQNrr|)processor_configrSz Processor ) rravalidate_init_kwargsrSr`rrrupdaterr) rrorrprrQ unused_kwargsrrqr3r3r4from_args_and_dicts&      z!ProcessorMixin.from_args_and_dict)ModelProcessorKwargstokenizer_init_kwargsrwc siiiiid}iiiiidt}D]d}|j|i|<|j|jD]8}||krTt|j|rxt|j|n||}|||<qTq*| t|t|} |D]}|j|jD]}||kr || |d} | dkr(|| kr(t d|d|dn||kr$||d} nd} | dkr| |||<| |qqt fdd|Dr|D]H\}} |krj| D]*\} } | |kr| ||| <| | qqjn&|D] }||kr|||d|<q|D]}|| |dq|S) a Method to merge dictionaries of kwargs cleanly separated by modality within a Processor instance. The order of operations is as follows: 1) kwargs passed as before have highest priority to preserve BC. ```python high_priority_kwargs = {"crop_size" = {"height": 222, "width": 222}, "padding" = "max_length"} processor(..., **high_priority_kwargs) ``` 2) kwargs passed as modality-specific kwargs have second priority. This is the recommended API. ```python processor(..., text_kwargs={"padding": "max_length"}, images_kwargs={"crop_size": {"height": 222, "width": 222}}}) ``` 3) kwargs passed during instantiation of a modality processor have fourth priority. ```python tokenizer = tokenizer_class(..., {"padding": "max_length"}) image_processor = image_processor_class(...) processor(tokenizer, image_processor) # will pass max_length unless overriden by kwargs at call ``` 4) defaults kwargs specified at processor level have lowest priority. ```python class MyProcessingKwargs(ProcessingKwargs, CommonKwargs, TextKwargs, ImagesKwargs, total=False): _defaults = { "text_kwargs": { "padding": "max_length", "max_length": 64, }, } ``` Args: ModelProcessorKwargs (`ProcessingKwargs`): Typed dictionary of kwargs specifically required by the model passed. tokenizer_init_kwargs (`Dict`, *optional*): Dictionary of kwargs the tokenizer was instantiated with and need to take precedence over defaults. Returns: output_kwargs (`Dict`): Dictionary of per-modality kwargs to be passed to each modality-specific processor. )rJrKrMrLrIZ __empty__zKeyword argument z+ was passed two times: in a dictionary for z and as a **kwarg.c3s|]}|kVqdSrWr3)r\rqZdefault_kwargsr3r4r^bsz/ProcessorMixin._merge_kwargs..rI)r _defaultsrjrr/rrrPrYrrarfaddanyrh)rnrrrpZ output_kwargsZ used_keysZmodalityZ modality_keyvalueZnon_modality_kwargsZ kwarg_valueZsubdictsubkeyZsubvaluerqr3rr4 _merge_kwargssf/          zProcessorMixin._merge_kwargsmain)rrrrrrc Ks||d<||d<||d<||d<|dd}|dk rTtdt|dk rPtd|}|dk rd||d <|j|f|} |j|f|\} }|j| | f|S) a[ Instantiate a processor associated with a pretrained model. This class method is simply calling the feature extractor [`~feature_extraction_utils.FeatureExtractionMixin.from_pretrained`], image processor [`~image_processing_utils.ImageProcessingMixin`] and the tokenizer [`~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`] methods. Please refer to the docstrings of the methods above for more information. 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 [`~SequenceFeatureExtractor.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`. **kwargs Additional keyword arguments passed along to both [`~feature_extraction_utils.FeatureExtractionMixin.from_pretrained`] and [`~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`]. rrrrrNrrr)rarrrrf_get_arguments_from_pretrainedrr) rrrrrrrrprrorr3r3r4from_pretrainedus(' zProcessorMixin.from_pretrained AutoProcessorcCsDt|ts|j}ddlmm}t||s:t|d||_dS)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 `AutoProcessor`. This API is experimental and may have some slight breaking changes in the next releases. Args: auto_class (`str` or `type`, *optional*, defaults to `"AutoProcessor"`): The auto class to register this new feature extractor with. rNz is not a valid auto class.) rkr1r+Ztransformers.models.automodelsautorrfr)rZ auto_classZ auto_moduler3r3r4register_for_auto_classs   z&ProcessorMixin.register_for_auto_classc Ksg}|jD]~}t||d}t|trjtdd|D}|dd}|r`|ddk r`|d}qt|d}n tt|}||j|f|q |S)NrVcss$|]}|dk rtt|ndVqdSrWrXr[r3r3r4r^sz@ProcessorMixin._get_arguments_from_pretrained..use_fastTr r)rbrYrkrlrjrZrr) rrrprorsrtclassesrZattribute_classr3r3r4rs      z-ProcessorMixin._get_arguments_from_pretrainedcCst||jd}t|ddS)Nrmodel_input_names)rYrb)rnZfirst_attributer3r3r4rsz ProcessorMixin.model_input_namescsR}i}t|t|}|rNd|}td|dfdd|D}|S)NrUzISome kwargs in processor config are unused and will not have any effect: z. csi|]}||qSr3r3)r\r~rr3r4rsz7ProcessorMixin.validate_init_kwargs..)rrrgrwarning)rrSZkwargs_from_configrZ unused_keysZunused_key_strr3rr4rs  z#ProcessorMixin.validate_init_kwargscGsht|rtdt|t|jkrRtdt|jdd|jdt|dddt||jDS) a Matches optional positional arguments to their corresponding names in `optional_call_args` in the processor class in the order they are passed to the processor call. Note that this should only be used in the `__call__` method of the processors with special arguments. Special arguments are arguments that aren't `text`, `images`, `audio`, nor `videos` but also aren't passed to the tokenizer, image processor, etc. Examples of such processors are: - `CLIPSegProcessor` - `LayoutLMv2Processor` - `OwlViTProcessor` Also note that passing by position to the processor call is now deprecated and will be disallowed in future versions. We only have this for backward compatibility. Example: Suppose that the processor class has `optional_call_args = ["arg_name_1", "arg_name_2"]`. And we define the call method as: ```python def __call__( self, text: str, images: Optional[ImageInput] = None, *arg, audio=None, videos=None, ) ``` Then, if we call the processor as: ```python images = [...] processor("What is common in these images?", images, arg_value_1, arg_value_2) ``` Then, this method will return: ```python { "arg_name_1": arg_value_1, "arg_name_2": arg_value_2, } ``` which we could then pass as kwargs to `self._merge_kwargs` zPassing positional arguments to the processor call is now deprecated and will be disallowed in v4.47. Please pass all arguments as keyword arguments.zExpected *at most* zK optional positional arguments in processor callwhich will be matched with  z+ in the order they are passed.However, got z positional arguments instead.Please pass all arguments as keyword arguments instead (e.g. `processor(arg_name_1=..., arg_name_2=...))`.cSsi|]\}}||qSr3r3)r\ arg_valueZarg_namer3r3r4r+szJProcessorMixin.prepare_and_validate_optional_call_args..)rerrrRrfrgrd)rnror3r3r4'prepare_and_validate_optional_call_argss,(z6ProcessorMixin.prepare_and_validate_optional_call_args) conversationrQtokenizerwcKs<|dkr"|jdk r|j}ntd|jj|f||d|S)a Similar to the `apply_chat_template` method on tokenizers, this method applies a Jinja template to input conversations to turn them into a single tokenizable string. Args: conversation (`List[Dict, str, str]`): The conversation to format. chat_template (`Optional[str]`, *optional*): The Jinja template to use for formatting the conversation. If not provided, the tokenizer's chat template is used. tokenize (`bool`, *optional*, defaults to `False`): Whether to tokenize the output or not. **kwargs: Additional keyword arguments NzNo chat template is set for this processor. Please either set the `chat_template` attribute, or provide a chat template as an argument. See https://huggingface.co/docs/transformers/main/en/chat_templating for more information.)rQr)rQrfrPapply_chat_template)rnrrQrrpr3r3r4r-s z"ProcessorMixin.apply_chat_template)F)N)NFFNr)r)NF)*r+r,r-r.rbr_rRrr1r/Zfeature_extractor_classZtokenizer_classrrSrurrrrr rPathLikerrr0r classmethodrrrrHrrrrrpropertyr staticmethodrrrr3r3r3r4rNTst &(  f 0 | ?    =rNcstdddfddfdddd }||}|}||}|}|rd|rd||fS|d krp|s|d kr||s|r|rtd ||fStd d S) a For backward compatibility: reverse the order of `images` and `text` inputs if they are swapped. This method should only be called for processors where `images` and `text` have been swapped for uniformization purposes. Note that this method assumes that two `None` inputs are valid inputs. If this is not the case, it should be handled in the processor's `__call__` method before calling this method. rvcSst|to|dS)Nhttp)rkr1 startswith)valr3r3r4is_urlZsz1_validate_images_text_input_order..is_urlcs@t|ttfr(|D]}|sdSqnt|s<|s._is_valid_images_input_for_processorcsDt|trdSt|ttfr@t|dkr,dS|D]}|SdS)NTrF)rkr1rrlre)tZt_s)"_is_valid_text_input_for_processorr3r4r hs   zM_validate_images_text_input_order.._is_valid_text_input_for_processorcSs||p|dkSrWr3)inputZ validatorr3r3r4 _is_validusz4_validate_images_text_input_order.._is_validNzYou may have used the wrong order for inputs. `images` should be passed before `text`. The `images` and `text` inputs will be swapped. This behavior will be deprecated in transformers v4.47.zGInvalid input type. Check that `images` and/or `text` are valid inputs.)r0rrrf)Zimagesrr Zimages_is_validZimages_is_textZ text_is_validZtext_is_imagesr3)rr rr4!_validate_images_text_input_orderRs     r rrzprocessor files)objectZ object_classZ object_files)Br.rrrrsystypingrpathlibrrrrrrrr ZnumpynpZtyping_extensionsZdynamic_module_utilsr Z image_utilsr r rrZtokenization_utils_baserrrrrutilsrrrrrrrrrrrr r!Z get_loggerr+r__file__parentrZri version_infoZUnpackr$r6rErFrGrHrNr rformatr3r3r3r4s^ $  <  :70'7: