

from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers.models.layoutlm.modeling_tf_layoutlm import (
        TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFLayoutLMForMaskedLM,
        TFLayoutLMForQuestionAnswering,
        TFLayoutLMForSequenceClassification,
        TFLayoutLMForTokenClassification,
        TFLayoutLMModel,
    )

class     __snake_case    :
       """simple docstring"""







       def __init__(		self      , _UpperCamelCase      , _UpperCamelCase=13      , _UpperCamelCase=7      , _UpperCamelCase=True      , _UpperCamelCase=True      , _UpperCamelCase=True      , _UpperCamelCase=True      , _UpperCamelCase=99      , _UpperCamelCase=32      , _UpperCamelCase=2      , _UpperCamelCase=4      , _UpperCamelCase=37      , _UpperCamelCase="gelu"      , _UpperCamelCase=0.1      , _UpperCamelCase=0.1      , _UpperCamelCase=5_12      , _UpperCamelCase=16      , _UpperCamelCase=2      , _UpperCamelCase=0.02      , _UpperCamelCase=3      , _UpperCamelCase=4      , _UpperCamelCase=None      , _UpperCamelCase=10_00      , )      ->							str:






              """simple docstring"""


              __snake_case       	=							parent
              __snake_case       	=							batch_size
              __snake_case       	=							seq_length
              __snake_case       	=							is_training
              __snake_case       	=							use_input_mask
              __snake_case       	=							use_token_type_ids
              __snake_case       	=							use_labels
              __snake_case       	=							vocab_size
              __snake_case       	=							hidden_size
              __snake_case       	=							num_hidden_layers
              __snake_case       	=							num_attention_heads
              __snake_case       	=							intermediate_size
              __snake_case       	=							hidden_act
              __snake_case       	=							hidden_dropout_prob
              __snake_case       	=							attention_probs_dropout_prob
              __snake_case       	=							max_position_embeddings
              __snake_case       	=							type_vocab_size
              __snake_case       	=							type_sequence_label_size
              __snake_case       	=							initializer_range
              __snake_case       	=							num_labels
              __snake_case       	=							num_choices
              __snake_case       	=							scope
              __snake_case       	=							range_bbox


       def 			a		(		self   )      ->							Tuple:






              """simple docstring"""


              __snake_case       	=							ids_tensor([self.batch_size, self.seq_length]      , self.vocab_size   )

              # convert bbox to numpy since TF does not support item assignment
              __snake_case       	=							ids_tensor([self.batch_size, self.seq_length, 4]      , self.range_bbox   ).numpy()
              # Ensure that bbox is legal
              for i in range(bbox.shape[0]   ):
                     for j in range(bbox.shape[1]   ):
                            if bbox[i, j, 3] < bbox[i, j, 1]:
                                   __snake_case       	=							bbox[i, j, 3]
                                   __snake_case       	=							bbox[i, j, 1]
                                   __snake_case       	=							t
                            if bbox[i, j, 2] < bbox[i, j, 0]:
                                   __snake_case       	=							bbox[i, j, 2]
                                   __snake_case       	=							bbox[i, j, 0]
                                   __snake_case       	=							t
              __snake_case       	=							tf.convert_to_tensor(_UpperCamelCase   )

              __snake_case       	=							None
              if self.use_input_mask:
                     __snake_case       	=							random_attention_mask([self.batch_size, self.seq_length]   )

              __snake_case       	=							None
              if self.use_token_type_ids:
                     __snake_case       	=							ids_tensor([self.batch_size, self.seq_length]      , self.type_vocab_size   )

              __snake_case       	=							None
              __snake_case       	=							None
              __snake_case       	=							None
              if self.use_labels:
                     __snake_case       	=							ids_tensor([self.batch_size]      , self.type_sequence_label_size   )
                     __snake_case       	=							ids_tensor([self.batch_size, self.seq_length]      , self.num_labels   )
                     __snake_case       	=							ids_tensor([self.batch_size]      , self.num_choices   )

              __snake_case       	=							LayoutLMConfig(
                  vocab_size=self.vocab_size      , hidden_size=self.hidden_size      , num_hidden_layers=self.num_hidden_layers      , num_attention_heads=self.num_attention_heads      , intermediate_size=self.intermediate_size      , hidden_act=self.hidden_act      , hidden_dropout_prob=self.hidden_dropout_prob      , attention_probs_dropout_prob=self.attention_probs_dropout_prob      , max_position_embeddings=self.max_position_embeddings      , type_vocab_size=self.type_vocab_size      , initializer_range=self.initializer_range      , )

              return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


       def 			a		(		self      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase   )      ->							Any:






              """simple docstring"""


              __snake_case       	=							TFLayoutLMModel(config=_UpperCamelCase   )

              __snake_case       	=							model(_UpperCamelCase      , _UpperCamelCase      , attention_mask=_UpperCamelCase      , token_type_ids=_UpperCamelCase   )
              __snake_case       	=							model(_UpperCamelCase      , _UpperCamelCase      , token_type_ids=_UpperCamelCase   )
              __snake_case       	=							model(_UpperCamelCase      , _UpperCamelCase   )
              self.parent.assertEqual(result.last_hidden_state.shape      , (self.batch_size, self.seq_length, self.hidden_size)   )
              self.parent.assertEqual(result.pooler_output.shape      , (self.batch_size, self.hidden_size)   )


       def 			a		(		self      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase   )      ->							Optional[int]:






              """simple docstring"""


              __snake_case       	=							TFLayoutLMForMaskedLM(config=_UpperCamelCase   )

              __snake_case       	=							model(_UpperCamelCase      , _UpperCamelCase      , attention_mask=_UpperCamelCase      , token_type_ids=_UpperCamelCase      , labels=_UpperCamelCase   )
              self.parent.assertEqual(result.logits.shape      , (self.batch_size, self.seq_length, self.vocab_size)   )


       def 			a		(		self      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase   )      ->							List[str]:






              """simple docstring"""


              __snake_case       	=							self.num_labels
              __snake_case       	=							TFLayoutLMForSequenceClassification(config=_UpperCamelCase   )

              __snake_case       	=							model(_UpperCamelCase      , _UpperCamelCase      , attention_mask=_UpperCamelCase      , token_type_ids=_UpperCamelCase   )
              self.parent.assertEqual(result.logits.shape      , (self.batch_size, self.num_labels)   )


       def 			a		(		self      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase   )      ->							Dict:






              """simple docstring"""


              __snake_case       	=							self.num_labels
              __snake_case       	=							TFLayoutLMForTokenClassification(config=_UpperCamelCase   )

              __snake_case       	=							model(_UpperCamelCase      , _UpperCamelCase      , attention_mask=_UpperCamelCase      , token_type_ids=_UpperCamelCase      , labels=_UpperCamelCase   )
              self.parent.assertEqual(result.logits.shape      , (self.batch_size, self.seq_length, self.num_labels)   )


       def 			a		(		self      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase   )      ->							Dict:






              """simple docstring"""


              __snake_case       	=							TFLayoutLMForQuestionAnswering(config=_UpperCamelCase   )

              __snake_case       	=							model(_UpperCamelCase      , _UpperCamelCase      , attention_mask=_UpperCamelCase      , token_type_ids=_UpperCamelCase   )
              self.parent.assertEqual(result.start_logits.shape      , (self.batch_size, self.seq_length)   )
              self.parent.assertEqual(result.end_logits.shape      , (self.batch_size, self.seq_length)   )






       def 			a		(		self   )      ->							List[str]:






              """simple docstring"""


              __snake_case       	=							self.prepare_config_and_inputs()
              (
                  (
                  __snake_case
              )	,    (
                  __snake_case
              )	,    (
                  __snake_case
              )	,    (
                  __snake_case
              )	,    (
                  __snake_case
              )	,    (
                  __snake_case
              )	,    (
                  __snake_case
              )	,    (
                  __snake_case
              )	,    
              )       	=							config_and_inputs
              __snake_case       	=							{
                  """input_ids""": input_ids,
                  """bbox""": bbox,
                  """token_type_ids""": token_type_ids,
                  """attention_mask""": input_mask,
              }
              return config, inputs_dict






