





# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
import importlib.metadata
import json
import os
from dataclasses import dataclass
from typing import Any, Dict, Union

from packaging import version

from ..utils import is_torch_available, logging


if is_torch_available():
     import torch


UpperCAmelCase_ 							=       logging.get_logger(__name__)
@dataclass
class      UpperCamelCase_						:




     def __init__(						self			,  lowerCAmelCase_=False			,  lowerCAmelCase_=False			,  lowerCAmelCase_=6.0			,  lowerCAmelCase_=None			,  lowerCAmelCase_=False			,  lowerCAmelCase_=False			,  lowerCAmelCase_=None			,  lowerCAmelCase_="fp4"			,  lowerCAmelCase_=False			,  **lowerCAmelCase_			,  )						->							Tuple:
          _snake_case													=			load_in_abit
          _snake_case													=			load_in_abit
          _snake_case													=			llm_inta_threshold
          _snake_case													=			llm_inta_skip_modules
          _snake_case													=			llm_inta_enable_fpaa_cpu_offload
          _snake_case													=			llm_inta_has_fpaa_weight
          _snake_case													=			bnb_abit_quant_type
          _snake_case													=			bnb_abit_use_double_quant

          if bnb_abit_compute_dtype is None:
               _snake_case													=			torch.floataa
          elif isinstance(lowerCAmelCase_			,  lowerCAmelCase_					):
               _snake_case													=			getattr(lowerCAmelCase_			,  lowerCAmelCase_					)
          elif isinstance(lowerCAmelCase_			,  torch.dtype					):
               _snake_case													=			bnb_abit_compute_dtype
          else:
               raise ValueError('bnb_4bit_compute_dtype must be a string or a torch.dtype'					)

          self.post_init()




     def 		lowerCAmelCase     (						self					)						->							Tuple:
          if not isinstance(self.llm_inta_threshold			,  lowerCAmelCase_					):
               raise ValueError('llm_int8_threshold must be a float'					)

          if self.llm_inta_skip_modules is not None and not isinstance(self.llm_inta_skip_modules			,  lowerCAmelCase_					):
               raise ValueError('llm_int8_skip_modules must be a list of strings'					)
          if not isinstance(self.llm_inta_enable_fpaa_cpu_offload			,  lowerCAmelCase_					):
               raise ValueError('llm_int8_enable_fp32_cpu_offload must be a boolean'					)

          if not isinstance(self.llm_inta_has_fpaa_weight			,  lowerCAmelCase_					):
               raise ValueError('llm_int8_has_fp16_weight must be a boolean'					)

          if self.bnb_abit_compute_dtype is not None and not isinstance(self.bnb_abit_compute_dtype			,  torch.dtype					):
               raise ValueError('bnb_4bit_compute_dtype must be torch.dtype'					)

          if not isinstance(self.bnb_abit_quant_type			,  lowerCAmelCase_					):
               raise ValueError('bnb_4bit_quant_type must be a string'					)

          if not isinstance(self.bnb_abit_use_double_quant			,  lowerCAmelCase_					):
               raise ValueError('bnb_4bit_use_double_quant must be a boolean'					)

          if self.load_in_abit and not version.parse(importlib.metadata.version('bitsandbytes'					)					) >= version.parse(
              '0.39.0'					):
               raise ValueError(
                   '4 bit quantization requires bitsandbytes>=0.39.0 - please upgrade your bitsandbytes version'					)




     def 		lowerCAmelCase     (						self					)						->							Optional[Any]:
          return self.load_in_abit or self.load_in_abit




     def 		lowerCAmelCase     (						self					)						->							str:
          if self.load_in_abit:
               return "llm_int8"
          elif self.load_in_abit and self.bnb_abit_quant_type == "fp4":
               return "fp4"
          elif self.load_in_abit and self.bnb_abit_quant_type == "nf4":
               return "nf4"
          else:
               return None




     @classmethod
     def 		lowerCAmelCase     (						cls			,  lowerCAmelCase_			,  lowerCAmelCase_			,  **lowerCAmelCase_					)						->							List[Any]:
          _snake_case													=			cls(**lowerCAmelCase_					)

          _snake_case													=			[]
          for key, value in kwargs.items():
               if hasattr(lowerCAmelCase_			,  lowerCAmelCase_					):
                    setattr(lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)
                    to_remove.append(lowerCAmelCase_					)
          for key in to_remove:
               kwargs.pop(lowerCAmelCase_			,  lowerCAmelCase_					)

          if return_unused_kwargs:
               return config, kwargs
          else:
               return config




     def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							Optional[int]:
          with open(lowerCAmelCase_			,  'w'			,  encoding='utf-8'					) as writer:
               _snake_case													=			self.to_dict()
               _snake_case													=			json.dumps(lowerCAmelCase_			,  indent=2			,  sort_keys=lowerCAmelCase_					) + '\n'

               writer.write(lowerCAmelCase_					)




     def 		lowerCAmelCase     (						self					)						->							Dict[str, Any]:
          _snake_case													=			copy.deepcopy(self.__dict__					)
          _snake_case													=			str(output['bnb_4bit_compute_dtype']					).split('.'					)[1]

          return output




     def __repr__(						self					)						->							str:
          return F'''{self.__class__.__name__} {self.to_json_string()}'''




     def 		lowerCAmelCase     (						self			,  lowerCAmelCase_ = True					)						->							str:
          if use_diff is True:
               _snake_case													=			self.to_diff_dict()
          else:
               _snake_case													=			self.to_dict()
          return json.dumps(lowerCAmelCase_			,  indent=2			,  sort_keys=lowerCAmelCase_					) + "\n"






     def 		lowerCAmelCase     (						self					)						->							Dict[str, Any]:
          _snake_case													=			self.to_dict()

          # get the default config dict
          _snake_case													=			BitsAndBytesConfig().to_dict()

          _snake_case													=			{}

          # only serialize values that differ from the default config
          for key, value in config_dict.items():
               if value != default_config_dict[key]:
                    _snake_case													=			value

          return serializable_config_dict










import warnings

from ...utils import logging
from .image_processing_flava import FlavaImageProcessor


UpperCAmelCase_ 							=       logging.get_logger(__name__)
class      UpperCamelCase_						(					_lowerCamelCase   ):




					def __init__(						self			,  *lowerCAmelCase_			,  **lowerCAmelCase_					)						->							None:
										warnings.warn(
										    'The class FlavaFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'
										    ' use FlavaImageProcessor instead.'			,  lowerCAmelCase_			,  )
										super().__init__(*lowerCAmelCase_			,  **lowerCAmelCase_					)



