'''simple docstring'''





from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
    from transformers import (
        AutoConfig,
        BertConfig,
        GPTaConfig,
        TaConfig,
        TFAutoModel,
        TFAutoModelForCausalLM,
        TFAutoModelForMaskedLM,
        TFAutoModelForPreTraining,
        TFAutoModelForQuestionAnswering,
        TFAutoModelForSeqaSeqLM,
        TFAutoModelForSequenceClassification,
        TFAutoModelWithLMHead,
        TFBertForMaskedLM,
        TFBertForPreTraining,
        TFBertForQuestionAnswering,
        TFBertForSequenceClassification,
        TFBertModel,
        TFGPTaLMHeadModel,
        TFRobertaForMaskedLM,
        TFTaForConditionalGeneration,
    )
    from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
    from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
    from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST

if is_torch_available():
    from transformers import (
        AutoModel,
        AutoModelForCausalLM,
        AutoModelForMaskedLM,
        AutoModelForPreTraining,
        AutoModelForQuestionAnswering,
        AutoModelForSeqaSeqLM,
        AutoModelForSequenceClassification,
        AutoModelWithLMHead,
        BertForMaskedLM,
        BertForPreTraining,
        BertForQuestionAnswering,
        BertForSequenceClassification,
        BertModel,
        GPTaLMHeadModel,
        RobertaForMaskedLM,
        TaForConditionalGeneration,
    )




