
"""simple docstring"""


import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...utils import CONFIG_NAME, FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


SCREAMING_SNAKE_CASE			  =  logging.get_logger(__name__)

SCREAMING_SNAKE_CASE			  =  OrderedDict(
    [
        ("""audio-spectrogram-transformer""", """ASTFeatureExtractor"""),
        ("""beit""", """BeitFeatureExtractor"""),
        ("""chinese_clip""", """ChineseCLIPFeatureExtractor"""),
        ("""clap""", """ClapFeatureExtractor"""),
        ("""clip""", """CLIPFeatureExtractor"""),
        ("""clipseg""", """ViTFeatureExtractor"""),
        ("""conditional_detr""", """ConditionalDetrFeatureExtractor"""),
        ("""convnext""", """ConvNextFeatureExtractor"""),
        ("""cvt""", """ConvNextFeatureExtractor"""),
        ("""data2vec-audio""", """Wav2Vec2FeatureExtractor"""),
        ("""data2vec-vision""", """BeitFeatureExtractor"""),
        ("""deformable_detr""", """DeformableDetrFeatureExtractor"""),
        ("""deit""", """DeiTFeatureExtractor"""),
        ("""detr""", """DetrFeatureExtractor"""),
        ("""dinat""", """ViTFeatureExtractor"""),
        ("""donut-swin""", """DonutFeatureExtractor"""),
        ("""dpt""", """DPTFeatureExtractor"""),
        ("""encodec""", """EncodecFeatureExtractor"""),
        ("""flava""", """FlavaFeatureExtractor"""),
        ("""glpn""", """GLPNFeatureExtractor"""),
        ("""groupvit""", """CLIPFeatureExtractor"""),
        ("""hubert""", """Wav2Vec2FeatureExtractor"""),
        ("""imagegpt""", """ImageGPTFeatureExtractor"""),
        ("""layoutlmv2""", """LayoutLMv2FeatureExtractor"""),
        ("""layoutlmv3""", """LayoutLMv3FeatureExtractor"""),
        ("""levit""", """LevitFeatureExtractor"""),
        ("""maskformer""", """MaskFormerFeatureExtractor"""),
        ("""mctct""", """MCTCTFeatureExtractor"""),
        ("""mobilenet_v1""", """MobileNetV1FeatureExtractor"""),
        ("""mobilenet_v2""", """MobileNetV2FeatureExtractor"""),
        ("""mobilevit""", """MobileViTFeatureExtractor"""),
        ("""nat""", """ViTFeatureExtractor"""),
        ("""owlvit""", """OwlViTFeatureExtractor"""),
        ("""perceiver""", """PerceiverFeatureExtractor"""),
        ("""poolformer""", """PoolFormerFeatureExtractor"""),
        ("""regnet""", """ConvNextFeatureExtractor"""),
        ("""resnet""", """ConvNextFeatureExtractor"""),
        ("""segformer""", """SegformerFeatureExtractor"""),
        ("""sew""", """Wav2Vec2FeatureExtractor"""),
        ("""sew-d""", """Wav2Vec2FeatureExtractor"""),
        ("""speech_to_text""", """Speech2TextFeatureExtractor"""),
        ("""speecht5""", """SpeechT5FeatureExtractor"""),
        ("""swiftformer""", """ViTFeatureExtractor"""),
        ("""swin""", """ViTFeatureExtractor"""),
        ("""swinv2""", """ViTFeatureExtractor"""),
        ("""table-transformer""", """DetrFeatureExtractor"""),
        ("""timesformer""", """VideoMAEFeatureExtractor"""),
        ("""tvlt""", """TvltFeatureExtractor"""),
        ("""unispeech""", """Wav2Vec2FeatureExtractor"""),
        ("""unispeech-sat""", """Wav2Vec2FeatureExtractor"""),
        ("""van""", """ConvNextFeatureExtractor"""),
        ("""videomae""", """VideoMAEFeatureExtractor"""),
        ("""vilt""", """ViltFeatureExtractor"""),
        ("""vit""", """ViTFeatureExtractor"""),
        ("""vit_mae""", """ViTFeatureExtractor"""),
        ("""vit_msn""", """ViTFeatureExtractor"""),
        ("""wav2vec2""", """Wav2Vec2FeatureExtractor"""),
        ("""wav2vec2-conformer""", """Wav2Vec2FeatureExtractor"""),
        ("""wavlm""", """Wav2Vec2FeatureExtractor"""),
        ("""whisper""", """WhisperFeatureExtractor"""),
        ("""xclip""", """CLIPFeatureExtractor"""),
        ("""yolos""", """YolosFeatureExtractor"""),
    ]
)

