
    sgIb                        d dl Z d dlZd dlZd dlZd dlmZ d dlmZmZm	Z	m
Z
mZmZmZmZ d dlZd dlZddlmZ ddlmZ ddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z"  e!       rd dl#m$Z$  ed	d
      Z% e"jL                  e'      Z( G d de      Z G d d
e      Z) ee)jT                        e)_*        e)jT                  jV                  8e)jT                  jV                  jY                  ddd      e)jT                  _+        yy)    N)BytesIO)AnyDictListOptionalTupleTypeTypeVarUnion   )custom_object_save)BatchFeature)IMAGE_PROCESSOR_NAMEPushToHubMixinadd_model_info_to_auto_map"add_model_info_to_custom_pipelinescached_file	copy_funcdownload_urlis_offline_modeis_remote_urlis_vision_availablelogging)ImageImageProcessorTypeImageProcessingMixin)boundc                       e Zd ZdZy)r   a  
    Holds the output of the image processor specific `__call__` methods.

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

    Args:
        data (`dict`):
            Dictionary of lists/arrays/tensors returned by the __call__ method ('pixel_values', 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)__name__
__module____qualname____doc__     U/var/www/html/venv/lib/python3.12/site-packages/transformers/image_processing_base.pyr   r   8   s    r$   r   c                      e Zd ZdZdZd ZdefdZe	 	 	 	 	 dde	e
   deeej                  f   deeeej                  f      d	ed
edeeeef      dede
fd       Zd deeej                  f   defdZedeeej                  f   deeeef   eeef   f   fd       Zedeeef   fd       Zdeeef   fdZedeeej                  f   fd       ZdefdZdeeej                  f   fdZd Zed!d       Zdeeee   f   fdZy)"r   z
    This is an image processor mixin used to provide saving/loading functionality for sequential and image feature
    extractors.
    Nc           
         |j                  dd       |j                  dd      | _        |j                         D ]  \  }}	 t        | ||        y# t        $ r%}t
        j                  d| d| d|         |d}~ww xY w)z'Set elements of `kwargs` as attributes.feature_extractor_typeNprocessor_classz
Can't set z with value z for )pop_processor_classitemssetattrAttributeErrorloggererror)selfkwargskeyvalueerrs        r%   __init__zImageProcessingMixin.__init__P   s     	

+T2 &

+<d C ,,. 	JCc5)	 " z#l5'tfMN	s   A	A? A::A?r)   c                     || _         y)z%Sets processor class as an attribute.N)r+   )r1   r)   s     r%   _set_processor_classz)ImageProcessingMixin._set_processor_class_   s
     /r$   clspretrained_model_name_or_path	cache_dirforce_downloadlocal_files_onlytokenrevisionreturnc                    ||d<   ||d<   ||d<   ||d<   |j                  dd      }|)t        j                  dt               |t	        d      |}|||d	<    | j
                  |fi |\  }	} | j                  |	fi |S )
