

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

from packaging import version


__A      		=     {
    '''<''': operator.lt,
    '''<=''': operator.le,
    '''==''': operator.eq,
    '''!=''': operator.ne,
    '''>=''': operator.ge,
    '''>''': operator.gt,
}



def 				snake_case_(_UpperCamelCase			,	_UpperCamelCase			,	_UpperCamelCase			,	_UpperCamelCase			,	_UpperCamelCase			,	_UpperCamelCase					)							->     Optional[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 				snake_case_(_UpperCamelCase			,	_UpperCamelCase = None					)							->     List[str]:



		"""simple docstring"""






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

		# non-versioned check
		if re.match(R'''^[\w_\-\d]+$'''			,	_a					):
				_snake_case						=							requirement, None, None
		else:
				_snake_case						=							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}"""					)
				_snake_case						=							match[0]
				_snake_case						=							want_full.split(''','''					)  # there could be multiple requirements
				_snake_case						=							{}
				for w in want_range:
						_snake_case						=							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}"""					)
						_snake_case						=							match[0]
						_snake_case						=							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":
				_snake_case						=							".".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:
				_snake_case						=							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 				snake_case_(_UpperCamelCase					)							->     Tuple:



		"""simple docstring"""






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




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__A      		=     {
    '''configuration_falcon''': ['''FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FalconConfig'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A      		=     [
     '''FALCON_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''FalconForCausalLM''',
     '''FalconModel''',
     '''FalconPreTrainedModel''',
     '''FalconForSequenceClassification''',
     '''FalconForTokenClassification''',
     '''FalconForQuestionAnswering''',
 ]


if TYPE_CHECKING:
 from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_falcon import (
      FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
      FalconForCausalLM,
      FalconForQuestionAnswering,
      FalconForSequenceClassification,
      FalconForTokenClassification,
      FalconModel,
      FalconPreTrainedModel,
  )


else:
 import sys

 __A      		=     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