SCREAMING_SNAKE_CASE			  =  _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)



def 						lowerCamelCase__      (				UpperCAmelCase_					)->				Optional[Any]:







       """simple docstring"""
       for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
              if class_name in extractors:
                     UpperCamelCase       			=		model_type_to_module_name(UpperCAmelCase_					)

                     UpperCamelCase       			=		importlib.import_module(F".{module_name}"		,   "transformers.models"					)
                     try:
                            return getattr(UpperCAmelCase_		,   UpperCAmelCase_					)
                     except AttributeError:
                            continue

       for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
              if getattr(UpperCAmelCase_		,   "__name__"		,   UpperCAmelCase_					) == class_name:
                     return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
       UpperCamelCase       			=		importlib.import_module("transformers"					)
       if hasattr(UpperCAmelCase_		,   UpperCAmelCase_					):
              return getattr(UpperCAmelCase_		,   UpperCAmelCase_					)

       return None



def 						lowerCamelCase__      (				UpperCAmelCase_		,   UpperCAmelCase_ = None		,   UpperCAmelCase_ = False		,   UpperCAmelCase_ = False		,   UpperCAmelCase_ = None		,   UpperCAmelCase_ = None		,   UpperCAmelCase_ = None		,   UpperCAmelCase_ = False		,   **UpperCAmelCase_		,   )->				str:







       """simple docstring"""
       UpperCamelCase       			=		get_file_from_repo(
           UpperCAmelCase_		,   UpperCAmelCase_		,   cache_dir=UpperCAmelCase_		,   force_download=UpperCAmelCase_		,   resume_download=UpperCAmelCase_		,   proxies=UpperCAmelCase_		,   use_auth_token=UpperCAmelCase_		,   revision=UpperCAmelCase_		,   local_files_only=UpperCAmelCase_		,   )
       if resolved_config_file is None:
              logger.info(
                  "Could not locate the feature extractor configuration file, will try to use the model config instead."					)
              return {}

       with open(UpperCAmelCase_		,   encoding="utf-8"					) as reader:
              return json.load(UpperCAmelCase_					)



