






"""simple docstring"""







from pickle import UnpicklingError

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict

from ..utils import logging


_UpperCamelCase	     =    logging.get_logger(__name__)

def _a					(						_snake_case ,			_snake_case				):







      """simple docstring"""






      try:
            with open(_snake_case ,			"""rb"""				) as flax_state_f:
                  UpperCAmelCase							     =			from_bytes(_snake_case ,			flax_state_f.read()				)
      except UnpicklingError as e:
            try:
                  with open(_snake_case				) as f:
                        if f.read().startswith("""version"""				):
                              raise OSError(
                                  """You seem to have cloned a repository without having git-lfs installed. Please"""
                                  """ install git-lfs and run `git lfs install` followed by `git lfs pull` in the"""
                                  """ folder you cloned."""				)
                        else:
                              raise ValueError from e
            except (UnicodeDecodeError, ValueError):
                  raise EnvironmentError(F'''Unable to convert {model_file} to Flax deserializable object. '''				)

      return load_flax_weights_in_pytorch_model(_snake_case ,			_snake_case				)






def _a					(						_snake_case ,			_snake_case				):







      """simple docstring"""






      try:
            import torch  # noqa: F401
      except ImportError:
            logger.error(
                """Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see"""
                """ https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"""
                """ instructions."""				)
            raise

      # check if we have bf16 weights
      UpperCAmelCase							     =			flatten_dict(jax.tree_util.tree_map(lambda _snake_case				: x.dtype == jnp.bfloataa ,			_snake_case				)				).values()
      if any(_snake_case				):
            # convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16

            # and bf16 is not fully supported in PT yet.
            logger.warning(
                """Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` """
                """before loading those in PyTorch model."""				)
            UpperCAmelCase							     =			jax.tree_util.tree_map(
                lambda _snake_case				: params.astype(np.floataa				) if params.dtype == jnp.bfloataa else params ,			_snake_case				)

      UpperCAmelCase							     =			""""""

      UpperCAmelCase							     =			flatten_dict(_snake_case ,			sep="""."""				)
      UpperCAmelCase							     =			pt_model.state_dict()

      # keep track of unexpected & missing keys
      UpperCAmelCase							     =			[]
      UpperCAmelCase							     =			set(pt_model_dict.keys()				)

      for flax_key_tuple, flax_tensor in flax_state_dict.items():
            UpperCAmelCase							     =			flax_key_tuple.split("""."""				)

            if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
                  UpperCAmelCase							     =			flax_key_tuple_array[:-1] + ["""weight"""]
                  UpperCAmelCase							     =			jnp.transpose(_snake_case ,			(3, 2, 0, 1)				)
            elif flax_key_tuple_array[-1] == "kernel":
                  UpperCAmelCase							     =			flax_key_tuple_array[:-1] + ["""weight"""]
                  UpperCAmelCase							     =			flax_tensor.T
            elif flax_key_tuple_array[-1] == "scale":
                  UpperCAmelCase							     =			flax_key_tuple_array[:-1] + ["""weight"""]

            if "time_embedding" not in flax_key_tuple_array:
                  for i, flax_key_tuple_string in enumerate(_snake_case				):
                        UpperCAmelCase							     =			(
                            flax_key_tuple_string.replace("""_0""" ,			""".0"""				)
                            .replace("""_1""" ,			""".1"""				)
                            .replace("""_2""" ,			""".2"""				)
                            .replace("""_3""" ,			""".3"""				)
                            .replace("""_4""" ,			""".4"""				)
                            .replace("""_5""" ,			""".5"""				)
                            .replace("""_6""" ,			""".6"""				)
                            .replace("""_7""" ,			""".7"""				)
                            .replace("""_8""" ,			""".8"""				)
                            .replace("""_9""" ,			""".9"""				)
                        )

            UpperCAmelCase							     =			""".""".join(_snake_case				)

            if flax_key in pt_model_dict:
                  if flax_tensor.shape != pt_model_dict[flax_key].shape:
                        raise ValueError(
                            F'''Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected '''
                            F'''to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.'''				)
                  else:
                        # add weight to pytorch dict
                        UpperCAmelCase							     =			np.asarray(_snake_case				) if not isinstance(_snake_case ,			np.ndarray				) else flax_tensor
                        UpperCAmelCase							     =			torch.from_numpy(_snake_case				)
                        # remove from missing keys
                        missing_keys.remove(_snake_case				)
            else:
                  # weight is not expected by PyTorch model
                  unexpected_keys.append(_snake_case				)

      pt_model.load_state_dict(_snake_case				)

      # re-transform missing_keys to list
      UpperCAmelCase							     =			list(_snake_case				)

      if len(_snake_case				) > 0:
            logger.warning(
                """Some weights of the Flax model were not used when initializing the PyTorch model"""
                F''' {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing'''
                F''' {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture'''
                """ (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This"""
                F''' IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect'''
                """ to be exactly identical (e.g. initializing a BertForSequenceClassification model from a"""
                """ FlaxBertForSequenceClassification model)."""				)
      if len(_snake_case				) > 0:
            logger.warning(
                F'''Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly'''
                F''' initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to'''
                """ use it for predictions and inference."""				)

      return pt_model





import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin

class 							_UpperCamelCase					(       unittest.TestCase  ,							_A	):






			'''simple docstring'''

			def    lowerCAmelCase__						(							self			:							Tuple   ):
							UpperCamelCase_:				List[Any]						=    load_tool("""text-classification"""   )
							self.tool.setup()
							UpperCamelCase_:				Optional[int]						=    load_tool("""text-classification"""    ,						remote=snake_case_   )

			def    lowerCAmelCase__						(							self			:							Optional[Any]   ):
							UpperCamelCase_:				Union[str, Any]						=    self.tool("""That's quite cool"""    ,						["""positive""", """negative"""]   )
							self.assertEqual(snake_case_    ,						"""positive"""   )

			def    lowerCAmelCase__						(							self			:							int   ):
							UpperCamelCase_:				Tuple						=    self.remote_tool("""That's quite cool"""    ,						["""positive""", """negative"""]   )
							self.assertEqual(snake_case_    ,						"""positive"""   )

			def    lowerCAmelCase__						(							self			:							Optional[int]   ):
							UpperCamelCase_:				int						=    self.tool(text="""That's quite cool"""    ,						labels=["""positive""", """negative"""]   )
							self.assertEqual(snake_case_    ,						"""positive"""   )




			def    lowerCAmelCase__						(							self			:							Tuple   ):
							UpperCamelCase_:				List[Any]						=    self.remote_tool(text="""That's quite cool"""    ,						labels=["""positive""", """negative"""]   )
							self.assertEqual(snake_case_    ,						"""positive"""   )