@is_pt_tf_cross_test
class 	__A				(			unittest.TestCase     ):



    @slow
    def  _lowercase						(self   :   int			):
         # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         for model_name in ["bert-base-uncased"]:
              UpperCAmelCase_	   =       AutoConfig.from_pretrained(__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       TFAutoModel.from_pretrained(__a       ,      from_pt=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       AutoModel.from_pretrained(__a       ,      from_tf=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)



    @slow
    def  _lowercase						(self   :   Any			):
         # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         for model_name in ["bert-base-uncased"]:
              UpperCAmelCase_	   =       AutoConfig.from_pretrained(__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       TFAutoModelForPreTraining.from_pretrained(__a       ,      from_pt=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       AutoModelForPreTraining.from_pretrained(__a       ,      from_tf=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)



    @slow
    def  _lowercase						(self   :   Any			):
         for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCAmelCase_	   =       AutoConfig.from_pretrained(__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       TFAutoModelForCausalLM.from_pretrained(__a       ,      from_pt=__a			)
              UpperCAmelCase_   ,			UpperCAmelCase_	   =       TFAutoModelForCausalLM.from_pretrained(
                  __a       ,      output_loading_info=__a       ,      from_pt=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       AutoModelForCausalLM.from_pretrained(__a       ,      from_tf=__a			)
              UpperCAmelCase_   ,			UpperCAmelCase_	   =       AutoModelForCausalLM.from_pretrained(
                  __a       ,      output_loading_info=__a       ,      from_tf=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)



    @slow
    def  _lowercase						(self   :   Tuple			):
         for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCAmelCase_	   =       AutoConfig.from_pretrained(__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       TFAutoModelWithLMHead.from_pretrained(__a       ,      from_pt=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       AutoModelWithLMHead.from_pretrained(__a       ,      from_tf=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)



    @slow
    def  _lowercase						(self   :   Dict			):
         for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCAmelCase_	   =       AutoConfig.from_pretrained(__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       TFAutoModelForMaskedLM.from_pretrained(__a       ,      from_pt=__a			)
              UpperCAmelCase_   ,			UpperCAmelCase_	   =       TFAutoModelForMaskedLM.from_pretrained(
                  __a       ,      output_loading_info=__a       ,      from_pt=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       AutoModelForMaskedLM.from_pretrained(__a       ,      from_tf=__a			)
              UpperCAmelCase_   ,			UpperCAmelCase_	   =       AutoModelForMaskedLM.from_pretrained(
                  __a       ,      output_loading_info=__a       ,      from_tf=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)



    @slow
    def  _lowercase						(self   :   str			):
         for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCAmelCase_	   =       AutoConfig.from_pretrained(__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       TFAutoModelForSeqaSeqLM.from_pretrained(__a       ,      from_pt=__a			)
              UpperCAmelCase_   ,			UpperCAmelCase_	   =       TFAutoModelForSeqaSeqLM.from_pretrained(
                  __a       ,      output_loading_info=__a       ,      from_pt=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       AutoModelForSeqaSeqLM.from_pretrained(__a       ,      from_tf=__a			)
              UpperCAmelCase_   ,			UpperCAmelCase_	   =       AutoModelForSeqaSeqLM.from_pretrained(
                  __a       ,      output_loading_info=__a       ,      from_tf=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)



    @slow
    def  _lowercase						(self   :   Optional[Any]			):
         # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         for model_name in ["bert-base-uncased"]:
              UpperCAmelCase_	   =       AutoConfig.from_pretrained(__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       TFAutoModelForSequenceClassification.from_pretrained(__a       ,      from_pt=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       AutoModelForSequenceClassification.from_pretrained(__a       ,      from_tf=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)



    @slow
    def  _lowercase						(self   :   Tuple			):
         # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         for model_name in ["bert-base-uncased"]:
              UpperCAmelCase_	   =       AutoConfig.from_pretrained(__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       TFAutoModelForQuestionAnswering.from_pretrained(__a       ,      from_pt=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)

              UpperCAmelCase_	   =       AutoModelForQuestionAnswering.from_pretrained(__a       ,      from_tf=__a			)
              self.assertIsNotNone(__a			)
              self.assertIsInstance(__a       ,      __a			)



    def  _lowercase						(self   :   Optional[int]			):
         UpperCAmelCase_	   =       TFAutoModelWithLMHead.from_pretrained(__a       ,      from_pt=__a			)
         self.assertIsInstance(__a       ,      __a			)
         self.assertEqual(model.num_parameters()       ,      14410			)
         self.assertEqual(model.num_parameters(only_trainable=__a			)       ,      14410			)

         UpperCAmelCase_	   =       AutoModelWithLMHead.from_pretrained(__a       ,      from_tf=__a			)
         self.assertIsInstance(__a       ,      __a			)
         self.assertEqual(model.num_parameters()       ,      14410			)
         self.assertEqual(model.num_parameters(only_trainable=__a			)       ,      14410			)






    def  _lowercase						(self   :   Any			):
         UpperCAmelCase_	   =       TFAutoModelWithLMHead.from_pretrained(__a       ,      from_pt=__a			)
         self.assertIsInstance(__a       ,      __a			)
         self.assertEqual(model.num_parameters()       ,      14410			)
         self.assertEqual(model.num_parameters(only_trainable=__a			)       ,      14410			)

         UpperCAmelCase_	   =       AutoModelWithLMHead.from_pretrained(__a       ,      from_tf=__a			)
         self.assertIsInstance(__a       ,      __a			)
         self.assertEqual(model.num_parameters()       ,      14410			)
         self.assertEqual(model.num_parameters(only_trainable=__a			)       ,      14410			)





'''simple docstring'''





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

import numpy as np
import pyarrow as pa

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


if TYPE_CHECKING:
    import jax
    import jaxlib

SCREAMING_SNAKE_CASE_:					List[str]  =get_logger()

SCREAMING_SNAKE_CASE_:					Optional[dict]  =None




class 	__A				(			TensorFormatter[Mapping, """jax.Array""", Mapping]     ):



    def __init__(self   :   List[Any]       ,      __a   :   Optional[int]=None       ,      __a   :   Any=None       ,      **__a   :   Dict			):
         super().__init__(features=__a			)
         import jax
         from jaxlib.xla_client import Device

         if isinstance(__a       ,      __a			):
              raise ValueError(
                  f"""Expected {device} to be a `str` not {type(__a			)}, as `jaxlib.xla_extension.Device` """
                  "is not serializable neither with `pickle` nor with `dill`. Instead you can surround "
                  "the device with `str()` to get its string identifier that will be internally mapped "
                  "to the actual `jaxlib.xla_extension.Device`."			)
         UpperCAmelCase_	   =       device if isinstance(__a       ,      __a			) else str(jax.devices()[0]			)
         # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
         # with `pickle` nor with `dill`, so we need to use a global variable instead
         global DEVICE_MAPPING
         if DEVICE_MAPPING is None:
              UpperCAmelCase_	   =       self._map_devices_to_str()
         if self.device not in list(DEVICE_MAPPING.keys()			):
              logger.warning(
                  f"""Device with string identifier {self.device} not listed among the available """
                  f"""devices: {list(DEVICE_MAPPING.keys()			)}, so falling back to the default """
                  f"""device: {str(jax.devices()[0]			)}."""			)
              UpperCAmelCase_	   =       str(jax.devices()[0]			)
         UpperCAmelCase_	   =       jnp_array_kwargs



    @staticmethod
    def  _lowercase						():
         import jax

         return {str(__a			): device for device in jax.devices()}



    def  _lowercase						(self   :   str       ,      __a   :   Tuple			):
         import jax
         import jax.numpy as jnp

         if isinstance(__a       ,      __a			) and column:
              if all(
                  isinstance(__a       ,      jax.Array			) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column			):
                   return jnp.stack(__a       ,      axis=0			)
         return column



    def  _lowercase						(self   :   Any       ,      __a   :   Optional[int]			):
         import jax
         import jax.numpy as jnp

         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.tolist()

         UpperCAmelCase_	   =       {}

         if isinstance(__a       ,      (np.number, np.ndarray)			) and np.issubdtype(value.dtype       ,      np.integer			):
              # the default int precision depends on the jax config
              # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
              if jax.config.jax_enable_xaa:
                   UpperCAmelCase_	   =       {"dtype": jnp.intaa}
              else:
                   UpperCAmelCase_	   =       {"dtype": jnp.intaa}
         elif isinstance(__a       ,      (np.number, np.ndarray)			) and np.issubdtype(value.dtype       ,      np.floating			):
              UpperCAmelCase_	   =       {"dtype": jnp.floataa}
         elif config.PIL_AVAILABLE and "PIL" in sys.modules:
              import PIL.Image

              if isinstance(__a       ,      PIL.Image.Image			):
                   UpperCAmelCase_	   =       np.asarray(__a			)

        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
        # with `pickle` nor with `dill`, so we need to use a global variable instead
         global DEVICE_MAPPING
         if DEVICE_MAPPING is None:
              UpperCAmelCase_	   =       self._map_devices_to_str()

         with jax.default_device(DEVICE_MAPPING[self.device]			):
              # calling jnp.array on a np.ndarray does copy the data
              # see https://github.com/google/jax/issues/4486
              return jnp.array(__a       ,      **{**default_dtype, **self.jnp_array_kwargs}			)



    def  _lowercase						(self   :   int       ,      __a   :   Any			):
         import jax

         # 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       ,      jax.Array			):
              UpperCAmelCase_	   =       data_struct.__array__()
         # support for nested types like struct of list of struct
         if isinstance(__a       ,      np.ndarray			):
              if data_struct.dtype == object:  # jax arrays 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  _lowercase						(self   :   Union[str, Any]       ,      __a   :   dict			):
         return map_nested(self._recursive_tensorize       ,      __a       ,      map_list=__a			)



    def  _lowercase						(self   :   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  _lowercase						(self   :   Tuple       ,      __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  _lowercase						(self   :   str       ,      __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