class 	__a	:






       def __init__(	self			:				Optional[Any]      )->	Optional[int]:







              """simple docstring"""
              raise EnvironmentError(
                  "AutoFeatureExtractor is designed to be instantiated "
                  "using the `AutoFeatureExtractor.from_pretrained(pretrained_model_name_or_path)` method."      )






       @classmethod
       @replace_list_option_in_docstrings(UpperCAmelCase_      )
       def 						_SCREAMING_SNAKE_CASE							(	cls			:				List[Any]							,   UpperCAmelCase_			:				str							,   **UpperCAmelCase_			:				Union[str, Any]      )->	List[str]:







              """simple docstring"""
              UpperCamelCase       			=		kwargs.pop("config"							,   UpperCAmelCase_      )
              UpperCamelCase       			=		kwargs.pop("trust_remote_code"							,   UpperCAmelCase_      )
              UpperCamelCase       			=		True

              UpperCamelCase			,							UpperCamelCase       			=		FeatureExtractionMixin.get_feature_extractor_dict(UpperCAmelCase_							,   **UpperCAmelCase_      )
              UpperCamelCase       			=		config_dict.get("feature_extractor_type"							,   UpperCAmelCase_      )
              UpperCamelCase       			=		None
              if "AutoFeatureExtractor" in config_dict.get("auto_map"							,   {}      ):
                     UpperCamelCase       			=		config_dict["auto_map"]["AutoFeatureExtractor"]

              # If we don't find the feature extractor class in the feature extractor config, let's try the model config.
              if feature_extractor_class is None and feature_extractor_auto_map is None:
                     if not isinstance(UpperCAmelCase_							,   UpperCAmelCase_      ):
                            UpperCamelCase       			=		AutoConfig.from_pretrained(UpperCAmelCase_							,   **UpperCAmelCase_      )
                     # It could be in `config.feature_extractor_type``
                     UpperCamelCase       			=		getattr(UpperCAmelCase_							,   "feature_extractor_type"							,   UpperCAmelCase_      )
                     if hasattr(UpperCAmelCase_							,   "auto_map"      ) and "AutoFeatureExtractor" in config.auto_map:
                            UpperCamelCase       			=		config.auto_map["AutoFeatureExtractor"]

              if feature_extractor_class is not None:
                     UpperCamelCase       			=		feature_extractor_class_from_name(UpperCAmelCase_      )

              UpperCamelCase       			=		feature_extractor_auto_map is not None
              UpperCamelCase       			=		feature_extractor_class is not None or type(UpperCAmelCase_      ) in FEATURE_EXTRACTOR_MAPPING
              UpperCamelCase       			=		resolve_trust_remote_code(
                  UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_      )

              if has_remote_code and trust_remote_code:
                     UpperCamelCase       			=		get_class_from_dynamic_module(
                         UpperCAmelCase_							,   UpperCAmelCase_							,   **UpperCAmelCase_      )
                     UpperCamelCase       			=		kwargs.pop("code_revision"							,   UpperCAmelCase_      )
                     if os.path.isdir(UpperCAmelCase_      ):
                            feature_extractor_class.register_for_auto_class()
                     return feature_extractor_class.from_dict(UpperCAmelCase_							,   **UpperCAmelCase_      )
              elif feature_extractor_class is not None:
                     return feature_extractor_class.from_dict(UpperCAmelCase_							,   **UpperCAmelCase_      )
              # Last try: we use the FEATURE_EXTRACTOR_MAPPING.
              elif type(UpperCAmelCase_      ) in FEATURE_EXTRACTOR_MAPPING:
                     UpperCamelCase       			=		FEATURE_EXTRACTOR_MAPPING[type(UpperCAmelCase_      )]
                     return feature_extractor_class.from_dict(UpperCAmelCase_							,   **UpperCAmelCase_      )

              raise ValueError(
                  f"Unrecognized feature extractor in {pretrained_model_name_or_path}. Should have a "
                  f"`feature_extractor_type` key in its {FEATURE_EXTRACTOR_NAME} of {CONFIG_NAME}, or one of the following "
                  f"`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in FEATURE_EXTRACTOR_MAPPING_NAMES.keys()      )}"      )






       @staticmethod
       def 						_SCREAMING_SNAKE_CASE							(	UpperCAmelCase_			:				List[str]							,   UpperCAmelCase_			:				str      )->	Optional[Any]:







              """simple docstring"""
              FEATURE_EXTRACTOR_MAPPING.register(UpperCAmelCase_							,   UpperCAmelCase_      )







"""simple docstring"""


from collections import defaultdict
from typing import Optional

