






"""simple docstring"""





import os
import warnings
from pathlib import Path
from typing import Optional, Union

from .dynamic_module_utils import custom_object_save
from .tokenization_utils_base import PreTrainedTokenizerBase
from .utils import PushToHubMixin, copy_func, direct_transformers_import, logging


UpperCamelCase_						:					Tuple      				=			logging.get_logger(__name__)

# Dynamically import the Transformers module to grab the attribute classes of the processor form their names.
UpperCamelCase_						:					List[str]      				=			direct_transformers_import(Path(__file__).parent)


UpperCamelCase_						:					Optional[int]      				=			{
    """AutoTokenizer""": """PreTrainedTokenizerBase""",
    """AutoFeatureExtractor""": """FeatureExtractionMixin""",
    """AutoImageProcessor""": """ImageProcessingMixin""",
}


class   _lowercase			(  lowerCAmelCase    ):
      _a :  int										= ['''feature_extractor''', '''tokenizer''']
      # Names need to be attr_class for attr in attributes
      _a :  Any										= None
      _a :  Dict										= None
      _a :  Dict										= None


      def __init__(     self					:						Union[str, Any]				, *a					:						str				, **a					:						str    ):





            """simple docstring"""







            for key in kwargs:
                  if key not in self.attributes:
                        raise TypeError(f'''Unexpected keyword argument {key}.'''    )
            for arg, attribute_name in zip(a				, self.attributes    ):
                  if attribute_name in kwargs:
                        raise TypeError(f'''Got multiple values for argument {attribute_name}.'''    )
                  else:
                        __snake_case   :     Union[str, Any]	      =arg

            if len(a    ) != len(self.attributes    ):
                  raise ValueError(
                      f'''This processor requires {len(self.attributes    )} arguments: {", ".join(self.attributes    )}. Got '''
                      f'''{len(a    )} arguments instead.'''    )

            # Check each arg is of the proper class (this will also catch a user initializing in the wrong order)
            for attribute_name, arg in kwargs.items():
                  __snake_case   :     Tuple	      =getattr(self				, f'''{attribute_name}_class'''    )
                  # Nothing is ever going to be an instance of "AutoXxx", in that case we check the base class.
                  __snake_case   :     int	      =AUTO_TO_BASE_CLASS_MAPPING.get(a				, a    )
                  if isinstance(a				, a    ):
                        __snake_case   :     Optional[Any]	      =tuple(getattr(a				, a    ) for n in class_name if n is not None    )
                  else:
                        __snake_case   :     Any	      =getattr(a				, a    )

                  if not isinstance(a				, a    ):
                        raise ValueError(
                            f'''Received a {type(a    ).__name__} for argument {attribute_name}, but a {class_name} was expected.'''    )

                  setattr(self				, a				, a    )


      def __repr__(     self					:						Union[str, Any]    ):





            """simple docstring"""







            __snake_case   :     Union[str, Any]	      =[f'''- {name}: {repr(getattr(self				, a    )    )}''' for name in self.attributes]
            __snake_case   :     Optional[int]	      ='''\n'''.join(a    )
            return f'''{self.__class__.__name__}:\n{attributes_repr}'''


      def _UpperCamelCase    (     self					:						Tuple				, a					:						Union[str, Any]				, a					:						bool = False				, **a					:						Union[str, Any]    ):





            """simple docstring"""







            os.makedirs(a				, exist_ok=a    )

            if push_to_hub:
                  __snake_case   :     Dict	      =kwargs.pop('''commit_message'''				, a    )
                  __snake_case   :     Tuple	      =kwargs.pop('''repo_id'''				, save_directory.split(os.path.sep    )[-1]    )
                  __snake_case   :     Any	      =self._create_repo(a				, **a    )
                  __snake_case   :     Optional[Any]	      =self._get_files_timestamps(a    )
            # If we have a custom config, we copy the file defining it in the folder and set the attributes so it can be
            # loaded from the Hub.
            if self._auto_class is not None:
                  __snake_case   :     List[Any]	      =[getattr(self				, a    ) for attribute_name in self.attributes]
                  __snake_case   :     Tuple	      =[(a.init_kwargs if isinstance(a				, a    ) else a) for a in attrs]
                  custom_object_save(self				, a				, config=a    )

            for attribute_name in self.attributes:
                  __snake_case   :     str	      =getattr(self				, a    )
                  # Include the processor class in the attribute config so this processor can then be reloaded with the
                  # `AutoProcessor` API.
                  if hasattr(a				, '''_set_processor_class'''    ):
                        attribute._set_processor_class(self.__class__.__name__    )
                  attribute.save_pretrained(a    )

            if self._auto_class is not None:
                  # We added an attribute to the init_kwargs of the tokenizers, which needs to be cleaned up.
                  for attribute_name in self.attributes:
                        __snake_case   :     str	      =getattr(self				, a    )
                        if isinstance(a				, a    ):
                              del attribute.init_kwargs["auto_map"]

            if push_to_hub:
                  self._upload_modified_files(
                      a				, a				, a				, commit_message=a				, token=kwargs.get('''use_auth_token'''    )				, )


      @classmethod
      def _UpperCamelCase    (     cls					:						Optional[Any]				, a					:						Union[str, os.PathLike]				, a					:						Optional[Union[str, os.PathLike]] = None				, a					:						bool = False				, a					:						bool = False				, a					:						Optional[Union[str, bool]] = None				, a					:						str = "main"				, **a					:						Any				, ):





            """simple docstring"""







            __snake_case   :     Dict	      =cache_dir
            __snake_case   :     Tuple	      =force_download
            __snake_case   :     Union[str, Any]	      =local_files_only
            __snake_case   :     Optional[int]	      =revision

            __snake_case   :     Union[str, Any]	      =kwargs.pop('''use_auth_token'''				, a    )
            if use_auth_token is not None:
                  warnings.warn(
                      '''The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers.'''				, a    )
                  if token is not None:
                        raise ValueError(
                            '''`token` and `use_auth_token` are both specified. Please set only the argument `token`.'''    )
                  __snake_case   :     Tuple	      =use_auth_token

            if token is not None:
                  # change to `token` in a follow-up PR
                  __snake_case   :     Optional[Any]	      =token

            __snake_case   :     Dict	      =cls._get_arguments_from_pretrained(a				, **a    )
            return cls(*a    )


      @classmethod
      def _UpperCamelCase    (     cls					:						str				, a					:						str="AutoProcessor"    ):





            """simple docstring"""







            if not isinstance(a				, a    ):
                  __snake_case   :     str	      =auto_class.__name__

            import transformers.models.auto as auto_module

            if not hasattr(a				, a    ):
                  raise ValueError(f'''{auto_class} is not a valid auto class.'''    )

            __snake_case   :     Union[str, Any]	      =auto_class


      @classmethod
      def _UpperCamelCase    (     cls					:						Optional[Any]				, a					:						List[str]				, **a					:						Any    ):





            """simple docstring"""







            __snake_case   :     str	      =[]
            for attribute_name in cls.attributes:
                  __snake_case   :     Optional[int]	      =getattr(cls				, f'''{attribute_name}_class'''    )
                  if isinstance(a				, a    ):
                        __snake_case   :     Union[str, Any]	      =tuple(getattr(a				, a    ) if n is not None else None for n in class_name    )
                        __snake_case   :     int	      =kwargs.get('''use_fast'''				, a    )
                        if use_fast and classes[1] is not None:
                              __snake_case   :     Union[str, Any]	      =classes[1]
                        else:
                              __snake_case   :     Optional[int]	      =classes[0]
                  else:
                        __snake_case   :     Any	      =getattr(a				, a    )

                  args.append(attribute_class.from_pretrained(a				, **a    )    )
            return args







      @property
      def _UpperCamelCase    (     self					:						str    ):





            """simple docstring"""







            __snake_case   :     Optional[Any]	      =getattr(self				, self.attributes[0]    )
            return getattr(a				, '''model_input_names'''				, a    )



