'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__SCREAMING_SNAKE_CASE	:					List[str]					=  {
    """configuration_flaubert""": ["""FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FlaubertConfig""", """FlaubertOnnxConfig"""],
    """tokenization_flaubert""": ["""FlaubertTokenizer"""],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__SCREAMING_SNAKE_CASE	:					Optional[Any]					=  [
		    """FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """FlaubertForMultipleChoice""",
		    """FlaubertForQuestionAnswering""",
		    """FlaubertForQuestionAnsweringSimple""",
		    """FlaubertForSequenceClassification""",
		    """FlaubertForTokenClassification""",
		    """FlaubertModel""",
		    """FlaubertWithLMHeadModel""",
		    """FlaubertPreTrainedModel""",
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__SCREAMING_SNAKE_CASE	:					Union[str, Any]					=  [
		    """TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """TFFlaubertForMultipleChoice""",
		    """TFFlaubertForQuestionAnsweringSimple""",
		    """TFFlaubertForSequenceClassification""",
		    """TFFlaubertForTokenClassification""",
		    """TFFlaubertModel""",
		    """TFFlaubertPreTrainedModel""",
		    """TFFlaubertWithLMHeadModel""",
		]


if TYPE_CHECKING:
		from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
		from .tokenization_flaubert import FlaubertTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flaubert import (
				    FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    FlaubertForMultipleChoice,
				    FlaubertForQuestionAnswering,
				    FlaubertForQuestionAnsweringSimple,
				    FlaubertForSequenceClassification,
				    FlaubertForTokenClassification,
				    FlaubertModel,
				    FlaubertPreTrainedModel,
				    FlaubertWithLMHeadModel,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_flaubert import (
				    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFFlaubertForMultipleChoice,
				    TFFlaubertForQuestionAnsweringSimple,
				    TFFlaubertForSequenceClassification,
				    TFFlaubertForTokenClassification,
				    TFFlaubertModel,
				    TFFlaubertPreTrainedModel,
				    TFFlaubertWithLMHeadModel,
				)

else:
		import sys

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


'''simple docstring'''




import sys
from collections.abc import Mapping

import numpy as np
import pyarrow as pa

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

class      lowerCamelCase_     (TensorFormatter[Mapping, np.ndarray, Mapping]   ):
      '''simple docstring'''

      def __init__(	self						:    str						, A						:    List[str]=None						, **A						:    Optional[Any]	):
             super().__init__(features=A	)
             _UpperCAmelCase					:  Tuple											=   np_array_kwargs




      def 					_A     (	self						:    str						, A						:    Tuple	):
             if isinstance(A						, A	):
                    if column and all(
                        isinstance(A						, np.ndarray	) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column	):
                           return np.stack(A	)
                    else:
                           # don't use np.array(column, dtype=object)
                           # since it fails in certain cases
                           # see https://stackoverflow.com/q/51005699
                           _UpperCAmelCase					:  List[str]											=   np.empty(len(A	)						, dtype=A	)
                           _UpperCAmelCase					:  int											=   column
                           return out
             return column




      def 					_A     (	self						:    Any						, A						:    Optional[Any]	):
             if isinstance(A						, (str, bytes, type(A	))	):
                    return value
             elif isinstance(A						, (np.character, np.ndarray)	) and np.issubdtype(value.dtype						, np.character	):
                    return value
             elif isinstance(A						, np.number	):
                    return value

             _UpperCAmelCase					:  List[str]											=   {}

             if isinstance(A						, np.ndarray	) and np.issubdtype(value.dtype						, np.integer	):
                    _UpperCAmelCase					:  str											=   {"dtype": np.intaa}
             elif isinstance(A						, np.ndarray	) and np.issubdtype(value.dtype						, np.floating	):
                    _UpperCAmelCase					:  int											=   {"dtype": np.floataa}
             elif config.PIL_AVAILABLE and "PIL" in sys.modules:
                    import PIL.Image

                    if isinstance(A						, PIL.Image.Image	):
                           return np.asarray(A						, **self.np_array_kwargs	)

             return np.asarray(A						, **{**default_dtype, **self.np_array_kwargs}	)




      def 					_A     (	self						:    Any						, A						:    Optional[Any]	):
             # 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						, (np.ndarray, np.character, np.number)	):
                    _UpperCAmelCase					:  Dict											=   data_struct.__array__()
             # support for nested types like struct of list of struct
             if isinstance(A						, np.ndarray	):
                    if data_struct.dtype == object:
                           return self._consolidate([self.recursive_tensorize(A	) for substruct in data_struct]	)
             if isinstance(A						, (list, tuple)	):
                    return self._consolidate([self.recursive_tensorize(A	) for substruct in data_struct]	)
             return self._tensorize(A	)




      def 					_A     (	self						:    List[Any]						, A						:    dict	):
             return map_nested(self._recursive_tensorize						, A						, map_list=A	)




      def 					_A     (	self						:    List[str]						, A						:    pa.Table	):
             _UpperCAmelCase					:  str											=   self.numpy_arrow_extractor().extract_row(A	)
             _UpperCAmelCase					:  Dict											=   self.python_features_decoder.decode_row(A	)
             return self.recursive_tensorize(A	)




      def 					_A     (	self						:    str						, A						:    pa.Table	):
             _UpperCAmelCase					:  List[str]											=   self.numpy_arrow_extractor().extract_column(A	)
             _UpperCAmelCase					:  Optional[Any]											=   self.python_features_decoder.decode_column(A						, pa_table.column_names[0]	)
             _UpperCAmelCase					:  Tuple											=   self.recursive_tensorize(A	)
             _UpperCAmelCase					:  Tuple											=   self._consolidate(A	)
             return column





      def 					_A     (	self						:    Union[str, Any]						, A						:    pa.Table	):
             _UpperCAmelCase					:  Any											=   self.numpy_arrow_extractor().extract_batch(A	)
             _UpperCAmelCase					:  Any											=   self.python_features_decoder.decode_batch(A	)
             _UpperCAmelCase					:  List[str]											=   self.recursive_tensorize(A	)
             for column_name in batch:
                    _UpperCAmelCase					:  Optional[Any]											=   self._consolidate(batch[column_name]	)
             return batch

