
"""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


_lowercase				 =					logging.get_logger(__name__)






def    _snake_case					(		snake_case__ :  List[Any]						,   snake_case__ :  List[Any]  ):
	try:
		with open(snake_case__						,   'rb'  ) as flax_state_f:
			A     = 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    _snake_case					(		snake_case__ :  str						,   snake_case__ :  List[Any]  ):

	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
	A     = 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.'  )
		A     = jax.tree_util.tree_map(
		    lambda snake_case__  : params.astype(np.floataa  ) if params.dtype == jnp.bfloataa else params						,   snake_case__  )

	A     = ''

	A     = flatten_dict(snake_case__						,   sep='.'  )
	A     = pt_model.state_dict()

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

	for flax_key_tuple, flax_tensor in flax_state_dict.items():
		A     = flax_key_tuple.split('.'  )

		if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
			A     = flax_key_tuple_array[:-1] + ['weight']
			A     = jnp.transpose(snake_case__						,   (3, 2, 0, 1)  )
		elif flax_key_tuple_array[-1] == "kernel":
			A     = flax_key_tuple_array[:-1] + ['weight']
			A     = flax_tensor.T
		elif flax_key_tuple_array[-1] == "scale":
			A     = 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__  ):
				A     = (
				    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'  )
				)

		A     = '.'.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
				A     = np.asarray(snake_case__  ) if not isinstance(snake_case__						,   np.ndarray  ) else flax_tensor
				A     = 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
	A     = 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

"""simple docstring"""


import pytest
import requests

from datasets.utils.file_utils import http_head

from .utils import OfflineSimulationMode, RequestWouldHangIndefinitelyError, offline






@pytest.mark.integration
def    _snake_case					(		):
	with offline(OfflineSimulationMode.CONNECTION_TIMES_OUT  ):
		with pytest.raises(snake_case__  ):
			requests.request('GET'						,   'https://huggingface.co'  )
		with pytest.raises(requests.exceptions.ConnectTimeout  ):
			requests.request('GET'						,   'https://huggingface.co'						,   timeout=1.0  )






@pytest.mark.integration
def    _snake_case					(		):
	with offline(OfflineSimulationMode.CONNECTION_FAILS  ):
		with pytest.raises(requests.exceptions.ConnectionError  ):
			requests.request('GET'						,   'https://huggingface.co'  )






def    _snake_case					(		):
	with offline(OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1  ):
		with pytest.raises(snake_case__  ):
			http_head('https://huggingface.co'  )