



from typing import TYPE_CHECKING

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


__lowerCamelCase								=      {'''configuration_vit_hybrid''': ['''VIT_HYBRID_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ViTHybridConfig''']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __lowerCamelCase								=      [
       '''VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''ViTHybridForImageClassification''',
       '''ViTHybridModel''',
       '''ViTHybridPreTrainedModel''',
   ]

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __lowerCamelCase								=      ['''ViTHybridImageProcessor''']


if TYPE_CHECKING:
   from .configuration_vit_hybrid import VIT_HYBRID_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTHybridConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_vit_hybrid import (
          VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST,
          ViTHybridForImageClassification,
          ViTHybridModel,
          ViTHybridPreTrainedModel,
      )

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .image_processing_vit_hybrid import ViTHybridImageProcessor


else:
   import sys

   __lowerCamelCase								=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





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  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case       ,	__snake_case=None     )  ->  Any:






      '''simple docstring'''







      UpperCAmelCase_	:						Dict					   =		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.
            UpperCAmelCase_	:						Optional[Any]					   =		weight.view(torch.intaa     )
            UpperCAmelCase_	:						Dict					   =		"bfloat16"
      UpperCAmelCase_	:						Optional[int]					   =		weight.cpu().numpy()
      UpperCAmelCase_	:						Tuple					   =		os.path.join(__snake_case       ,	F"""{weight_name}.dat"""     )
      if index is not None:
            if dtype is None:
                  UpperCAmelCase_	:						int					   =		str(array.dtype     )
            UpperCAmelCase_	:						Any					   =		{"dtype": dtype, "shape": list(array.shape     )}
      if array.ndim == 0:
            UpperCAmelCase_	:						List[str]					   =		array[None]
      UpperCAmelCase_	:						List[Any]					   =		np.memmap(__snake_case       ,	dtype=array.dtype       ,	mode="w+"       ,	shape=array.shape     )
      UpperCAmelCase_	:						List[str]					   =		array[:]
      file_array.flush()
      return index







def  _snake_case			(							__snake_case       ,	__snake_case     )  ->  Any:






      '''simple docstring'''







      UpperCAmelCase_	:						Union[str, Any]					   =		tuple(weight_info["shape"]     )
      if shape == ():
            # NumPy memory-mapped arrays can't have 0 dims so it was saved as 1d tensor
            UpperCAmelCase_	:						Dict					   =		(1,)

      UpperCAmelCase_	:						Tuple					   =		weight_info["dtype"]
      if dtype == "bfloat16":
            # NumPy does not support bfloat16 so this was saved as a int16
            UpperCAmelCase_	:						Tuple					   =		"int16"

      UpperCAmelCase_	:						Union[str, Any]					   =		np.memmap(__snake_case       ,	dtype=__snake_case       ,	shape=__snake_case       ,	mode="r"     )

      if len(weight_info["shape"]     ) == 0:
            UpperCAmelCase_	:						Optional[Any]					   =		weight[0]
      UpperCAmelCase_	:						List[str]					   =		torch.tensor(__snake_case     )
      if weight_info["dtype"] == "bfloat16":
            UpperCAmelCase_	:						Union[str, Any]					   =		weight.view(torch.bfloataa     )

      return weight







def  _snake_case			(							__snake_case       ,	__snake_case     )  ->  List[Any]:






      '''simple docstring'''







      if index is None or len(__snake_case     ) == 0:
            # Nothing to save
            return

      UpperCAmelCase_	:						str					   =		os.path.join(__snake_case       ,	"index.json"     )
      if os.path.isfile(__snake_case     ):
            with open(__snake_case       ,	"r"       ,	encoding="utf-8"     ) as f:
                  UpperCAmelCase_	:						str					   =		json.load(__snake_case     )
      else:
            UpperCAmelCase_	:						Dict					   =		{}
      current_index.update(__snake_case     )

      with open(__snake_case       ,	"w"       ,	encoding="utf-8"     ) as f:
            json.dump(__snake_case       ,	__snake_case       ,	indent=2     )







def  _snake_case			(							__snake_case       ,	__snake_case     )  ->  Union[str, Any]:






      '''simple docstring'''







      os.makedirs(__snake_case       ,	exist_ok=__snake_case     )
      UpperCAmelCase_	:						Any					   =		{}
      for name, parameter in state_dict.items():
            UpperCAmelCase_	:						Tuple					   =		offload_weight(__snake_case       ,	__snake_case       ,	__snake_case       ,	index=__snake_case     )

      # Update index
      save_offload_index(__snake_case       ,	__snake_case     )


class 	snake_case_			(lowercase__	):




       """simple docstring"""






       def __init__(  self  ,lowercase  ,lowercase):

             """simple docstring"""





             UpperCAmelCase_	:						Optional[Any]					   =		dataset
             UpperCAmelCase_	:						Any					   =		prefix



       def __getitem__(  self  ,lowercase):

             """simple docstring"""





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



       def __iter__(  self):

             """simple docstring"""





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



       def __len__(  self):

             """simple docstring"""





             return len(self.dataset)


class 	snake_case_			(lowercase__	):




       """simple docstring"""






       def __init__(  self  ,lowercase = None  ,lowercase = None  ,lowercase = None  ,lowercase=None  ,):

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

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



       def __getitem__(  self  ,lowercase):

             """simple docstring"""





             if key in self.state_dict:
                   return self.state_dict[key]
             UpperCAmelCase_	:						str					   =		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

                   UpperCAmelCase_	:						Any					   =		"cpu" if self.device is None else self.device
                   with safe_open(weight_info["safetensors_file"]  ,framework="pt"  ,device=lowercase) as f:
                         UpperCAmelCase_	:						int					   =		f.get_tensor(weight_info.get("weight_name"  ,lowercase))

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

             UpperCAmelCase_	:						Optional[int]					   =		os.path.join(self.save_folder  ,F"""{key}.dat""")
             return load_offloaded_weight(lowercase  ,lowercase)



       def __iter__(  self):

             """simple docstring"""





             return iter(self.all_keys)



       def __len__(  self):

             """simple docstring"""





             return len(self.all_keys)







def  _snake_case			(							__snake_case       ,	__snake_case     )  ->  Optional[Any]:






      '''simple docstring'''







      UpperCAmelCase_	:						str					   =		{}
      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
