




import importlib.metadata
import operator
import re
import sys
from typing import Optional

from packaging import version


__lowerCAmelCase		:				Union[str, Any]       			=		{
    '<': operator.lt,
    '<=': operator.le,
    '==': operator.eq,
    '!=': operator.ne,
    '>=': operator.ge,
    '>': operator.gt,
}




def 			__magic_name__				( A		:					List[Any],  A		:					List[Any],  A		:					str,  A		:					List[str],  A		:					Optional[Any],  A		:					Union[str, Any]   ):






			'''simple docstring'''







			if got_ver is None or want_ver is None:
						raise ValueError(
						    F"""Unable to compare versions for {requirement}: need={want_ver} found={got_ver}. This is unusual. Consider"""
						    F""" reinstalling {pkg}."""   )
			if not ops[op](version.parse(A   ),  version.parse(A   )   ):
						raise ImportError(
						    F"""{requirement} is required for a normal functioning of this module, but found {pkg}=={got_ver}.{hint}"""   )




def 			__magic_name__				( A		:					str,  A		:					Optional[str] = None   ):






			'''simple docstring'''







			a    =			F"""\n{hint}""" if hint is not None else ""

			# non-versioned check
			if re.match(R"^[\w_\-\d]+$",  A   ):
						a    ,		a    ,		a    =			requirement, None, None
			else:
						a    =			re.findall(R"^([^!=<>\s]+)([\s!=<>]{1,2}.+)",  A   )
						if not match:
									raise ValueError(
									    "requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23, but"
									    F""" got {requirement}"""   )
						a    ,		a    =			match[0]
						a    =			want_full.split(","   )  # there could be multiple requirements
						a    =			{}
						for w in want_range:
									a    =			re.findall(R"^([\s!=<>]{1,2})(.+)",  A   )
									if not match:
												raise ValueError(
												    "requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23,"
												    F""" but got {requirement}"""   )
									a    ,		a    =			match[0]
									a    =			want_ver
									if op not in ops:
												raise ValueError(F"""{requirement}: need one of {list(ops.keys()   )}, but got {op}"""   )

    # special case
			if pkg == "python":
						a    =			".".join([str(A   ) for x in sys.version_info[:3]]   )
						for op, want_ver in wanted.items():
									_compare_versions(A,  A,  A,  A,  A,  A   )
						return

			# check if any version is installed
			try:
						a    =			importlib.metadata.version(A   )
			except importlib.metadata.PackageNotFoundError:
						raise importlib.metadata.PackageNotFoundError(
						    F"""The '{requirement}' distribution was not found and is required by this application. {hint}"""   )

			# check that the right version is installed if version number or a range was provided
			if want_ver is not None:
						for op, want_ver in wanted.items():
									_compare_versions(A,  A,  A,  A,  A,  A   )






def 			__magic_name__				( A		:					Optional[int]   ):






			'''simple docstring'''







			a    =			"Try: pip install transformers -U or pip install -e '.[dev]' if you're working with git main"
			return require_version(A,  A   )












from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)






