

import os
import pathlib
import tempfile
import uuid

import numpy as np

from ..utils import is_soundfile_availble, is_torch_available, is_vision_available, logging


lowerCAmelCase_	     =      logging.get_logger(__name__)

if is_vision_available():
					import PIL.Image
					from PIL import Image
					from PIL.Image import Image as ImageType
else:
					lowerCAmelCase_	     =      object

if is_torch_available():
					import torch

if is_soundfile_availble():
					import soundfile as sf





class      snake_case_       :







			'''simple docstring'''

			def __init__(					self			:    List[Any]							,       _UpperCamelCase			:    Union[str, Any]							)				->str:
									snake_case_       =     value







			def __str__(					self			:    Optional[int]							)				->int:
									return self.to_string()







			def     snake_case__(					self			:    Optional[int]							)				->List[str]:
									logger.error(
									    '''This is a raw AgentType of unknown type. Display in notebooks and string conversion will be unreliable'''							)
									return self._value







			def     snake_case__(					self			:    List[str]							)				->str:
									logger.error(
									    '''This is a raw AgentType of unknown type. Display in notebooks and string conversion will be unreliable'''							)
									return str(self._value							)






class      snake_case_       (		__A     ,	__A ):







			'''simple docstring'''

			def     snake_case__(					self			:    Dict							)				->Dict:
									return self._value







			def     snake_case__(					self			:    Tuple							)				->Optional[int]:
									return self._value






class      snake_case_       (		__A     ,	__A ):







			'''simple docstring'''

			def __init__(					self			:    Optional[Any]							,       _UpperCamelCase			:    Tuple							)				->List[str]:
									super().__init__(_UpperCamelCase							)

									if not is_vision_available():
															raise ImportError('''PIL must be installed in order to handle images.'''							)

									snake_case_       =     None
									snake_case_       =     None
									snake_case_       =     None

									if isinstance(_UpperCamelCase							,       _UpperCamelCase							):
															snake_case_       =     value
									elif isinstance(_UpperCamelCase							,       (str, pathlib.Path)							):
															snake_case_       =     value
									elif isinstance(_UpperCamelCase							,       torch.Tensor							):
															snake_case_       =     value
									else:
															raise ValueError(f'''Unsupported type for {self.__class__.__name__}: {type(_UpperCamelCase							)}'''							)







			def     snake_case__(					self			:    int							,       _UpperCamelCase			:    int=None							,       _UpperCamelCase			:    int=None							)				->List[Any]:
									from IPython.display import Image, display

									display(Image(self.to_string()							)							)







			def     snake_case__(					self			:    Optional[Any]							)				->Optional[int]:
									if self._raw is not None:
															return self._raw

									if self._path is not None:
															snake_case_       =     Image.open(self._path							)
															return self._raw







			def     snake_case__(					self			:    str							)				->Tuple:
									if self._path is not None:
															return self._path

									if self._raw is not None:
															snake_case_       =     tempfile.mkdtemp()
															snake_case_       =     os.path.join(_UpperCamelCase							,       str(uuid.uuida()							) + '''.png'''							)
															self._raw.save(self._path							)

															return self._path

									if self._tensor is not None:
															snake_case_       =     self._tensor.cpu().detach().numpy()

															# There is likely simpler than load into image into save
															snake_case_       =     Image.fromarray((array * 2_5_5).astype(np.uinta							)							)

															snake_case_       =     tempfile.mkdtemp()
															snake_case_       =     os.path.join(_UpperCamelCase							,       str(uuid.uuida()							) + '''.png'''							)

															img.save(self._path							)

															return self._path






class      snake_case_       (		__A ):







			'''simple docstring'''

			def __init__(					self			:    Union[str, Any]							,       _UpperCamelCase			:    str							,       _UpperCamelCase			:    Any=1_6_0_0_0							)				->str:
									super().__init__(_UpperCamelCase							)

									if not is_soundfile_availble():
															raise ImportError('''soundfile must be installed in order to handle audio.'''							)

									snake_case_       =     None
									snake_case_       =     None

									snake_case_       =     samplerate

									if isinstance(_UpperCamelCase							,       (str, pathlib.Path)							):
															snake_case_       =     value
									elif isinstance(_UpperCamelCase							,       torch.Tensor							):
															snake_case_       =     value
									else:
															raise ValueError(f'''Unsupported audio type: {type(_UpperCamelCase							)}'''							)







			def     snake_case__(					self			:    Dict							,       _UpperCamelCase			:    int=None							,       _UpperCamelCase			:    Optional[int]=None							)				->List[str]:
									from IPython.display import Audio, display

									display(Audio(self.to_string()							,       rate=self.samplerate							)							)







			def     snake_case__(					self			:    Optional[int]							)				->List[Any]:
									if self._tensor is not None:
															return self._tensor

									if self._path is not None:
															snake_case_,   snake_case_       =     sf.read(self._path							)
															snake_case_       =     torch.tensor(_UpperCamelCase							)
															return self._tensor







			def     snake_case__(					self			:    Union[str, Any]							)				->List[str]:
									if self._path is not None:
															return self._path

									if self._tensor is not None:
															snake_case_       =     tempfile.mkdtemp()
															snake_case_       =     os.path.join(_UpperCamelCase							,       str(uuid.uuida()							) + '''.wav'''							)
															sf.write(self._path							,       self._tensor							,       samplerate=self.samplerate							)
															return self._path