a  
        Instantiate a type of [`~image_processing_utils.ImageProcessingMixin`] from an image processor.

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

                - a string, the *model id* of a pretrained image_processor hosted inside a model repo on
                  huggingface.co.
                - a path to a *directory* containing a image processor file saved using the
                  [`~image_processing_utils.ImageProcessingMixin.save_pretrained`] method, e.g.,
                  `./my_model_directory/`.
                - a path or url to a saved image processor 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 image processor 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 image processor 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 image processor object. If `True`, then this
                functions returns a `Tuple(image_processor, unused_kwargs)` where *unused_kwargs* is a dictionary
                consisting of the key/value pairs whose keys are not image processor attributes: i.e., the part of
                `kwargs` which has not been used to update `image_processor` and is otherwise ignored.
            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.
            kwargs (`Dict[str, Any]`, *optional*):
                The values in kwargs of any keys which are image processor attributes will be used to override the
                loaded values. Behavior concerning key/value pairs whose keys are *not* image processor attributes is
                controlled by the `return_unused_kwargs` keyword parameter.

        Returns:
            A image processor of type [`~image_processing_utils.ImageProcessingMixin`].

        Examples:

        ```python
        # We can't instantiate directly the base class *ImageProcessingMixin* so let's show the examples on a
        # derived class: *CLIPImageProcessor*
        image_processor = CLIPImageProcessor.from_pretrained(
            "openai/clip-vit-base-patch32"
        )  # Download image_processing_config from huggingface.co and cache.
        image_processor = CLIPImageProcessor.from_pretrained(
            "./test/saved_model/"
        )  # E.g. image processor (or model) was saved using *save_pretrained('./test/saved_model/')*
        image_processor = CLIPImageProcessor.from_pretrained("./test/saved_model/preprocessor_config.json")
        image_processor = CLIPImageProcessor.from_pretrained(
            "openai/clip-vit-base-patch32", do_normalize=False, foo=False
        )
        assert image_processor.do_normalize is False
        image_processor, unused_kwargs = CLIPImageProcessor.from_pretrained(
            "openai/clip-vit-base-patch32", do_normalize=False, foo=False, return_unused_kwargs=True
        )
        assert image_processor.do_normalize 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FutureWarning
ValueErrorget_image_processor_dict	from_dict)
r9   r:   r;   r<   r=   r>   r?   r2   rB   image_processor_dicts
             r%   from_pretrainedz$ImageProcessingMixin.from_pretrainedc   s    t ({#1 %5!"%z$4d;%MM E   l  #E#F7O'Cs'C'CDa'lek'l$fs}}1<V<<r$   save_directorypush_to_hubc           	      6   |j                  dd      }|<t        j                  dt               |j	                  dd      t        d      ||d<   t        j                  j                  |      rt        d| d      t        j                  |d	       |rr|j                  d
d      }|j                  d|j                  t        j                  j                        d         } | j                  |fi |}| j                  |      }| j                  t!        | ||        t        j                  j#                  |t$              }| j'                  |       t(        j+                  d|        |r%| j-                  ||j	                  d             |gS )as  
        Save an image processor object to the directory `save_directory`, so that it can be re-loaded using the
        [`~image_processing_utils.ImageProcessingMixin.from_pretrained`] class method.

        Args:
            save_directory (`str` or `os.PathLike`):
                Directory where the image processor 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.
        rB   NrC   r>   rD   zProvided path (z#) should be a directory, not a fileT)exist_okcommit_messagerepo_id)configzImage processor saved in )rQ   r>   )r*   rE   rF   rG   getrH   ospathisfileAssertionErrormakedirssplitsep_create_repo_get_files_timestamps_auto_classr   joinr   to_json_filer/   info_upload_modified_files)	r1   rM   rN   r2   rB   rQ   rR   files_timestampsoutput_image_processor_files	            r%   save_pretrainedz$ImageProcessingMixin.save_pretrained   s     $4d;%MM E zz'4(4 l  -F7O77>>.) ?>2BBe!fgg
NT2#ZZ(8$?NjjN,@,@,Mb,QRG'd'':6:G#99.I 't^DA ')ggll>CW&X#56/0K/LMN'' -jj) (  ,,,r$   c                    |j                  dd      }|j                  dd      }|j                  dd      }|j                  dd      }|j                  dd      }|j                  dd      }|j                  d	d      }	|j                  d
d      }
|j                  dd      }|j                  dd      }|j                  dd      }|)t        j                  dt               |t	        d      |}d|d}|||d<   t               r|	st        j                  d       d}	t        |      }t        j                  j                  |      }t        j                  j                  |      r$t        j                  j                  |t              }t        j                  j                  |      r|}d}n6t        |      r|}t!        |      }nt        }	 t#        |||||||	|||
|      }	 t)        |dd      5 }|j+                         }ddd       t-        j.                        }|rt        j                  d |        nt        j                  d  d!|        |s,d"|v rt3        |d"   |      |d"<   d#|v rt5        |d#   |      |d#<   ||fS # t$        $ r  t&        $ r t%        d| d| dt         d      w xY w# 1 sw Y   xY w# t,        j0                  $ r t%        d| d      w xY w)$a  
        From a `pretrained_model_name_or_path`, resolve to a dictionary of parameters, to be used for instantiating a
        image processor of type [`~image_processor_utils.ImageProcessingMixin`] 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.
            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 image processor object.
        r;   Nr<   Fresume_downloadproxiesr>   rB   r=   r?   	subfolder _from_pipeline
_from_autorC   rD   image processor)	file_typefrom_auto_classusing_pipelinez+Offline mode: forcing local_files_only=TrueT)	r;   r<   ri   rh   r=   r>   
user_agentr?   rj   z Can't load image 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 filer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*   rE   rF   rG   rH   r   r/   rb   strrV   rW   isdirr`   r   rX   r   r   r   EnvironmentError	ExceptionopenreadjsonloadsJSONDecodeErrorr   r   )r9   r:   r2   r;   r<   rh   ri   r>   rB   r=   r?   rj   from_pipelinerp   rr   is_localimage_processor_fileresolved_image_processor_filereadertextrK   s                        r%   rI   z-ImageProcessingMixin.get_image_processor_dict  sC   $ JJ{D1	$4e< **%6=**Y-

7D)$4d;!::&8%@::j$/JJ{B/	

#3T: **\59%MM E   l  #E#4Y
$+8J'(%5KKEF#(+,I(J%77==!>?77==67#%77<<0MOc#d 77>>78,I)H89#@ ,89V,W)#7 0;1('#1#$3%5)%'1-4		3S7K %v{{}%#'::d#3  KK56S5TUVKK-.B-C?SpRqr 113M(46S4$Z0 "%99;]();<>[<$%78 $V++Q $   &67T6U V99V8W X//C.DEK % % ## 	"45R4SSno 	s0   J )K 7J<K ,J9<KK #K+rK   c                    |j                         }|j                  dd      }d|v rd|v r|j                  d      |d<   d|v rd|v r|j                  d      |d<    | di |}g }|j                         D ]0  \  }}t        ||      st	        |||       |j                  |       2 |D ]  }|j                  |d        t        j                  d|        |r||fS |S )a  
        Instantiates a type of [`~image_processing_utils.ImageProcessingMixin`] from a Python dictionary of parameters.

        Args:
            image_processor_dict (`Dict[str, Any]`):
                Dictionary that will be used to instantiate the image processor object. Such a dictionary can be
                retrieved from a pretrained checkpoint by leveraging the
                [`~image_processing_utils.ImageProcessingMixin.to_dict`] method.
            kwargs (`Dict[str, Any]`):
                Additional parameters from which to initialize the image processor object.

        Returns:
            [`~image_processing_utils.ImageProcessingMixin`]: The image processor object instantiated from those
            parameters.
        return_unused_kwargsFsize	crop_sizeNzImage processor r#   )copyr*   r,   hasattrr-   appendr/   rb   )r9   rK   r2   r   image_processor	to_remover3   r4   s           r%   rJ   zImageProcessingMixin.from_dict  s   "  488:%zz*@%H
 V*> >+1::f+= (& [4H%H06

;0G -5 45 	 ,,. 	&JC,e4  %	&  	"CJJsD!	" 	&&789"F**""r$   c                 v    t        j                  | j                        }| j                  j                  |d<   |S )z
        Serializes this instance to a Python dictionary.

        Returns:
            `Dict[str, Any]`: Dictionary of all the attributes that make up this image processor instance.
        image_processor_type)r   deepcopy__dict__	__class__r   )r1   outputs     r%   to_dictzImageProcessingMixin.to_dict  s0     t}}-)-)@)@%&r$   	json_filec                     t        |dd      5 }|j                         }ddd       t        j                        } | di |S # 1 sw Y   &xY w)a  
        Instantiates a image processor of type [`~image_processing_utils.ImageProcessingMixin`] 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 image processor of type [`~image_processing_utils.ImageProcessingMixin`]: The image_processor object
            instantiated from that JSON file.
        rs   rt   ru   Nr#   )r}   r~   r   r   )r9   r   r   r   rK   s        r%   from_json_filez#ImageProcessingMixin.from_json_file  sP     )S73 	!v;;=D	!#zz$/*)**	! 	!s   AAc                    | j                         }|j                         D ]3  \  }}t        |t        j                        s!|j                         ||<   5 |j                  dd      }|||d<   t        j                  |dd      dz   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   r,   
