





'''simple docstring'''
# 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


a__							:							List[Any] =logging.get_logger(__name__)

@dataclass
class      snake_case     :




 """simple docstring"""



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

        if bnb_abit_compute_dtype is None:
               __UpperCamelCase       =  torch.floataa
        elif isinstance(__A							,	__A	):
               __UpperCamelCase       =  getattr(__A							,	__A	)
        elif isinstance(__A							,	torch.dtype	):
               __UpperCamelCase       =  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       :							int	):
        if not isinstance(self.llm_inta_threshold							,	__A	):
               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							,	__A	):
               raise ValueError('llm_int8_skip_modules must be a list of strings'	)
        if not isinstance(self.llm_inta_enable_fpaa_cpu_offload							,	__A	):
               raise ValueError('llm_int8_enable_fp32_cpu_offload must be a boolean'	)

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

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






 def        _lowerCamelCase					(       self       :							Any	):
        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       :							Dict							,	__A       :							Tuple							,	__A       :							Dict							,	**__A       :							List[Any]	):
        __UpperCamelCase       =  cls(**__A	)

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

        if return_unused_kwargs:
               return config, kwargs
        else:
               return config






 def        _lowerCamelCase					(       self       :							Optional[Any]							,	__A       :							Union[str, os.PathLike]	):
        with open(__A							,	'w'							,	encoding='utf-8'	) as writer:
               __UpperCamelCase       =  self.to_dict()
               __UpperCamelCase       =  json.dumps(__A							,	indent=2							,	sort_keys=__A	) + '\n'

               writer.write(__A	)






 def        _lowerCamelCase					(       self       :							Optional[int]	):
        __UpperCamelCase       =  copy.deepcopy(self.__dict__	)
        __UpperCamelCase       =  str(output['bnb_4bit_compute_dtype']	).split('.'	)[1]

        return output






 def __repr__(       self       :							Any	):
        return f'''{self.__class__.__name__} {self.to_json_string()}'''






 def        _lowerCamelCase					(       self       :							List[str]							,	__A       :							bool = True	):
        if use_diff is True:
               __UpperCamelCase       =  self.to_diff_dict()
        else:
               __UpperCamelCase       =  self.to_dict()
        return json.dumps(__A							,	indent=2							,	sort_keys=__A	) + "\n"






 def        _lowerCamelCase					(       self       :							Union[str, Any]	):
        __UpperCamelCase       =  self.to_dict()

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

        __UpperCamelCase       =  {}

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

        return serializable_config_dict







'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a__							:							List[Any] ={
    '''configuration_timesformer''': ['''TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TimesformerConfig'''],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    a__							:							Optional[int] =[
        '''TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''TimesformerModel''',
        '''TimesformerForVideoClassification''',
        '''TimesformerPreTrainedModel''',
    ]

if TYPE_CHECKING:
    from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_timesformer import (
            TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
            TimesformerForVideoClassification,
            TimesformerModel,
            TimesformerPreTrainedModel,
        )

else:
    import sys

    a__							:							Optional[int] =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
