






# 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   lowerCamelCase      :







		'''simple docstring'''



		def __init__(							self				,		_UpperCamelCase=False				,		_UpperCamelCase=False				,		_UpperCamelCase=6.0				,		_UpperCamelCase=None				,		_UpperCamelCase=False				,		_UpperCamelCase=False				,		_UpperCamelCase=None				,		_UpperCamelCase="fp4"				,		_UpperCamelCase=False				,		**_UpperCamelCase				,		)	->							Optional[int]:
							UpperCAmelCase_    :      Union[str, Any]            =						load_in_abit
							UpperCAmelCase_    :      Any            =						load_in_abit
							UpperCAmelCase_    :      List[Any]            =						llm_inta_threshold
							UpperCAmelCase_    :      Tuple            =						llm_inta_skip_modules
							UpperCAmelCase_    :      Tuple            =						llm_inta_enable_fpaa_cpu_offload
							UpperCAmelCase_    :      Optional[Any]            =						llm_inta_has_fpaa_weight
							UpperCAmelCase_    :      Union[str, Any]            =						bnb_abit_quant_type
							UpperCAmelCase_    :      Dict            =						bnb_abit_use_double_quant

							if bnb_abit_compute_dtype is None:
												UpperCAmelCase_    :      int            =						torch.floataa
							elif isinstance(_UpperCamelCase				,		_UpperCamelCase   ):
												UpperCAmelCase_    :      str            =						getattr(_UpperCamelCase				,		_UpperCamelCase   )
							elif isinstance(_UpperCamelCase				,		torch.dtype   ):
												UpperCAmelCase_    :      Optional[Any]            =						bnb_abit_compute_dtype
							else:
												raise ValueError('bnb_4bit_compute_dtype must be a string or a torch.dtype'   )

							self.post_init()



		def 					__UpperCAmelCase			(							self   )	->							int:
							if not isinstance(self.llm_inta_threshold				,		_UpperCamelCase   ):
												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				,		_UpperCamelCase   ):
												raise ValueError('llm_int8_skip_modules must be a list of strings'   )
							if not isinstance(self.llm_inta_enable_fpaa_cpu_offload				,		_UpperCamelCase   ):
												raise ValueError('llm_int8_enable_fp32_cpu_offload must be a boolean'   )

							if not isinstance(self.llm_inta_has_fpaa_weight				,		_UpperCamelCase   ):
												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				,		_UpperCamelCase   ):
												raise ValueError('bnb_4bit_quant_type must be a string'   )

							if not isinstance(self.bnb_abit_use_double_quant				,		_UpperCamelCase   ):
												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 					__UpperCAmelCase			(							self   )	->							str:
							return self.load_in_abit or self.load_in_abit



		def 					__UpperCAmelCase			(							self   )	->							List[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 					__UpperCAmelCase			(							cls				,		_UpperCamelCase				,		_UpperCamelCase				,		**_UpperCamelCase   )	->							Tuple:
							UpperCAmelCase_    :      str            =						cls(**_UpperCamelCase   )

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

							if return_unused_kwargs:
												return config, kwargs
							else:
												return config



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase   )	->							int:
							with open(_UpperCamelCase				,		'w'				,		encoding='utf-8'   ) as writer:
												UpperCAmelCase_    :      Union[str, Any]            =						self.to_dict()
												UpperCAmelCase_    :      Optional[Any]            =						json.dumps(_UpperCamelCase				,		indent=2				,		sort_keys=_UpperCamelCase   ) + '\n'

												writer.write(_UpperCamelCase   )



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

							return output



		def __repr__(							self   )	->							Optional[Any]:
							return f"{self.__class__.__name__} {self.to_json_string()}"



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase = True   )	->							str:
							if use_diff is True:
												UpperCAmelCase_    :      Tuple            =						self.to_diff_dict()
							else:
												UpperCAmelCase_    :      Dict            =						self.to_dict()
							return json.dumps(_UpperCamelCase				,		indent=2				,		sort_keys=_UpperCamelCase   ) + "\n"



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

							# get the default config dict
							UpperCAmelCase_    :      Optional[Any]            =						BitsAndBytesConfig().to_dict()

							UpperCAmelCase_    :      Optional[int]            =						{}

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

							return serializable_config_dict














from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCAmelCase								=						{
    'configuration_time_series_transformer': [
        'TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'TimeSeriesTransformerConfig',
    ],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__UpperCAmelCase								=						[
		    'TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'TimeSeriesTransformerForPrediction',
		    'TimeSeriesTransformerModel',
		    'TimeSeriesTransformerPreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_time_series_transformer import (
		    TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    TimeSeriesTransformerConfig,
		)

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_time_series_transformer import (
				    TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TimeSeriesTransformerForPrediction,
				    TimeSeriesTransformerModel,
				    TimeSeriesTransformerPreTrainedModel,
				)

else:
		import sys

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