@require_tf
class     __snake_case    (				snake_case__			,	snake_case__			,	unittest.TestCase  ):
       """simple docstring"""







       __SCREAMING_SNAKE_CASE				    =							(
           (
               TFLayoutLMModel,
               TFLayoutLMForMaskedLM,
               TFLayoutLMForTokenClassification,
               TFLayoutLMForSequenceClassification,
               TFLayoutLMForQuestionAnswering,
           )
           if is_tf_available()
           else ()
       )
       __SCREAMING_SNAKE_CASE				    =							(
           {
               "feature-extraction": TFLayoutLMModel,
               "fill-mask": TFLayoutLMForMaskedLM,
               "text-classification": TFLayoutLMForSequenceClassification,
               "token-classification": TFLayoutLMForTokenClassification,
               "zero-shot": TFLayoutLMForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __SCREAMING_SNAKE_CASE				    =							False
       __SCREAMING_SNAKE_CASE				    =							True
       __SCREAMING_SNAKE_CASE				    =							10


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






              """simple docstring"""


              __snake_case       	=							TFLayoutLMModelTester(self   )
              __snake_case       	=							ConfigTester(self      , config_class=_UpperCamelCase      , hidden_size=37   )


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






              """simple docstring"""


              self.config_tester.run_common_tests()


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






              """simple docstring"""


              __snake_case       	=							self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*_UpperCamelCase   )


       def 			a		(		self   )      ->							str:






              """simple docstring"""


              __snake_case       	=							self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase   )


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






              """simple docstring"""


              __snake_case       	=							self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase   )


       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              __snake_case       	=							self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase   )


       def 			a		(		self   )      ->							Any:






              """simple docstring"""


              __snake_case       	=							self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase   )


       @slow
       def 			a		(		self   )      ->							Tuple:






              """simple docstring"""


              for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     __snake_case       	=							TFLayoutLMModel.from_pretrained(_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )






       @unittest.skip("""Onnx compliancy broke with TF 2.10"""   )
       def 			a		(		self   )      ->							Union[str, Any]:






              """simple docstring"""


              pass







