
"""simple docstring"""


# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
						import torch




class  __lowerCamelCase  ( TensorFormatter[Mapping, 'torch.Tensor', Mapping]			):




				def __init__(				self							,						UpperCAmelCase=None							,						**UpperCAmelCase   ):
							super().__init__(features=UpperCAmelCase   )
							lowerCamelCase_					=  torch_tensor_kwargs
							import torch  # noqa import torch at initialization




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							import torch

							if isinstance(UpperCAmelCase							,						UpperCAmelCase   ) and column:
										if all(
										    isinstance(UpperCAmelCase							,						torch.Tensor   ) and x.shape == column[0].shape and x.dtype == column[0].dtype
										    for x in column   ):
													return torch.stack(UpperCAmelCase   )
							return column




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							import torch

							if isinstance(UpperCAmelCase							,						(str, bytes, type(UpperCAmelCase   ))   ):
										return value
							elif isinstance(UpperCAmelCase							,						(np.character, np.ndarray)   ) and np.issubdtype(value.dtype							,						np.character   ):
										return value.tolist()

							lowerCamelCase_					=  {}

							if isinstance(UpperCAmelCase							,						(np.number, np.ndarray)   ) and np.issubdtype(value.dtype							,						np.integer   ):
										lowerCamelCase_					=  {'''dtype''': torch.intaa}
							elif isinstance(UpperCAmelCase							,						(np.number, np.ndarray)   ) and np.issubdtype(value.dtype							,						np.floating   ):
										lowerCamelCase_					=  {'''dtype''': torch.floataa}
							elif config.PIL_AVAILABLE and "PIL" in sys.modules:
										import PIL.Image

										if isinstance(UpperCAmelCase							,						PIL.Image.Image   ):
													lowerCamelCase_					=  np.asarray(UpperCAmelCase   )
							return torch.tensor(UpperCAmelCase							,						**{**default_dtype, **self.torch_tensor_kwargs}   )




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							import torch

							# support for torch, tf, jax etc.
							if hasattr(UpperCAmelCase							,						'''__array__'''   ) and not isinstance(UpperCAmelCase							,						torch.Tensor   ):
										lowerCamelCase_					=  data_struct.__array__()
							# support for nested types like struct of list of struct
							if isinstance(UpperCAmelCase							,						np.ndarray   ):
										if data_struct.dtype == object:  # torch tensors cannot be instantied from an array of objects
													return self._consolidate([self.recursive_tensorize(UpperCAmelCase   ) for substruct in data_struct]   )
							elif isinstance(UpperCAmelCase							,						(list, tuple)   ):
										return self._consolidate([self.recursive_tensorize(UpperCAmelCase   ) for substruct in data_struct]   )
							return self._tensorize(UpperCAmelCase   )




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							return map_nested(self._recursive_tensorize							,						UpperCAmelCase							,						map_list=UpperCAmelCase   )




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							lowerCamelCase_					=  self.numpy_arrow_extractor().extract_row(UpperCAmelCase   )
							lowerCamelCase_					=  self.python_features_decoder.decode_row(UpperCAmelCase   )
							return self.recursive_tensorize(UpperCAmelCase   )




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							lowerCamelCase_					=  self.numpy_arrow_extractor().extract_column(UpperCAmelCase   )
							lowerCamelCase_					=  self.python_features_decoder.decode_column(UpperCAmelCase							,						pa_table.column_names[0]   )
							lowerCamelCase_					=  self.recursive_tensorize(UpperCAmelCase   )
							lowerCamelCase_					=  self._consolidate(UpperCAmelCase   )
							return column





				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							lowerCamelCase_					=  self.numpy_arrow_extractor().extract_batch(UpperCAmelCase   )
							lowerCamelCase_					=  self.python_features_decoder.decode_batch(UpperCAmelCase   )
							lowerCamelCase_					=  self.recursive_tensorize(UpperCAmelCase   )
							for column_name in batch:
										lowerCamelCase_					=  self._consolidate(batch[column_name]   )
							return batch










def   __lowerCamelCase   (				__a  :str       )						->							bool:






		"""simple docstring"""

		A__     =  0
		for ch in input_str:
				A__     =  ord(__a       )
				A__     =  pow(2       ,	__a       )

				# If we already turned on bit for current character's unicode
				if bitmap >> ch_unicode & 1 == 1:
						return False
				bitmap |= ch_bit_index_on
		return True


if __name__ == "__main__":
					import doctest

					doctest.testmod()



