
# 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


lowerCamelCase_						     =					logging.get_logger(__name__)




@dataclass
class      __A:

  """simple docstring"""







  def __init__(self	,      SCREAMING_SNAKE_CASE_=False	,      SCREAMING_SNAKE_CASE_=False	,      SCREAMING_SNAKE_CASE_=6.0	,      SCREAMING_SNAKE_CASE_=None	,      SCREAMING_SNAKE_CASE_=False	,      SCREAMING_SNAKE_CASE_=False	,      SCREAMING_SNAKE_CASE_=None	,      SCREAMING_SNAKE_CASE_="fp4"	,      SCREAMING_SNAKE_CASE_=False	,      **SCREAMING_SNAKE_CASE_	,      ):
       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(SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
            UpperCamelCase__				=    getattr(SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						)
       elif isinstance(SCREAMING_SNAKE_CASE_	,      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 	UpperCAmelCase_ (self						):
       if not isinstance(self.llm_inta_threshold	,      SCREAMING_SNAKE_CASE_						):
            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	,      SCREAMING_SNAKE_CASE_						):
            raise ValueError("""llm_int8_skip_modules must be a list of strings"""						)
       if not isinstance(self.llm_inta_enable_fpaa_cpu_offload	,      SCREAMING_SNAKE_CASE_						):
            raise ValueError("""llm_int8_enable_fp32_cpu_offload must be a boolean"""						)

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

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







  def 	UpperCAmelCase_ (self						):
       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	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_	,      **SCREAMING_SNAKE_CASE_						):
       UpperCamelCase__				=    cls(**SCREAMING_SNAKE_CASE_						)

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

       if return_unused_kwargs:
            return config, kwargs
       else:
            return config







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

            writer.write(SCREAMING_SNAKE_CASE_						)







  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    copy.deepcopy(self.__dict__						)
       UpperCamelCase__				=    str(output["""bnb_4bit_compute_dtype"""]						).split("""."""						)[1]

       return output







  def __repr__(self						):
       return F"{self.__class__.__name__} {self.to_json_string()}"







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







  def 	UpperCAmelCase_ (self						):
       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







import hashlib
import unittest
from typing import Dict

import numpy as np

from transformers import (
    MODEL_FOR_MASK_GENERATION_MAPPING,
    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
    is_vision_available,
    pipeline,
)
from transformers.pipelines import MaskGenerationPipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)


if is_vision_available():
    from PIL import Image
else:




    class      __A:

      """simple docstring"""







      @staticmethod
      def 	UpperCAmelCase_ (*SCREAMING_SNAKE_CASE_	,      **SCREAMING_SNAKE_CASE_						):
           pass






def 						__magic_name__			(   __a      :	Image						):



     '''simple docstring'''




     UpperCamelCase__				=    hashlib.mda(image.tobytes()						)
     return m.hexdigest()[:10]






def 						__magic_name__			(   __a      :	Image						):



     '''simple docstring'''




     UpperCamelCase__				=    np.array(__a						)
     UpperCamelCase__				=    npimg.shape
     return {"hash": hashimage(__a						), "shape": shape}