def 						lowerCamelCase__      ( ):


       """simple docstring"""




       __snake_case       	=							tf.convert_to_tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]]		)  # noqa: E231
       __snake_case       	=							tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]		)  # noqa: E231
       __snake_case       	=							tf.convert_to_tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]]		)  # noqa: E231
       __snake_case       	=							tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]		)  # noqa: E231
       # these are sequence labels (i.e. at the token level)
       __snake_case       	=							tf.convert_to_tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]]		)  # noqa: E231
       # fmt: on

       return input_ids, attention_mask, bbox, token_type_ids, labels




@require_tf
class     __snake_case    (				unittest.TestCase  ):
       """simple docstring"""







       @slow
       def 			a		(		self   )      ->							List[str]:






              """simple docstring"""


              __snake_case       	=							TFLayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""   )

              __snake_case	,    __snake_case	,    __snake_case	,    __snake_case	,    __snake_case       	=							prepare_layoutlm_batch_inputs()

              # forward pass
              __snake_case       	=							model(input_ids=_UpperCamelCase      , bbox=_UpperCamelCase      , attention_mask=_UpperCamelCase      , token_type_ids=_UpperCamelCase   )

              # test the sequence output on [0, :3, :3]
              __snake_case       	=							tf.convert_to_tensor(
                  [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]      , )

              self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]      , _UpperCamelCase      , atol=1E-3   )   )

              # test the pooled output on [1, :3]
              __snake_case       	=							tf.convert_to_tensor([-0.6580, -0.0214, 0.8552]   )

              self.assertTrue(np.allclose(outputs.pooler_output[1, :3]      , _UpperCamelCase      , atol=1E-3   )   )


       @slow
       def 			a		(		self   )      ->							int:






              """simple docstring"""


              __snake_case       	=							TFLayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""      , num_labels=2   )

              __snake_case	,    __snake_case	,    __snake_case	,    __snake_case	,    __snake_case       	=							prepare_layoutlm_batch_inputs()

              # forward pass
              __snake_case       	=							model(
                  input_ids=_UpperCamelCase      , bbox=_UpperCamelCase      , attention_mask=_UpperCamelCase      , token_type_ids=_UpperCamelCase      , labels=tf.convert_to_tensor([1, 1]   )      , )

              # test whether we get a loss as a scalar
              __snake_case       	=							outputs.loss
              __snake_case       	=							(2,)
              self.assertEqual(loss.shape      , _UpperCamelCase   )

              # test the shape of the logits
              __snake_case       	=							outputs.logits
              __snake_case       	=							(2, 2)
              self.assertEqual(logits.shape      , _UpperCamelCase   )


       @slow
       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              __snake_case       	=							TFLayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""      , num_labels=13   )

              __snake_case	,    __snake_case	,    __snake_case	,    __snake_case	,    __snake_case       	=							prepare_layoutlm_batch_inputs()

              # forward pass
              __snake_case       	=							model(
                  input_ids=_UpperCamelCase      , bbox=_UpperCamelCase      , attention_mask=_UpperCamelCase      , token_type_ids=_UpperCamelCase      , labels=_UpperCamelCase   )

              # test the shape of the logits
              __snake_case       	=							outputs.logits
              __snake_case       	=							tf.convert_to_tensor((2, 25, 13)   )
              self.assertEqual(logits.shape      , _UpperCamelCase   )






       @slow
       def 			a		(		self   )      ->							Dict:






              """simple docstring"""


              __snake_case       	=							TFLayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""   )

              __snake_case	,    __snake_case	,    __snake_case	,    __snake_case	,    __snake_case       	=							prepare_layoutlm_batch_inputs()

              # forward pass
              __snake_case       	=							model(input_ids=_UpperCamelCase      , bbox=_UpperCamelCase      , attention_mask=_UpperCamelCase      , token_type_ids=_UpperCamelCase   )

              # test the shape of the logits
              __snake_case       	=							tf.convert_to_tensor((2, 25)   )
              self.assertEqual(outputs.start_logits.shape      , _UpperCamelCase   )
              self.assertEqual(outputs.end_logits.shape      , _UpperCamelCase   )