UpperCamelCase_						:					Optional[Any]      				=			copy_func(ProcessorMixin.push_to_hub)
if ProcessorMixin.push_to_hub.__doc__ is not None:
    UpperCamelCase_						:					List[Any]      				=			ProcessorMixin.push_to_hub.__doc__.format(
        object="""processor""", object_class="""AutoProcessor""", object_files="""processor files"""
    )










"""simple docstring"""





import numpy as np



def      __lowercase       (     a			:					Union[str, Any]							,		a			:					Optional[Any]							,		a			:					List[str]			)       ->       Dict:
      __snake_case   :     Dict	      =n_draws * class_counts / class_counts.sum()
      # floored means we don't overshoot n_samples, but probably undershoot
      __snake_case   :     int	      =np.floor(a			)
      # we add samples according to how much "left over" probability
      # they had, until we arrive at n_samples
      __snake_case   :     Dict	      =int(n_draws - floored.sum()			)
      if need_to_add > 0:
            __snake_case   :     List[str]	      =continuous - floored
            __snake_case   :     str	      =np.sort(np.unique(a			)			)[::-1]
            # add according to remainder, but break ties
            # randomly to avoid biases
            for value in values:
                  ((__snake_case)      ,					)   :     Tuple	      =np.where(remainder == value			)
                  # if we need_to_add less than what's in inds
                  # we draw randomly from them.
                  # if we need to add more, we add them all and
                  # go to the next value
                  __snake_case   :     int	      =min(len(a			)							,		a			)
                  __snake_case   :     Any	      =rng.choice(a							,		size=a							,		replace=a			)
                  floored[inds] += 1
                  need_to_add -= add_now
                  if need_to_add == 0:
                        break
      return floored.astype(np.intaa			)