@is_pipeline_test
@require_vision
@require_torch
class      __A(    unittest.TestCase			):

  """simple docstring"""
  SCREAMING_SNAKE_CASE__         =      dict(
      (list(MODEL_FOR_MASK_GENERATION_MAPPING.items()			) if MODEL_FOR_MASK_GENERATION_MAPPING else [])			)
  SCREAMING_SNAKE_CASE__         =      dict(
      (list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items()			) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else [])			)







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
       UpperCamelCase__				=    MaskGenerationPipeline(model=SCREAMING_SNAKE_CASE_	,      image_processor=SCREAMING_SNAKE_CASE_						)
       return image_segmenter, [
           "./tests/fixtures/tests_samples/COCO/000000039769.png",
           "./tests/fixtures/tests_samples/COCO/000000039769.png",
       ]







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
       pass







  @require_tf
  @unittest.skip("""Image segmentation not implemented in TF"""						)
  def 	UpperCAmelCase_ (self						):
       pass







  @slow
  @require_torch
  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    pipeline("""mask-generation"""	,      model="""facebook/sam-vit-huge"""						)

       UpperCamelCase__				=    image_segmenter("""http://images.cocodataset.org/val2017/000000039769.jpg"""	,      points_per_batch=2_56						)

       # Shortening by hashing
       UpperCamelCase__				=    []
       for i, o in enumerate(outputs["""masks"""]						):
            new_outupt += [{"mask": mask_to_test_readable(SCREAMING_SNAKE_CASE_						), "scores": outputs["scores"][i]}]

       # fmt: off
       self.assertEqual(
           nested_simplify(SCREAMING_SNAKE_CASE_	,      decimals=4						)	,      [
               {"""mask""": {"""hash""": """115ad19f5f""", """shape""": (4_80, 6_40)}, """scores""": 1.0444},
               {"""mask""": {"""hash""": """6affa964c6""", """shape""": (4_80, 6_40)}, """scores""": 1.021},
               {"""mask""": {"""hash""": """dfe28a0388""", """shape""": (4_80, 6_40)}, """scores""": 1.0167},
               {"""mask""": {"""hash""": """c0a5f4a318""", """shape""": (4_80, 6_40)}, """scores""": 1.0132},
               {"""mask""": {"""hash""": """fe8065c197""", """shape""": (4_80, 6_40)}, """scores""": 1.0053},
               {"""mask""": {"""hash""": """e2d0b7a0b7""", """shape""": (4_80, 6_40)}, """scores""": 0.9967},
               {"""mask""": {"""hash""": """453c7844bd""", """shape""": (4_80, 6_40)}, """scores""": 0.993},
               {"""mask""": {"""hash""": """3d44f2926d""", """shape""": (4_80, 6_40)}, """scores""": 0.9909},
               {"""mask""": {"""hash""": """64033ddc3f""", """shape""": (4_80, 6_40)}, """scores""": 0.9879},
               {"""mask""": {"""hash""": """801064ff79""", """shape""": (4_80, 6_40)}, """scores""": 0.9834},
               {"""mask""": {"""hash""": """6172f276ef""", """shape""": (4_80, 6_40)}, """scores""": 0.9716},
               {"""mask""": {"""hash""": """b49e60e084""", """shape""": (4_80, 6_40)}, """scores""": 0.9612},
               {"""mask""": {"""hash""": """a811e775fd""", """shape""": (4_80, 6_40)}, """scores""": 0.9599},
               {"""mask""": {"""hash""": """a6a8ebcf4b""", """shape""": (4_80, 6_40)}, """scores""": 0.9552},
               {"""mask""": {"""hash""": """9d8257e080""", """shape""": (4_80, 6_40)}, """scores""": 0.9532},
               {"""mask""": {"""hash""": """32de6454a8""", """shape""": (4_80, 6_40)}, """scores""": 0.9516},
               {"""mask""": {"""hash""": """af3d4af2c8""", """shape""": (4_80, 6_40)}, """scores""": 0.9499},
               {"""mask""": {"""hash""": """3c6db475fb""", """shape""": (4_80, 6_40)}, """scores""": 0.9483},
               {"""mask""": {"""hash""": """c290813fb9""", """shape""": (4_80, 6_40)}, """scores""": 0.9464},
               {"""mask""": {"""hash""": """b6f0b8f606""", """shape""": (4_80, 6_40)}, """scores""": 0.943},
               {"""mask""": {"""hash""": """92ce16bfdf""", """shape""": (4_80, 6_40)}, """scores""": 0.943},
               {"""mask""": {"""hash""": """c749b25868""", """shape""": (4_80, 6_40)}, """scores""": 0.9408},
               {"""mask""": {"""hash""": """efb6cab859""", """shape""": (4_80, 6_40)}, """scores""": 0.9335},
               {"""mask""": {"""hash""": """1ff2eafb30""", """shape""": (4_80, 6_40)}, """scores""": 0.9326},
               {"""mask""": {"""hash""": """788b798e24""", """shape""": (4_80, 6_40)}, """scores""": 0.9262},
               {"""mask""": {"""hash""": """abea804f0e""", """shape""": (4_80, 6_40)}, """scores""": 0.8999},
               {"""mask""": {"""hash""": """7b9e8ddb73""", """shape""": (4_80, 6_40)}, """scores""": 0.8986},
               {"""mask""": {"""hash""": """cd24047c8a""", """shape""": (4_80, 6_40)}, """scores""": 0.8984},
               {"""mask""": {"""hash""": """6943e6bcbd""", """shape""": (4_80, 6_40)}, """scores""": 0.8873},
               {"""mask""": {"""hash""": """b5f47c9191""", """shape""": (4_80, 6_40)}, """scores""": 0.8871}
           ]	,      )
       # fmt: on







  @require_torch
  @slow
  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    """facebook/sam-vit-huge"""
       UpperCamelCase__				=    pipeline("""mask-generation"""	,      model=SCREAMING_SNAKE_CASE_						)

       UpperCamelCase__				=    image_segmenter(
           """http://images.cocodataset.org/val2017/000000039769.jpg"""	,      pred_iou_thresh=1	,      points_per_batch=2_56						)

       # Shortening by hashing
       UpperCamelCase__				=    []
       for i, o in enumerate(outputs["""masks"""]						):
            new_outupt += [{"mask": mask_to_test_readable(SCREAMING_SNAKE_CASE_						), "scores": outputs["scores"][i]}]

       self.assertEqual(
           nested_simplify(SCREAMING_SNAKE_CASE_	,      decimals=4						)	,      [
               {"""mask""": {"""hash""": """115ad19f5f""", """shape""": (4_80, 6_40)}, """scores""": 1.0444},
               {"""mask""": {"""hash""": """6affa964c6""", """shape""": (4_80, 6_40)}, """scores""": 1.0210},
               {"""mask""": {"""hash""": """dfe28a0388""", """shape""": (4_80, 6_40)}, """scores""": 1.0167},
               {"""mask""": {"""hash""": """c0a5f4a318""", """shape""": (4_80, 6_40)}, """scores""": 1.0132},
               {"""mask""": {"""hash""": """fe8065c197""", """shape""": (4_80, 6_40)}, """scores""": 1.0053},
           ]	,      )





