




"""simple docstring"""
import os
import string
import sys


a_				:    int										=     1 << 8

a_				:    Tuple										=     {
    '''tab''': ord('''\t'''),
    '''newline''': ord('''\r'''),
    '''esc''': 27,
    '''up''': 65 + ARROW_KEY_FLAG,
    '''down''': 66 + ARROW_KEY_FLAG,
    '''right''': 67 + ARROW_KEY_FLAG,
    '''left''': 68 + ARROW_KEY_FLAG,
    '''mod_int''': 91,
    '''undefined''': sys.maxsize,
    '''interrupt''': 3,
    '''insert''': 50,
    '''delete''': 51,
    '''pg_up''': 53,
    '''pg_down''': 54,
}

a_				:    List[str]										=     KEYMAP['''up''']
a_				:    Dict										=     KEYMAP['''left''']

if sys.platform == "win32":
					a_				:    List[str]										=     []
					a_				:    Dict										=     {
					    b'''\xe0H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
					    b'''\x00H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
					    b'''\xe0P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
					    b'''\x00P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
					    b'''\xe0M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
					    b'''\x00M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
					    b'''\xe0K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
					    b'''\x00K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
					}

for i in range(10):
					a_				:    Tuple										=     ord(str(i))





def 						UpperCAmelCase				(			)  ->     Union[str, Any]:
			if os.name == "nt":
						import msvcrt

						__lowerCamelCase					:	Union[str, Any]	       =				'mbcs'
						# Flush the keyboard buffer
						while msvcrt.kbhit():
									msvcrt.getch()
						if len(A__     ) == 0:
									# Read the keystroke
									__lowerCamelCase					:	Any	       =				msvcrt.getch()

									# If it is a prefix char, get second part
									if ch in (b"\x00", b"\xe0"):
												__lowerCamelCase					:	Optional[Any]	       =				ch + msvcrt.getch()
												# Translate actual Win chars to bullet char types
												try:
															__lowerCamelCase					:	Optional[int]	       =				chr(WIN_KEYMAP[cha]     )
															WIN_CH_BUFFER.append(chr(KEYMAP['mod_int']     )     )
															WIN_CH_BUFFER.append(A__     )
															if ord(A__     ) in (
															    KEYMAP["insert"] - 1 << 9,
															    KEYMAP["delete"] - 1 << 9,
															    KEYMAP["pg_up"] - 1 << 9,
															    KEYMAP["pg_down"] - 1 << 9,
															):
																		WIN_CH_BUFFER.append(chr(126     )     )
															__lowerCamelCase					:	Tuple	       =				chr(KEYMAP['esc']     )
												except KeyError:
															__lowerCamelCase					:	List[Any]	       =				cha[1]
									else:
												__lowerCamelCase					:	str	       =				ch.decode(A__     )
						else:
									__lowerCamelCase					:	Any	       =				WIN_CH_BUFFER.pop(0     )
			elif os.name == "posix":
						import termios
						import tty

						__lowerCamelCase					:	Tuple	       =				sys.stdin.fileno()
						__lowerCamelCase					:	Union[str, Any]	       =				termios.tcgetattr(A__     )
						try:
									tty.setraw(A__     )
									__lowerCamelCase					:	str	       =				sys.stdin.read(1     )
						finally:
									termios.tcsetattr(A__							,				termios.TCSADRAIN							,				A__     )
			return ch






def 						UpperCAmelCase				(			)  ->     str:
			__lowerCamelCase					:	Optional[Any]	       =				get_raw_chars()
			if ord(A__     ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
						return char

			elif ord(A__     ) == KEYMAP["esc"]:
						__lowerCamelCase					:	Dict	       =				get_raw_chars()
						if ord(A__     ) == KEYMAP["mod_int"]:
									__lowerCamelCase					:	List[str]	       =				get_raw_chars()
									if ord(A__     ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(A__     ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
												return chr(ord(A__     ) + ARROW_KEY_FLAG     )
									else:
												return KEYMAP["undefined"]
						else:
									return get_raw_chars()

			else:
						if char in string.printable:
									return char
						else:
									return KEYMAP["undefined"]









"""simple docstring"""
from typing import TYPE_CHECKING

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


a_				:    List[Any]										=     {
    '''configuration_encodec''': [
        '''ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''EncodecConfig''',
    ],
    '''feature_extraction_encodec''': ['''EncodecFeatureExtractor'''],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					a_				:    int										=     [
					    '''ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''EncodecModel''',
					    '''EncodecPreTrainedModel''',
					]

if TYPE_CHECKING:
					from .configuration_encodec import (
					    ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    EncodecConfig,
					)
					from .feature_extraction_encodec import EncodecFeatureExtractor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_encodec import (
										    ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST,
										    EncodecModel,
										    EncodecPreTrainedModel,
										)

else:
					import sys

					a_				:    Tuple										=     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



