


import os
import sys

__UpperCamelCase    :						List[str]     =							os.path.join(os.path.dirname(__file__), 'src')
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


__UpperCamelCase    :						Union[str, Any]     =							[
    'torch',
    'numpy',
    'tokenizers',
    'filelock',
    'requests',
    'tqdm',
    'regex',
    'sentencepiece',
    'sacremoses',
    'importlib_metadata',
    'huggingface_hub',
]





@add_start_docstrings(AutoConfig.__doc__      )
def   _UpperCAmelCase       (     *UpperCAmelCase      :			Tuple						,	**UpperCAmelCase      :			Tuple      ):
      """simple docstring"""




      return AutoConfig.from_pretrained(*UpperCAmelCase						,	**UpperCAmelCase      )





@add_start_docstrings(AutoTokenizer.__doc__      )
def   _UpperCAmelCase       (     *UpperCAmelCase      :			Any						,	**UpperCAmelCase      :			Any      ):
      """simple docstring"""




      return AutoTokenizer.from_pretrained(*UpperCAmelCase						,	**UpperCAmelCase      )





@add_start_docstrings(AutoModel.__doc__      )
def   _UpperCAmelCase       (     *UpperCAmelCase      :			str						,	**UpperCAmelCase      :			Optional[Any]      ):
      """simple docstring"""




      return AutoModel.from_pretrained(*UpperCAmelCase						,	**UpperCAmelCase      )





@add_start_docstrings(AutoModelForCausalLM.__doc__      )
def   _UpperCAmelCase       (     *UpperCAmelCase      :			Tuple						,	**UpperCAmelCase      :			str      ):
      """simple docstring"""




      return AutoModelForCausalLM.from_pretrained(*UpperCAmelCase						,	**UpperCAmelCase      )





@add_start_docstrings(AutoModelForMaskedLM.__doc__      )
def   _UpperCAmelCase       (     *UpperCAmelCase      :			Optional[Any]						,	**UpperCAmelCase      :			Dict      ):
      """simple docstring"""




      return AutoModelForMaskedLM.from_pretrained(*UpperCAmelCase						,	**UpperCAmelCase      )





@add_start_docstrings(AutoModelForSequenceClassification.__doc__      )
def   _UpperCAmelCase       (     *UpperCAmelCase      :			Union[str, Any]						,	**UpperCAmelCase      :			Dict      ):
      """simple docstring"""




      return AutoModelForSequenceClassification.from_pretrained(*UpperCAmelCase						,	**UpperCAmelCase      )





@add_start_docstrings(AutoModelForQuestionAnswering.__doc__      )
def   _UpperCAmelCase       (     *UpperCAmelCase      :			List[Any]						,	**UpperCAmelCase      :			Optional[Any]      ):
      """simple docstring"""




      return AutoModelForQuestionAnswering.from_pretrained(*UpperCAmelCase						,	**UpperCAmelCase      )







def   _UpperCAmelCase       (     UpperCAmelCase      :			str      ):
      """simple docstring"""




      __lowerCamelCase     :      List[Any]       						=						hex_num.strip()
      if not hex_num:
            raise ValueError("""No value was passed to the function"""      )

      __lowerCamelCase     :      Dict       						=						hex_num[0] == """-"""
      if is_negative:
            __lowerCamelCase     :      Optional[Any]       						=						hex_num[1:]

      try:
            __lowerCamelCase     :      Any       						=						int(UpperCAmelCase						,	16      )
      except ValueError:
            raise ValueError("""Invalid value was passed to the function"""      )

      __lowerCamelCase     :      List[str]       						=						""""""
      while int_num > 0:
            __lowerCamelCase     :      Dict       						=						str(int_num % 2      ) + bin_str
            int_num >>= 1

      return int(("""-""" + bin_str) if is_negative else bin_str      )


if __name__ == "__main__":
    import doctest

    doctest.testmod()



