




'''simple docstring'''


import json
import os
from collections.abc import Mapping
from typing import Dict, List, Optional, Union

import numpy as np
import torch

from .imports import is_safetensors_available
def 				SCREAMING_SNAKE_CASE(      __lowercase		,							__lowercase		,							__lowercase		,							__lowercase=None  ) ->   Optional[int]:
					A:		List[str]        =		None
					# Check the string instead of the dtype to be compatible with versions of PyTorch that don't have bfloat16.
					if str(weight.dtype  ) == "torch.bfloat16":
										# Need to reinterpret the underlined data as int16 since NumPy does not handle bfloat16s.
										A:		int        =		weight.view(torch.intaa  )
										A:		List[Any]        =		'''bfloat16'''
					A:		Dict        =		weight.cpu().numpy()
					A:		Any        =		os.path.join(__lowercase		,							F"""{weight_name}.dat"""  )
					if index is not None:
										if dtype is None:
															A:		Optional[Any]        =		str(array.dtype  )
										A:		Optional[Any]        =		{'''dtype''': dtype, '''shape''': list(array.shape  )}
					if array.ndim == 0:
										A:		str        =		array[None]
					A:		List[str]        =		np.memmap(__lowercase		,							dtype=array.dtype		,							mode='''w+'''		,							shape=array.shape  )
					A:		List[str]        =		array[:]
					file_array.flush()
					return index
def 				SCREAMING_SNAKE_CASE(      __lowercase		,							__lowercase  ) ->   List[str]:
					A:		Optional[Any]        =		tuple(weight_info['''shape''']  )
					if shape == ():
										# NumPy memory-mapped arrays can't have 0 dims so it was saved as 1d tensor
										A:		List[str]        =		(1,)

					A:		Union[str, Any]        =		weight_info['''dtype''']
					if dtype == "bfloat16":
										# NumPy does not support bfloat16 so this was saved as a int16
										A:		Optional[Any]        =		'''int16'''

					A:		Optional[int]        =		np.memmap(__lowercase		,							dtype=__lowercase		,							shape=__lowercase		,							mode='''r'''  )

					if len(weight_info['''shape''']  ) == 0:
										A:		Dict        =		weight[0]
					A:		Any        =		torch.tensor(__lowercase  )
					if weight_info["dtype"] == "bfloat16":
										A:		List[Any]        =		weight.view(torch.bfloataa  )

					return weight
def 				SCREAMING_SNAKE_CASE(      __lowercase		,							__lowercase  ) ->   List[Any]:
					if index is None or len(__lowercase  ) == 0:
										# Nothing to save
										return

					A:		Union[str, Any]        =		os.path.join(__lowercase		,							'''index.json'''  )
					if os.path.isfile(__lowercase  ):
										with open(__lowercase		,							'''r'''		,							encoding='''utf-8'''  ) as f:
															A:		List[str]        =		json.load(__lowercase  )
					else:
										A:		Any        =		{}
					current_index.update(__lowercase  )

					with open(__lowercase		,							'''w'''		,							encoding='''utf-8'''  ) as f:
										json.dump(__lowercase		,							__lowercase		,							indent=2  )
def 				SCREAMING_SNAKE_CASE(      __lowercase		,							__lowercase  ) ->   int:
					os.makedirs(__lowercase		,							exist_ok=__lowercase  )
					A:		str        =		{}
					for name, parameter in state_dict.items():
										A:		List[str]        =		offload_weight(__lowercase		,							__lowercase		,							__lowercase		,							index=__lowercase  )

					# Update index
					save_offload_index(__lowercase		,							__lowercase  )






class 	lowerCAmelCase_  (					UpperCAmelCase_       ):







		'''simple docstring'''

		def __init__(   self							:       List[str]				,     SCREAMING_SNAKE_CASE_							:       Mapping				,     SCREAMING_SNAKE_CASE_							:       str  ) ->		str:







							'''simple docstring'''



							A:		str        =		dataset
							A:		Any        =		prefix



		def __getitem__(   self							:       List[str]				,     SCREAMING_SNAKE_CASE_							:       str  ) ->		Union[str, Any]:







							'''simple docstring'''



							return self.dataset[f"""{self.prefix}{key}"""]



		def __iter__(   self							:       Any  ) ->		Union[str, Any]:







							'''simple docstring'''



							return iter([key for key in self.dataset if key.startswith(self.prefix  )]  )




		def __len__(   self							:       Union[str, Any]  ) ->		Optional[int]:







							'''simple docstring'''



							return len(self.dataset  )