isinstancenpndarraytolistr*   r   dumps)r1   
dictionaryr3   r4   r+   s        r%   to_json_stringz#ImageProcessingMixin.to_json_string  s     \\^
$**, 	1JC%,"',,.
3	1 &>>*<dC',<J()zz*Q$?$FFr$   json_file_pathc                     t        |dd      5 }|j                  | j                                ddd       y# 1 sw Y   yxY w)z
        Save this instance to a JSON file.

        Args:
            json_file_path (`str` or `os.PathLike`):
                Path to the JSON file in which this image_processor instance's parameters will be saved.
        wrt   ru   N)r}   writer   )r1   r   writers      r%   ra   z!ImageProcessingMixin.to_json_file  s<     .#8 	0FLL,,./	0 	0 	0s	    8Ac                 T    | j                   j                   d| j                          S )N )r   r   r   )r1   s    r%   __repr__zImageProcessingMixin.__repr__  s(    ..))*!D,?,?,A+BCCr$   c                     t        |t              s|j                  }ddlmc m} t        ||      st        | d      || _        y)a	  
        Register this class with a given auto class. This should only be used for custom image processors as the ones
        in the library are already mapped with `AutoImageProcessor `.

        <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 `"AutoImageProcessor "`):
                The auto class to register this new image processor with.
        r   Nz is not a valid auto class.)	r   ry   r   transformers.models.automodelsautor   rH   r_   )r9   