lowerCAmelCase_	     =      {'''text''': AgentText, '''image''': AgentImage, '''audio''': AgentAudio}
lowerCAmelCase_	     =      {str: AgentText}

if is_vision_available():
					lowerCAmelCase_	     =      AgentImage


def   __SCREAMING_SNAKE_CASE (*SCREAMING_SNAKE_CASE__  ,		**SCREAMING_SNAKE_CASE__	):
						snake_case_       =     [(arg.to_raw() if isinstance(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__	) else arg) for arg in args]
						snake_case_       =     {k: (v.to_raw() if isinstance(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__	) else v) for k, v in kwargs.items()}
						return args, kwargs


def   __SCREAMING_SNAKE_CASE (SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__=None	):
						if isinstance(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__	):
												snake_case_       =     {}
												for i, (k, v) in enumerate(outputs.items()	):
																		if output_types is not None:
																								# If the class has defined outputs, we can map directly according to the class definition
																								if output_types[i] in AGENT_TYPE_MAPPING:
																														snake_case_       =     AGENT_TYPE_MAPPING[output_types[i]](SCREAMING_SNAKE_CASE__	)
																								else:
																														snake_case_       =     AgentType(SCREAMING_SNAKE_CASE__	)

																		else:
																								# If the class does not have defined output, then we map according to the type
																								for _k, _v in INSTANCE_TYPE_MAPPING.items():
																														if isinstance(SCREAMING_SNAKE_CASE__  ,		_k	):
																																				snake_case_       =     _v(SCREAMING_SNAKE_CASE__	)
																								if k not in decoded_outputs:
																														snake_case_       =     AgentType[v]

						elif isinstance(SCREAMING_SNAKE_CASE__  ,		(list, tuple)	):
												snake_case_       =     type(SCREAMING_SNAKE_CASE__	)()
												for i, v in enumerate(SCREAMING_SNAKE_CASE__	):
																		if output_types is not None:
																								# If the class has defined outputs, we can map directly according to the class definition
																								if output_types[i] in AGENT_TYPE_MAPPING:
																														decoded_outputs.append(AGENT_TYPE_MAPPING[output_types[i]](SCREAMING_SNAKE_CASE__	)	)
																								else:
																														decoded_outputs.append(AgentType(SCREAMING_SNAKE_CASE__	)	)
																		else:
																								# If the class does not have defined output, then we map according to the type
																								snake_case_       =     False
																								for _k, _v in INSTANCE_TYPE_MAPPING.items():
																														if isinstance(SCREAMING_SNAKE_CASE__  ,		_k	):
																																				decoded_outputs.append(_v(SCREAMING_SNAKE_CASE__	)	)
																																				snake_case_       =     True

																								if not found:
																														decoded_outputs.append(AgentType(SCREAMING_SNAKE_CASE__	)	)

						else:
												if output_types[0] in AGENT_TYPE_MAPPING:
																		# If the class has defined outputs, we can map directly according to the class definition
																		snake_case_       =     AGENT_TYPE_MAPPING[output_types[0]](SCREAMING_SNAKE_CASE__	)

												else:
																		# If the class does not have defined output, then we map according to the type
																		for _k, _v in INSTANCE_TYPE_MAPPING.items():
																								if isinstance(SCREAMING_SNAKE_CASE__  ,		_k	):
																														return _v(SCREAMING_SNAKE_CASE__	)
																		return AgentType(SCREAMING_SNAKE_CASE__	)

						return decoded_outputs


import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_splinter import SplinterTokenizer


lowerCAmelCase_	     =     logging.get_logger(__name__)

lowerCAmelCase_	     =     {'''vocab_file''': '''vocab.txt'''}

lowerCAmelCase_	     =     {
    '''vocab_file''': {
        '''tau/splinter-base''': '''https://huggingface.co/tau/splinter-base/resolve/main/vocab.txt''',
        '''tau/splinter-base-qass''': '''https://huggingface.co/tau/splinter-base-qass/resolve/main/vocab.txt''',
        '''tau/splinter-large''': '''https://huggingface.co/tau/splinter-large/resolve/main/vocab.txt''',
        '''tau/splinter-large-qass''': '''https://huggingface.co/tau/splinter-large-qass/resolve/main/vocab.txt''',
    }
}

lowerCAmelCase_	     =     {
    '''tau/splinter-base''': 5_12,
    '''tau/splinter-base-qass''': 5_12,
    '''tau/splinter-large''': 5_12,
    '''tau/splinter-large-qass''': 5_12,
}