from ..image_utils import load_image
from ..utils import (
    add_end_docstrings,
    is_torch_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_torch_available():
      import torch

      from ..models.auto.modeling_auto import MODEL_FOR_MASK_GENERATION_MAPPING

SCREAMING_SNAKE_CASE			  =  logging.get_logger(__name__)



@add_end_docstrings(_lowerCAmelCase						)
class 	__a	(   _lowerCAmelCase						):






       def __init__(	self			:				str							,   **UpperCAmelCase_			:				List[str]      )->	Tuple:







              """simple docstring"""
              super().__init__(**UpperCAmelCase_      )
              requires_backends(self							,   "vision"      )
              requires_backends(self							,   "torch"      )

              if self.framework != "pt":
                     raise ValueError(f"The {self.__class__} is only available in PyTorch."      )

              self.check_model_type(UpperCAmelCase_      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Tuple							,   **UpperCAmelCase_			:				int      )->	List[str]:







              """simple docstring"""
              UpperCamelCase       			=		{}
              UpperCamelCase       			=		{}
              UpperCamelCase       			=		{}
              # preprocess args
              if "points_per_batch" in kwargs:
                     UpperCamelCase       			=		kwargs["points_per_batch"]
              if "points_per_crop" in kwargs:
                     UpperCamelCase       			=		kwargs["points_per_crop"]
              if "crops_n_layers" in kwargs:
                     UpperCamelCase       			=		kwargs["crops_n_layers"]
              if "crop_overlap_ratio" in kwargs:
                     UpperCamelCase       			=		kwargs["crop_overlap_ratio"]
              if "crop_n_points_downscale_factor" in kwargs:
                     UpperCamelCase       			=		kwargs["crop_n_points_downscale_factor"]
              # postprocess args
              if "pred_iou_thresh" in kwargs:
                     UpperCamelCase       			=		kwargs["pred_iou_thresh"]
              if "stability_score_offset" in kwargs:
                     UpperCamelCase       			=		kwargs["stability_score_offset"]
              if "mask_threshold" in kwargs:
                     UpperCamelCase       			=		kwargs["mask_threshold"]
              if "stability_score_thresh" in kwargs:
                     UpperCamelCase       			=		kwargs["stability_score_thresh"]
              if "crops_nms_thresh" in kwargs:
                     UpperCamelCase       			=		kwargs["crops_nms_thresh"]
              if "output_rle_mask" in kwargs:
                     UpperCamelCase       			=		kwargs["output_rle_mask"]
              if "output_bboxes_mask" in kwargs:
                     UpperCamelCase       			=		kwargs["output_bboxes_mask"]
              return preprocess_kwargs, forward_params, postprocess_kwargs






       def __call__(	self			:				Optional[int]							,   UpperCAmelCase_			:				Optional[int]							,   *UpperCAmelCase_			:				Tuple							,   UpperCAmelCase_			:				int=None							,   UpperCAmelCase_			:				Tuple=None							,   **UpperCAmelCase_			:				str      )->	Any:







              """simple docstring"""
              return super().__call__(UpperCAmelCase_							,   *UpperCAmelCase_							,   num_workers=UpperCAmelCase_							,   batch_size=UpperCAmelCase_							,   **UpperCAmelCase_      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[int]							,   UpperCAmelCase_			:				Optional[int]							,   UpperCAmelCase_			:				str=64							,   UpperCAmelCase_			:				int = 0							,   UpperCAmelCase_			:				float = 512 / 1_500							,   UpperCAmelCase_			:				Optional[int] = 32							,   UpperCAmelCase_			:				Optional[int] = 1							,   )->	List[Any]:







              """simple docstring"""
              UpperCamelCase       			=		load_image(UpperCAmelCase_      )
              UpperCamelCase       			=		self.image_processor.size["longest_edge"]
              UpperCamelCase			,							UpperCamelCase			,							UpperCamelCase			,							UpperCamelCase       			=		self.image_processor.generate_crop_boxes(
                  UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_      )
              UpperCamelCase       			=		self.image_processor(images=UpperCAmelCase_							,   return_tensors="pt"      )

              with self.device_placement():
                     if self.framework == "pt":
                            UpperCamelCase       			=		self.get_inference_context()
                            with inference_context():
                                   UpperCamelCase       			=		self._ensure_tensor_on_device(UpperCAmelCase_							,   device=self.device      )
                                   UpperCamelCase       			=		self.model.get_image_embeddings(model_inputs.pop("pixel_values"      )      )
                                   UpperCamelCase       			=		image_embeddings

              UpperCamelCase       			=		grid_points.shape[1]
              UpperCamelCase       			=		points_per_batch if points_per_batch is not None else n_points

              if points_per_batch <= 0:
                     raise ValueError(
                         "Cannot have points_per_batch<=0. Must be >=1 to returned batched outputs. "
                         "To return all points at once, set points_per_batch to None"      )

              for i in range(0							,   UpperCAmelCase_							,   UpperCAmelCase_      ):
                     UpperCamelCase       			=		grid_points[:, i : i + points_per_batch, :, :]
                     UpperCamelCase       			=		input_labels[:, i : i + points_per_batch]
                     UpperCamelCase       			=		i == n_points - points_per_batch
                     yield {
                         "input_points": batched_points,
                         "input_labels": labels,
                         "input_boxes": crop_boxes,
                         "is_last": is_last,
                         **model_inputs,
                     }






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Union[str, Any]							,   UpperCAmelCase_			:				Union[str, Any]							,   UpperCAmelCase_			:				int=0.88							,   UpperCAmelCase_			:				Optional[int]=0.95							,   UpperCAmelCase_			:				Dict=0							,   UpperCAmelCase_			:				int=1							,   )->	Any:







              """simple docstring"""
              UpperCamelCase       			=		model_inputs.pop("input_boxes"      )
              UpperCamelCase       			=		model_inputs.pop("is_last"      )
              UpperCamelCase       			=		model_inputs.pop("original_sizes"      ).tolist()
              UpperCamelCase       			=		model_inputs.pop("reshaped_input_sizes"      ).tolist()

              UpperCamelCase       			=		self.model(**UpperCAmelCase_      )

              # post processing happens here in order to avoid CPU GPU copies of ALL the masks
              UpperCamelCase       			=		model_outputs["pred_masks"]
              UpperCamelCase       			=		self.image_processor.post_process_masks(
                  UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_							,   binarize=UpperCAmelCase_      )
              UpperCamelCase       			=		model_outputs["iou_scores"]
              UpperCamelCase			,							UpperCamelCase			,							UpperCamelCase       			=		self.image_processor.filter_masks(
                  masks[0]							,   iou_scores[0]							,   original_sizes[0]							,   input_boxes[0]							,   UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_							,   )
              return {
                  "masks": masks,
                  "is_last": is_last,
                  "boxes": boxes,
                  "iou_scores": iou_scores,
              }






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Any							,   UpperCAmelCase_			:				Tuple							,   UpperCAmelCase_			:				List[str]=False							,   UpperCAmelCase_			:				str=False							,   UpperCAmelCase_			:				Optional[int]=0.7							,   )->	Dict:







              """simple docstring"""
              UpperCamelCase       			=		[]
              UpperCamelCase       			=		[]
              UpperCamelCase       			=		[]
              for model_output in model_outputs:
                     all_scores.append(model_output.pop("iou_scores"      )      )
                     all_masks.extend(model_output.pop("masks"      )      )
                     all_boxes.append(model_output.pop("boxes"      )      )

              UpperCamelCase       			=		torch.cat(UpperCAmelCase_      )
              UpperCamelCase       			=		torch.cat(UpperCAmelCase_      )
              UpperCamelCase			,							UpperCamelCase			,							UpperCamelCase			,							UpperCamelCase       			=		self.image_processor.post_process_for_mask_generation(
                  UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_      )

              UpperCamelCase       			=		defaultdict(UpperCAmelCase_      )
              for output in model_outputs:
                     for k, v in output.items():
                            extra[k].append(UpperCAmelCase_      )

              UpperCamelCase       			=		{}
              if output_rle_mask:
                     UpperCamelCase       			=		rle_mask

              if output_bboxes_mask:
                     UpperCamelCase       			=		bounding_boxes

              return {"masks": output_masks, "scores": iou_scores, **optional, **extra}





