





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 tensorflow as tf

class 					snake_case					(   TensorFormatter[Mapping, "tf.Tensor", Mapping]	):




 """simple docstring"""



 def __init__(	self	:							Tuple							,     __A	:							Optional[int]=None							,     **__A	:							int     ):
        super().__init__(features=__A     )
        __UpperCamelCase	=  tf_tensor_kwargs
        import tensorflow as tf  # noqa: import tf at initialization






 def 	_lowerCamelCase (	self	:							Optional[int]							,     __A	:							Tuple     ):
        import tensorflow as tf

        if isinstance(__A							,     __A     ) and column:
               if all(
                   isinstance(__A							,     tf.Tensor     ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column     ):
                      return tf.stack(__A     )
               elif all(
                   isinstance(__A							,     (tf.Tensor, tf.RaggedTensor)     ) and x.ndim == 1 and x.dtype == column[0].dtype
                   for x in column     ):
                      # only rag 1-D tensors, otherwise some dimensions become ragged even though they were consolidated
                      return tf.ragged.stack(__A     )

        return column






 def 	_lowerCamelCase (	self	:							List[str]							,     __A	:							Union[str, Any]     ):
        import tensorflow as tf

        if value is None:
               return value

        __UpperCamelCase	=  {}

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

               if isinstance(__A							,     PIL.Image.Image     ):
                      __UpperCamelCase	=  np.asarray(__A     )

        return tf.convert_to_tensor(__A							,     **{**default_dtype, **self.tf_tensor_kwargs}     )






 def 	_lowerCamelCase (	self	:							Dict							,     __A	:							Dict     ):
        import tensorflow as tf

        # support for torch, tf, jax etc.
        if config.TORCH_AVAILABLE and "torch" in sys.modules:
               import torch

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






 def 	_lowerCamelCase (	self	:							Dict							,     __A	:							dict     ):
        return map_nested(self._recursive_tensorize							,     __A							,     map_list=__A     )






 def 	_lowerCamelCase (	self	:							List[str]							,     __A	:							pa.Table     ):
        __UpperCamelCase	=  self.numpy_arrow_extractor().extract_row(__A     )
        __UpperCamelCase	=  self.python_features_decoder.decode_row(__A     )
        return self.recursive_tensorize(__A     )






 def 	_lowerCamelCase (	self	:							str							,     __A	:							pa.Table     ):
        __UpperCamelCase	=  self.numpy_arrow_extractor().extract_column(__A     )
        __UpperCamelCase	=  self.python_features_decoder.decode_column(__A							,     pa_table.column_names[0]     )
        __UpperCamelCase	=  self.recursive_tensorize(__A     )
        __UpperCamelCase	=  self._consolidate(__A     )
        return column






 def 	_lowerCamelCase (	self	:							Union[str, Any]							,     __A	:							pa.Table     ):
        __UpperCamelCase	=  self.numpy_arrow_extractor().extract_batch(__A     )
        __UpperCamelCase	=  self.python_features_decoder.decode_batch(__A     )
        __UpperCamelCase	=  self.recursive_tensorize(__A     )
        for column_name in batch:
               __UpperCamelCase	=  self._consolidate(batch[column_name]     )
        return batch







'''simple docstring'''
def     lowercase__       (       __lowercase						:  str    ,  __lowercase						:  Tuple					)			->				str:



       """simple docstring"""






       sequence.append(__lowercase					)

       __UpperCamelCase	=  0
       while sequence[index] != target:
              index += 1

       sequence.pop()

       if index == len(__lowercase					):
              return None

       return index


if __name__ == "__main__":
    a__							:							Any			=input('''Enter numbers separated by comma:\n''').strip()
    a__							:							Any			=[int(item) for item in user_input.split(''',''')]

    a__							:							Tuple			=input('''Enter a single number to be found in the list:\n''')
    a__							:							List[Any]			=int(target_input)
    a__							:							List[Any]			=sentinel_linear_search(sequence, target)
    if result is not None:
        print(f'{target} found at positions: {result}')
    else:
        print('''Not found''')