# 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     __snake_case    :
       """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      , )      ->							int:






              """simple docstring"""


              __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(_UpperCamelCase      , _UpperCamelCase   ):
                     __snake_case       	=							getattr(_UpperCamelCase      , _UpperCamelCase   )
              elif isinstance(_UpperCamelCase      , 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 			a		(		self   )      ->							Union[str, Any]:






              """simple docstring"""


              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 			a		(		self   )      ->							int:






              """simple docstring"""


              return self.load_in_abit or self.load_in_abit


       def 			a		(		self   )      ->							int:






              """simple docstring"""


              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 			a		(		cls      , _UpperCamelCase      , _UpperCamelCase      , **_UpperCamelCase   )      ->							Union[str, Any]:






              """simple docstring"""


              __snake_case       	=							cls(**_UpperCamelCase   )

              __snake_case       	=							[]
              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 			a		(		self      , _UpperCamelCase   )      ->							int:






              """simple docstring"""


              with open(_UpperCamelCase      , """w"""      , encoding="""utf-8"""   ) as writer:
                     __snake_case       	=							self.to_dict()
                     __snake_case       	=							json.dumps(_UpperCamelCase      , indent=2      , sort_keys=_UpperCamelCase   ) + """\n"""

                     writer.write(_UpperCamelCase   )


       def 			a		(		self   )      ->							Dict[str, Any]:






              """simple docstring"""


              __snake_case       	=							copy.deepcopy(self.__dict__   )
              __snake_case       	=							str(output["""bnb_4bit_compute_dtype"""]   ).split("""."""   )[1]

              return output


       def __repr__(		self   )      ->							Dict:






              """simple docstring"""


              return F'{self.__class__.__name__} {self.to_json_string()}'


       def 			a		(		self      , _UpperCamelCase = True   )      ->							str:






              """simple docstring"""


              if use_diff is True:
                     __snake_case       	=							self.to_diff_dict()
              else:
                     __snake_case       	=							self.to_dict()
              return json.dumps(_UpperCamelCase      , indent=2      , sort_keys=_UpperCamelCase   ) + "\n"






       def 			a		(		self   )      ->							Dict[str, Any]:






              """simple docstring"""


              __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