auto_classauto_modules      r%   register_for_auto_classz,ImageProcessingMixin.register_for_auto_class  sC      *c*#,,J66{J/
|+FGHH$r$   image_url_or_urlsc                 `   ddi}t        |t              r|D cg c]  }| j                  |       c}S t        |t              rPt	        j
                  |d|      }|j                          t        j                  t        |j                              S t        dt        |             c c}w )z
        Convert a single or a list of urls into the corresponding `PIL.Image` objects.

        If a single url is passed, the return value will be a single object. If a list is passed a list of objects is
        returned.
        z
User-AgentzuMozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36T)streamheadersz=only a single or a list of entries is supported but got type=)r   listfetch_imagesry   requestsrU   raise_for_statusr   r}   r   content	TypeErrortype)r1   r   r   xresponses        r%   r   z!ImageProcessingMixin.fetch_images  s     !
 '.2CDQD%%a(DD)3/||$5dGTH%%'::gh&6&6788[\`ar\s[tuvv Es   B+)NFFNmain)F)AutoImageProcessor)r   r    r!   r"   r_   r6   ry   r8   classmethodr	   r   r   rV   PathLiker   boolrL   rf   r   r   r   rI   rJ   r   r   r   ra   r   r   r   r   r#   r$   r%   r   r   H   s   
 K0C 0  8<$!&,0o=$%o=',S"++-='>o= E#r{{"234o= 	o=
 o= c4i()o= o= 
o= o=b;-eC4D.E ;-TX ;-z t,,1#r{{2B,Ct,	tCH~tCH~-	.t, t,l *#T#s(^ *# *#X
c3h 
 +uS"++-='> + +$G G*	05bkk1A+B 	0D % %2weCcN.C wr$   rn   r   zimage processor file)objectobject_classobject_files)-r   r   rV   rE   ior   typingr   r   r   r   r   r	   r
   r   numpyr   r   dynamic_module_utilsr   feature_extraction_utilsr   BaseBatchFeatureutilsr   r   r   r   r   r   r   r   r   r   r   PILr   r   
get_loggerr   r/   r   rN   r"   formatr#   r$   r%   <module>r      s   "   	   I I I   4 F     19OP  
		H	%
#  ^w> ^wB $--A-M-M#N   ##++7/C/O/O/W/W/^/^ /CRh 0_ 0$$, 8r$   