


# 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


_lowercase				     = logging.get_logger(__name__)



@dataclass
class 	lowerCamelCase__			:




   def __init__(   self						:						Optional[int]    ,    __a						:						Optional[Any]=False    ,    __a						:						Tuple=False    ,    __a						:						Optional[int]=6.0    ,    __a						:						str=None    ,    __a						:						Union[str, Any]=False    ,    __a						:						Optional[int]=False    ,    __a						:						int=None    ,    __a						:						Any="fp4"    ,    __a						:						str=False    ,    **__a						:						int    ,    ):




         '''simple docstring'''







         lowerCamelCase__:						Optional[Any]							   = load_in_abit
         lowerCamelCase__:						List[Any]							   = load_in_abit
         lowerCamelCase__:						Union[str, Any]							   = llm_inta_threshold
         lowerCamelCase__:						List[Any]							   = llm_inta_skip_modules
         lowerCamelCase__:						Any							   = llm_inta_enable_fpaa_cpu_offload
         lowerCamelCase__:						Tuple							   = llm_inta_has_fpaa_weight
         lowerCamelCase__:						Dict							   = bnb_abit_quant_type
         lowerCamelCase__:						List[str]							   = bnb_abit_use_double_quant

         if bnb_abit_compute_dtype is None:
               lowerCamelCase__:						Union[str, Any]							   = torch.floataa
         elif isinstance(__a    ,    __a							):
               lowerCamelCase__:						Tuple							   = getattr(__a    ,    __a							)
         elif isinstance(__a    ,    torch.dtype							):
               lowerCamelCase__:						int							   = 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						:						Optional[Any]							):




         '''simple docstring'''







         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						:						Union[str, Any]							):




         '''simple docstring'''







         return self.load_in_abit or self.load_in_abit




   def 							lowerCamelCase_   (   self						:						Tuple							):




         '''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 							lowerCamelCase_   (   cls						:						Any    ,    __a						:						str    ,    __a						:						Optional[int]    ,    **__a						:						Any							):




         '''simple docstring'''







         lowerCamelCase__:						Optional[int]							   = cls(**__a							)

         lowerCamelCase__:						int							   = []
         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						:						List[Any]    ,    __a						:						Any							):




         '''simple docstring'''







         with open(__a    ,    """w"""    ,    encoding="""utf-8"""							) as writer:
               lowerCamelCase__:						Union[str, Any]							   = self.to_dict()
               lowerCamelCase__:						int							   = json.dumps(__a    ,    indent=2    ,    sort_keys=__a							) + '\n'

               writer.write(__a							)




   def 							lowerCamelCase_   (   self						:						int							):




         '''simple docstring'''







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

         return output




   def __repr__(   self						:						List[str]							):




         '''simple docstring'''







         return f"""{self.__class__.__name__} {self.to_json_string()}"""




   def 							lowerCamelCase_   (   self						:						Tuple    ,    __a						:						Optional[int] = True							):




         '''simple docstring'''







         if use_diff is True:
               lowerCamelCase__:						int							   = self.to_diff_dict()
         else:
               lowerCamelCase__:						List[str]							   = self.to_dict()
         return json.dumps(__a    ,    indent=2    ,    sort_keys=__a							) + "\n"




   def 							lowerCamelCase_   (   self						:						List[Any]							):




         '''simple docstring'''







         lowerCamelCase__:						Optional[Any]							   = self.to_dict()

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

         lowerCamelCase__:						str							   = {}

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

         return serializable_config_dict










import argparse

from transformers import TaConfig, TaForConditionalGeneration, load_tf_weights_in_ta
from transformers.utils import logging


logging.set_verbosity_info()



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		Optional[int]:
    # Initialise PyTorch model
    _lowercase			:				Optional[int] 						=						TaConfig.from_json_file(lowerCamelCase_					)
    print(F'''Building PyTorch model from configuration: {config}'''					)
    _lowercase			:				Union[str, Any] 						=						TaForConditionalGeneration(lowerCamelCase_					)

    # Load weights from tf checkpoint
    load_tf_weights_in_ta(lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_					)

    # Save pytorch-model
    print(F'''Save PyTorch model to {pytorch_dump_path}'''					)
    model.save_pretrained(lowerCamelCase_					)


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE			: Optional[int]				   =					argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
 )
 parser.add_argument(
     "--config_file",
     default=None,
     type=str,
     required=True,
     help=(
         "The config json file corresponding to the pre-trained T5 model. \nThis specifies the model architecture."
     ),
 )
 parser.add_argument(
     "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
 )
 SCREAMING_SNAKE_CASE			: Any				   =					parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)


