"""simple docstring"""






from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    flip_channel_order,
    get_resize_output_image_size,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging


if is_vision_available():
       import PIL

if is_torch_available():
       import torch


__lowerCAmelCase       :			Tuple   	=logging.get_logger(__name__)





class 					_A		(			lowerCAmelCase      ):
      snake_case__     :  Any				    =      ['pixel_values']

      def __init__(		self						,			__lowerCAmelCase = True						,			__lowerCAmelCase = None						,			__lowerCAmelCase = PILImageResampling.BILINEAR						,			__lowerCAmelCase = True						,			__lowerCAmelCase = 1 / 255						,			__lowerCAmelCase = True						,			__lowerCAmelCase = None						,			__lowerCAmelCase = True						,			**__lowerCAmelCase						,			):







            """simple docstring"""



            super().__init__(**__lowerCAmelCase		)
            lowercase								=      size if size is not None else {"""shortest_edge""": 224}
            lowercase								=      get_size_dict(__lowerCAmelCase						,			default_to_square=__lowerCAmelCase		)
            lowercase								=      crop_size if crop_size is not None else {"""height""": 256, """width""": 256}
            lowercase								=      get_size_dict(__lowerCAmelCase						,			param_name="""crop_size"""		)

            lowercase								=      do_resize
            lowercase								=      size
            lowercase								=      resample
            lowercase								=      do_rescale
            lowercase								=      rescale_factor
            lowercase								=      do_center_crop
            lowercase								=      crop_size
            lowercase								=      do_flip_channel_order

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase = PIL.Image.BILINEAR						,			__lowerCAmelCase = None						,			**__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      get_size_dict(__lowerCAmelCase						,			default_to_square=__lowerCAmelCase		)
            if "shortest_edge" not in size:
                  raise ValueError(f'The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}'		)
            lowercase								=      get_resize_output_image_size(__lowerCAmelCase						,			size=size["""shortest_edge"""]						,			default_to_square=__lowerCAmelCase		)
            return resize(__lowerCAmelCase						,			size=__lowerCAmelCase						,			resample=__lowerCAmelCase						,			data_format=__lowerCAmelCase						,			**__lowerCAmelCase		)

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase = None						,			**__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      get_size_dict(__lowerCAmelCase		)
            if "height" not in size or "width" not in size:
                  raise ValueError(f'The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}'		)
            return center_crop(__lowerCAmelCase						,			size=(size["""height"""], size["""width"""])						,			data_format=__lowerCAmelCase						,			**__lowerCAmelCase		)

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase = None						,			**__lowerCAmelCase						,			):







            """simple docstring"""



            return rescale(__lowerCAmelCase						,			scale=__lowerCAmelCase						,			data_format=__lowerCAmelCase						,			**__lowerCAmelCase		)

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase = None		):







            """simple docstring"""



            return flip_channel_order(__lowerCAmelCase						,			data_format=__lowerCAmelCase		)

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase = None						,			__lowerCAmelCase = None						,			__lowerCAmelCase = None						,			__lowerCAmelCase = None						,			__lowerCAmelCase = None						,			__lowerCAmelCase = None						,			__lowerCAmelCase = None						,			__lowerCAmelCase = None						,			__lowerCAmelCase = None						,			__lowerCAmelCase = ChannelDimension.FIRST						,			**__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      do_resize if do_resize is not None else self.do_resize
            lowercase								=      resample if resample is not None else self.resample
            lowercase								=      do_rescale if do_rescale is not None else self.do_rescale
            lowercase								=      rescale_factor if rescale_factor is not None else self.rescale_factor
            lowercase								=      do_center_crop if do_center_crop is not None else self.do_center_crop
            lowercase								=      (
                do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
            )

            lowercase								=      size if size is not None else self.size
            lowercase								=      get_size_dict(__lowerCAmelCase						,			default_to_square=__lowerCAmelCase		)
            lowercase								=      crop_size if crop_size is not None else self.crop_size
            lowercase								=      get_size_dict(__lowerCAmelCase						,			param_name="""crop_size"""		)

            lowercase								=      make_list_of_images(__lowerCAmelCase		)

            if not valid_images(__lowerCAmelCase		):
                  raise ValueError(
                      """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
                      """torch.Tensor, tf.Tensor or jax.ndarray."""		)

            if do_resize and size is None:
                  raise ValueError("""Size must be specified if do_resize is True."""		)

            if do_rescale and rescale_factor is None:
                  raise ValueError("""Rescale factor must be specified if do_rescale is True."""		)

            if do_center_crop and crop_size is None:
                  raise ValueError("""Crop size must be specified if do_center_crop is True."""		)

            # All transformations expect numpy arrays.
            lowercase								=      [to_numpy_array(__lowerCAmelCase		) for image in images]

            if do_resize:
                  lowercase								=      [self.resize(image=__lowerCAmelCase						,			size=__lowerCAmelCase						,			resample=__lowerCAmelCase		) for image in images]

            if do_center_crop:
                  lowercase								=      [self.center_crop(image=__lowerCAmelCase						,			size=__lowerCAmelCase		) for image in images]

            if do_rescale:
                  lowercase								=      [self.rescale(image=__lowerCAmelCase						,			scale=__lowerCAmelCase		) for image in images]

            # the pretrained checkpoints assume images are BGR, not RGB
            if do_flip_channel_order:
                  lowercase								=      [self.flip_channel_order(image=__lowerCAmelCase		) for image in images]

            lowercase								=      [to_channel_dimension_format(__lowerCAmelCase						,			__lowerCAmelCase		) for image in images]

            lowercase								=      {"""pixel_values""": images}
            return BatchFeature(data=__lowerCAmelCase						,			tensor_type=__lowerCAmelCase		)







      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase = None		):







            """simple docstring"""



            lowercase								=      outputs.logits

            # Resize logits and compute semantic segmentation maps
            if target_sizes is not None:
                  if len(__lowerCAmelCase		) != len(__lowerCAmelCase		):
                        raise ValueError(
                            """Make sure that you pass in as many target sizes as the batch dimension of the logits"""		)

                  if is_torch_tensor(__lowerCAmelCase		):
                        lowercase								=      target_sizes.numpy()

                  lowercase								=      []

                  for idx in range(len(__lowerCAmelCase		)		):
                        lowercase								=      torch.nn.functional.interpolate(
                            logits[idx].unsqueeze(dim=0		)						,			size=target_sizes[idx]						,			mode="""bilinear"""						,			align_corners=__lowerCAmelCase		)
                        lowercase								=      resized_logits[0].argmax(dim=0		)
                        semantic_segmentation.append(__lowerCAmelCase		)
            else:
                  lowercase								=      logits.argmax(dim=1		)
                  lowercase								=      [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]		)]

            return semantic_segmentation




"""simple docstring"""






from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Sequence, Value
from .base import TaskTemplate





@dataclass(frozen=lowerCAmelCase      )
class 					_A		(			lowerCAmelCase      ):
      # `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
      snake_case__     :  str				    =      field(default='question-answering-extractive'    ,       metadata={'include_in_asdict_even_if_is_default': True}      )
      snake_case__     :  ClassVar[Features]				    =      Features({'question': Value('string'      ), 'context': Value('string'      )}      )
      snake_case__     :  ClassVar[Features]				    =      Features(
          {
              'answers': Sequence(
                  {
                      'text': Value('string'      ),
                      'answer_start': Value('int32'      ),
                  }      )
          }      )
      snake_case__     :  str				    =      "question"
      snake_case__     :  str				    =      "context"
      snake_case__     :  str				    =      "answers"

      @property
      def 							A__			(		self		):







            """simple docstring"""



            return {self.question_column: "question", self.context_column: "context", self.answers_column: "answers"}