lowerCAmelCase_	     =     {
    '''tau/splinter-base''': {'''do_lower_case''': False},
    '''tau/splinter-base-qass''': {'''do_lower_case''': False},
    '''tau/splinter-large''': {'''do_lower_case''': False},
    '''tau/splinter-large-qass''': {'''do_lower_case''': False},
}





class      snake_case_       (		__A ):







			'''simple docstring'''

			SCREAMING_SNAKE_CASE					:       List[str]						      =    VOCAB_FILES_NAMES
			SCREAMING_SNAKE_CASE					:       List[str]						      =    PRETRAINED_VOCAB_FILES_MAP
			SCREAMING_SNAKE_CASE					:       Optional[int]						      =    PRETRAINED_INIT_CONFIGURATION
			SCREAMING_SNAKE_CASE					:       List[str]						      =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			SCREAMING_SNAKE_CASE					:       Any						      =    SplinterTokenizer







			def __init__(					self			:    List[str]							,       _UpperCamelCase			:    Dict=None							,       _UpperCamelCase			:    Union[str, Any]=None							,       _UpperCamelCase			:    Union[str, Any]=True							,       _UpperCamelCase			:    List[Any]="[UNK]"							,       _UpperCamelCase			:    List[str]="[SEP]"							,       _UpperCamelCase			:    Optional[int]="[PAD]"							,       _UpperCamelCase			:    Tuple="[CLS]"							,       _UpperCamelCase			:    Optional[int]="[MASK]"							,       _UpperCamelCase			:    str="[QUESTION]"							,       _UpperCamelCase			:    Optional[Any]=True							,       _UpperCamelCase			:    Dict=None							,       **_UpperCamelCase			:    Optional[int]							,       )				->Union[str, Any]:
									super().__init__(
									    _UpperCamelCase							,       tokenizer_file=_UpperCamelCase							,       do_lower_case=_UpperCamelCase							,       unk_token=_UpperCamelCase							,       sep_token=_UpperCamelCase							,       pad_token=_UpperCamelCase							,       cls_token=_UpperCamelCase							,       mask_token=_UpperCamelCase							,       tokenize_chinese_chars=_UpperCamelCase							,       strip_accents=_UpperCamelCase							,       additional_special_tokens=(question_token,)							,       **_UpperCamelCase							,       )

									snake_case_       =     json.loads(self.backend_tokenizer.normalizer.__getstate__()							)
									if (
									    pre_tok_state.get('''lowercase'''							,       _UpperCamelCase							) != do_lower_case
									    or pre_tok_state.get('''strip_accents'''							,       _UpperCamelCase							) != strip_accents
									):
															snake_case_       =     getattr(_UpperCamelCase							,       pre_tok_state.pop('''type'''							)							)
															snake_case_       =     do_lower_case
															snake_case_       =     strip_accents
															snake_case_       =     pre_tok_class(**_UpperCamelCase							)

									snake_case_       =     do_lower_case







			@property
			def     snake_case__(					self			:    Optional[int]							)				->int:
									return self.convert_tokens_to_ids(self.question_token							)







			def     snake_case__(					self			:    Dict							,       _UpperCamelCase			:    List[int]							,       _UpperCamelCase			:    Optional[List[int]] = None							)				->List[int]:
									if token_ids_a is None:
															return [self.cls_token_id] + token_ids_a + [self.sep_token_id]

									snake_case_       =     [self.cls_token_id]
									snake_case_       =     [self.sep_token_id]
									snake_case_       =     [self.question_token_id] + [self.convert_tokens_to_ids('''.'''							)]
									if self.padding_side == "right":
															# Input is question-then-context
															return cls + token_ids_a + question_suffix + sep + token_ids_a + sep
									else:
															# Input is context-then-question
															return cls + token_ids_a + sep + token_ids_a + question_suffix + sep







			def     snake_case__(					self			:    str							,       _UpperCamelCase			:    List[int]							,       _UpperCamelCase			:    Optional[List[int]] = None							)				->List[int]:
									snake_case_       =     [self.sep_token_id]
									snake_case_       =     [self.cls_token_id]
									snake_case_       =     [self.question_token_id] + [self.convert_tokens_to_ids('''.'''							)]
									if token_ids_a is None:
															return len(cls + token_ids_a + sep							) * [0]

									if self.padding_side == "right":
															# Input is question-then-context
															return len(cls + token_ids_a + question_suffix + sep							) * [0] + len(token_ids_a + sep							) * [1]
									else:
															# Input is context-then-question
															return len(cls + token_ids_a + sep							) * [0] + len(token_ids_a + question_suffix + sep							) * [1]







			def     snake_case__(					self			:    Union[str, Any]							,       _UpperCamelCase			:    str							,       _UpperCamelCase			:    Optional[str] = None							)				->Tuple[str]:
									snake_case_       =     self._tokenizer.model.save(_UpperCamelCase							,       name=_UpperCamelCase							)
									return tuple(_UpperCamelCase							)