class 	lowerCAmelCase_  (					UpperCAmelCase_       ):







		'''simple docstring'''

		def __init__(   self							:       int				,     SCREAMING_SNAKE_CASE_							:       Dict[str, torch.Tensor] = None				,     SCREAMING_SNAKE_CASE_							:       Optional[Union[str, os.PathLike]] = None				,     SCREAMING_SNAKE_CASE_							:       Mapping = None				,     SCREAMING_SNAKE_CASE_							:       Union[str, Any]=None				,     ) ->		str:







							'''simple docstring'''



							if state_dict is None and save_folder is None:
												raise ValueError('''Need either a `state_dict` or a `save_folder` containing offloaded weights.'''  )

							A:		Tuple        =		{} if state_dict is None else state_dict
							A:		int        =		save_folder
							if index is None and save_folder is not None:
												with open(os.path.join(SCREAMING_SNAKE_CASE_				,     '''index.json'''  )  ) as f:
																	A:		Optional[int]        =		json.load(SCREAMING_SNAKE_CASE_  )
							A:		Dict        =		{} if index is None else index
							A:		Dict        =		list(self.state_dict.keys()  )
							self.all_keys.extend([key for key in self.index if key not in self.all_keys]  )
							A:		str        =		device



		def __getitem__(   self							:       List[str]				,     SCREAMING_SNAKE_CASE_							:       str  ) ->		List[str]:







							'''simple docstring'''



							if key in self.state_dict:
												return self.state_dict[key]
							A:		int        =		self.index[key]
							if weight_info.get('''safetensors_file'''  ) is not None:
												if not is_safetensors_available():
																	raise ImportError('''These offloaded weights require the use of safetensors: `pip install safetensors`.'''  )

												from safetensors import safe_open

												A:		Any        =		'''cpu''' if self.device is None else self.device
												with safe_open(weight_info['''safetensors_file''']				,     framework='''pt'''				,     device=SCREAMING_SNAKE_CASE_  ) as f:
																	A:		Union[str, Any]        =		f.get_tensor(weight_info.get('''weight_name'''				,     SCREAMING_SNAKE_CASE_  )  )

												if "dtype" in weight_info:
																	return tensor.to(getattr(SCREAMING_SNAKE_CASE_				,     weight_info['''dtype''']  )  )
												else:
																	return tensor

							A:		List[Any]        =		os.path.join(self.save_folder				,     f"""{key}.dat"""  )
							return load_offloaded_weight(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )



		def __iter__(   self							:       str  ) ->		str:







							'''simple docstring'''



							return iter(self.all_keys  )




		def __len__(   self							:       Optional[int]  ) ->		List[str]:







							'''simple docstring'''



							return len(self.all_keys  )






def 				SCREAMING_SNAKE_CASE(      __lowercase		,							__lowercase  ) ->   Union[str, Any]:
					A:		Optional[Any]        =		{}
					for module_name in submodule_names:
										# We want to catch module_name parameter (module_name.xxx) or potentially module_name, but not any of the
										# submodules that could being like module_name (transformers.h.1 and transformers.h.10 for instance)
										result.update(
										    {
										        key: param
										        for key, param in state_dict.items()
										        if key == module_name or key.startswith(module_name + '''.'''  )
										    }  )
					return result












'''simple docstring'''


def 				SCREAMING_SNAKE_CASE(      __lowercase  ) ->   int:
     A:		str        =		str(__lowercase  ).strip()
     if not bin_string:
          raise ValueError('''Empty string was passed to the function'''  )
     A:		int        =		bin_string[0] == '''-'''
     if is_negative:
          A:		Optional[Any]        =		bin_string[1:]
     if not all(char in '''01''' for char in bin_string  ):
          raise ValueError('''Non-binary value was passed to the function'''  )
     A:		Any        =		0
     for char in bin_string:
          A:		Dict        =		2 * decimal_number + int(__lowercase  )
     return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
     from doctest import testmod

     testmod()






