

'''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					:			Dict							=    logging.get_logger(__name__)



@dataclass
class 							lowercase_						:

  '''simple docstring'''





  def __init__(  self ,			a_=False ,			a_=False ,			a_=6.0 ,			a_=None ,			a_=False ,			a_=False ,			a_=None ,			a_="fp4" ,			a_=False ,			**a_ ,			)				->					Any:


    """simple docstring"""
    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     snake_case_      (  self  )				->					List[str]:


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


    """simple docstring"""
    return self.load_in_abit or self.load_in_abit
  def     snake_case_      (  self  )				->					Optional[Any]:


    """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     snake_case_      (  cls ,			a_ ,			a_ ,			**a_  )				->					Any:


    """simple docstring"""
    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     snake_case_      (  self ,			a_  )				->					List[str]:


    """simple docstring"""
    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     snake_case_      (  self  )				->					Dict[str, Any]:


    """simple docstring"""
    UpperCAmelCase    				=						copy.deepcopy(self.__dict__  )
    UpperCAmelCase    				=						str(output['bnb_4bit_compute_dtype']  ).split('.'  )[1]

    return output
  def __repr__(  self  )				->					Optional[int]:


    """simple docstring"""
    return F'''{self.__class__.__name__} {self.to_json_string()}'''
  def     snake_case_      (  self ,			a_ = True  )				->					str:


    """simple docstring"""
    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     snake_case_      (  self  )				->					Dict[str, Any]:


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




import qiskit


def    lowerCamelCase__		(    SCREAMING_SNAKE_CASE   : int							, SCREAMING_SNAKE_CASE   : int    ):
  UpperCAmelCase    				=						qiskit.Aer.get_backend('aer_simulator'    )

  # Create a Quantum Circuit acting on the q register
  UpperCAmelCase    				=						qiskit.QuantumCircuit(SCREAMING_SNAKE_CASE							, SCREAMING_SNAKE_CASE    )

  # Map the quantum measurement to the classical bits
  circuit.measure([0]							, [0]    )

  # Execute the circuit on the simulator
  UpperCAmelCase    				=						qiskit.execute(SCREAMING_SNAKE_CASE							, SCREAMING_SNAKE_CASE							, shots=1000    )

  # Return the histogram data of the results of the experiment.
  return job.result().get_counts(SCREAMING_SNAKE_CASE    )


if __name__ == "__main__":
  print(F'''Total count for various states are: {single_qubit_measure(1, 1)}''')


