


'''simple docstring'''

from typing import TYPE_CHECKING

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


lowerCAmelCase :Tuple             =     {
    'configuration_funnel': ['FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FunnelConfig'],
    'convert_funnel_original_tf_checkpoint_to_pytorch': [],
    'tokenization_funnel': ['FunnelTokenizer'],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase :Union[str, Any]             =     ['FunnelTokenizerFast']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase :List[str]             =     [
							    'FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'FunnelBaseModel',
							    'FunnelForMaskedLM',
							    'FunnelForMultipleChoice',
							    'FunnelForPreTraining',
							    'FunnelForQuestionAnswering',
							    'FunnelForSequenceClassification',
							    'FunnelForTokenClassification',
							    'FunnelModel',
							    'FunnelPreTrainedModel',
							    'load_tf_weights_in_funnel',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase :Optional[Any]             =     [
							    'TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'TFFunnelBaseModel',
							    'TFFunnelForMaskedLM',
							    'TFFunnelForMultipleChoice',
							    'TFFunnelForPreTraining',
							    'TFFunnelForQuestionAnswering',
							    'TFFunnelForSequenceClassification',
							    'TFFunnelForTokenClassification',
							    'TFFunnelModel',
							    'TFFunnelPreTrainedModel',
							]


if TYPE_CHECKING:
							from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig
							from .tokenization_funnel import FunnelTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_funnel_fast import FunnelTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_funnel import (
														    FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
														    FunnelBaseModel,
														    FunnelForMaskedLM,
														    FunnelForMultipleChoice,
														    FunnelForPreTraining,
														    FunnelForQuestionAnswering,
														    FunnelForSequenceClassification,
														    FunnelForTokenClassification,
														    FunnelModel,
														    FunnelPreTrainedModel,
														    load_tf_weights_in_funnel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_funnel import (
														    TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFFunnelBaseModel,
														    TFFunnelForMaskedLM,
														    TFFunnelForMultipleChoice,
														    TFFunnelForPreTraining,
														    TFFunnelForQuestionAnswering,
														    TFFunnelForSequenceClassification,
														    TFFunnelForTokenClassification,
														    TFFunnelModel,
														    TFFunnelPreTrainedModel,
														)

else:
							import sys

							lowerCAmelCase :List[Any]             =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






import enum
import shutil
import sys


a__   ,				a__      :     int         =		shutil.get_terminal_size()

a__      :     Tuple         =		{'UP': 'A', 'DOWN': 'B', 'RIGHT': 'C', 'LEFT': 'D'}





class UpperCAmelCase_				( enum.Enum ):
  __lowerCAmelCase   :						int							=   0
  __lowerCAmelCase   :						Optional[int]							=   1




def      UpperCAmelCase_    (    _UpperCAmelCase							:Optional[int]  ,						_UpperCAmelCase							:int=""				)	->				str:
     '''simple docstring'''


     sys.stdout.write(str(_UpperCAmelCase				) + end				)
     sys.stdout.flush()

def      UpperCAmelCase_    (    _UpperCAmelCase							:Union[str, Any]  ,						_UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:Tuple=""				)	->				List[Any]:
     '''simple docstring'''


     forceWrite(f'\u001b[{color}m{content}\u001b[0m'  ,						_UpperCAmelCase				)

def      UpperCAmelCase_    (    )	->				Dict:
     '''simple docstring'''


     forceWrite('''\r'''				)

def      UpperCAmelCase_    (    _UpperCAmelCase							:int  ,						_UpperCAmelCase							:str				)	->				List[Any]:
     '''simple docstring'''


     forceWrite(f'\033[{num_lines}{CURSOR_TO_CHAR[direction.upper()]}'				)

def      UpperCAmelCase_    (    )	->				List[Any]:
     '''simple docstring'''


     forceWrite(''' ''' * TERMINAL_WIDTH				)
     reset_cursor()


def      UpperCAmelCase_    (    )	->				Tuple:
     '''simple docstring'''


     reset_cursor()
     forceWrite('''-''' * TERMINAL_WIDTH				)