def      __lowercase       (     a			:					Any							,		a			:					str							,		a			:					Dict							,		a			:					Union[str, Any]							,		a			:					Union[str, Any]=10			)       ->       Any:
      __snake_case      ,					__snake_case   :     int	      =np.unique(a							,		return_inverse=a			)
      __snake_case   :     Dict	      =classes.shape[0]
      __snake_case   :     int	      =np.bincount(a			)
      if np.min(a			) < 2:
            raise ValueError('''Minimum class count error'''			)
      if n_train < n_classes:
            raise ValueError(
                '''The train_size = %d should be greater or ''' '''equal to the number of classes = %d''' % (n_train, n_classes)			)
      if n_test < n_classes:
            raise ValueError(
                '''The test_size = %d should be greater or ''' '''equal to the number of classes = %d''' % (n_test, n_classes)			)
      __snake_case   :     str	      =np.split(np.argsort(a							,		kind='''mergesort'''			)							,		np.cumsum(a			)[:-1]			)
      for _ in range(a			):
            __snake_case   :     str	      =approximate_mode(a							,		a							,		a			)
            __snake_case   :     List[str]	      =class_counts - n_i
            __snake_case   :     Union[str, Any]	      =approximate_mode(a							,		a							,		a			)

            __snake_case   :     int	      =[]
            __snake_case   :     Union[str, Any]	      =[]

            for i in range(a			):
                  __snake_case   :     Union[str, Any]	      =rng.permutation(class_counts[i]			)
                  __snake_case   :     Dict	      =class_indices[i].take(a							,		mode='''clip'''			)
                  train.extend(perm_indices_class_i[: n_i[i]]			)
                  test.extend(perm_indices_class_i[n_i[i] : n_i[i] + t_i[i]]			)
            __snake_case   :     Any	      =rng.permutation(a			)
            __snake_case   :     int	      =rng.permutation(a			)

            yield train, test


