
import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY




@is_pipeline_test
@require_torch_or_tf
class      __A(    unittest.TestCase			):

  """simple docstring"""
  SCREAMING_SNAKE_CASE__         =      MODEL_FOR_CAUSAL_LM_MAPPING
  SCREAMING_SNAKE_CASE__         =      TF_MODEL_FOR_CAUSAL_LM_MAPPING







  @require_torch
  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    pipeline(task="""text-generation"""	,      model="""sshleifer/tiny-ctrl"""	,      framework="""pt"""						)
       # Using `do_sample=False` to force deterministic output
       UpperCamelCase__				=    text_generator("""This is a test"""	,      do_sample=SCREAMING_SNAKE_CASE_						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               {
                   """generated_text""": (
                       """This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."""
                       """ oscope. FiliFili@@"""
                   )
               }
           ]	,      )

       UpperCamelCase__				=    text_generator(["""This is a test""", """This is a second test"""]						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               [
                   {
                       """generated_text""": (
                           """This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."""
                           """ oscope. FiliFili@@"""
                       )
                   }
               ],
               [
                   {
                       """generated_text""": (
                           """This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy"""
                           """ oscope. oscope. FiliFili@@"""
                       )
                   }
               ],
           ]	,      )

       UpperCamelCase__				=    text_generator("""This is a test"""	,      do_sample=SCREAMING_SNAKE_CASE_	,      num_return_sequences=2	,      return_tensors=SCREAMING_SNAKE_CASE_						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               {"""generated_token_ids""": ANY(SCREAMING_SNAKE_CASE_						)},
               {"""generated_token_ids""": ANY(SCREAMING_SNAKE_CASE_						)},
           ]	,      )
       UpperCamelCase__				=    text_generator.model.config.eos_token_id
       UpperCamelCase__				=    """<pad>"""
       UpperCamelCase__				=    text_generator(
           ["""This is a test""", """This is a second test"""]	,      do_sample=SCREAMING_SNAKE_CASE_	,      num_return_sequences=2	,      batch_size=2	,      return_tensors=SCREAMING_SNAKE_CASE_	,      )
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               [
                   {"""generated_token_ids""": ANY(SCREAMING_SNAKE_CASE_						)},
                   {"""generated_token_ids""": ANY(SCREAMING_SNAKE_CASE_						)},
               ],
               [
                   {"""generated_token_ids""": ANY(SCREAMING_SNAKE_CASE_						)},
                   {"""generated_token_ids""": ANY(SCREAMING_SNAKE_CASE_						)},
               ],
           ]	,      )







  @require_tf
  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    pipeline(task="""text-generation"""	,      model="""sshleifer/tiny-ctrl"""	,      framework="""tf"""						)

       # Using `do_sample=False` to force deterministic output
       UpperCamelCase__				=    text_generator("""This is a test"""	,      do_sample=SCREAMING_SNAKE_CASE_						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               {
                   """generated_text""": (
                       """This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"""
                       """ please,"""
                   )
               }
           ]	,      )

       UpperCamelCase__				=    text_generator(["""This is a test""", """This is a second test"""]	,      do_sample=SCREAMING_SNAKE_CASE_						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               [
                   {
                       """generated_text""": (
                           """This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"""
                           """ please,"""
                       )
                   }
               ],
               [
                   {
                       """generated_text""": (
                           """This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes"""
                           """ Cannes 閲閲Cannes Cannes Cannes 攵 please,"""
                       )
                   }
               ],
           ]	,      )







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
       UpperCamelCase__				=    TextGenerationPipeline(model=SCREAMING_SNAKE_CASE_	,      tokenizer=SCREAMING_SNAKE_CASE_						)
       return text_generator, ["This is a test", "Another test"]







  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    """Hello I believe in"""
       UpperCamelCase__				=    pipeline("""text-generation"""	,      model="""hf-internal-testing/tiny-random-gpt2"""						)
       UpperCamelCase__				=    text_generator(SCREAMING_SNAKE_CASE_						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [{"""generated_text""": """Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"""}]	,      )

       UpperCamelCase__				=    text_generator(SCREAMING_SNAKE_CASE_	,      stop_sequence=""" fe"""						)
       self.assertEqual(SCREAMING_SNAKE_CASE_	,      [{"""generated_text""": """Hello I believe in fe"""}]						)







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
       UpperCamelCase__				=    text_generator.model
       UpperCamelCase__				=    text_generator.tokenizer

       UpperCamelCase__				=    text_generator("""This is a test"""						)
       self.assertEqual(SCREAMING_SNAKE_CASE_	,      [{"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}]						)
       self.assertTrue(outputs[0]["""generated_text"""].startswith("""This is a test"""						)						)

       UpperCamelCase__				=    text_generator("""This is a test"""	,      return_full_text=SCREAMING_SNAKE_CASE_						)
       self.assertEqual(SCREAMING_SNAKE_CASE_	,      [{"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}]						)
       self.assertNotIn("""This is a test"""	,      outputs[0]["""generated_text"""]						)

       UpperCamelCase__				=    pipeline(task="""text-generation"""	,      model=SCREAMING_SNAKE_CASE_	,      tokenizer=SCREAMING_SNAKE_CASE_	,      return_full_text=SCREAMING_SNAKE_CASE_						)
       UpperCamelCase__				=    text_generator("""This is a test"""						)
       self.assertEqual(SCREAMING_SNAKE_CASE_	,      [{"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}]						)
       self.assertNotIn("""This is a test"""	,      outputs[0]["""generated_text"""]						)

       UpperCamelCase__				=    text_generator("""This is a test"""	,      return_full_text=SCREAMING_SNAKE_CASE_						)
       self.assertEqual(SCREAMING_SNAKE_CASE_	,      [{"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}]						)
       self.assertTrue(outputs[0]["""generated_text"""].startswith("""This is a test"""						)						)

       UpperCamelCase__				=    text_generator(["""This is great !""", """Something else"""]	,      num_return_sequences=2	,      do_sample=SCREAMING_SNAKE_CASE_						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               [{"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}, {"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}],
               [{"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}, {"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}],
           ]	,      )

       if text_generator.tokenizer.pad_token is not None:
            UpperCamelCase__				=    text_generator(
                ["""This is great !""", """Something else"""]	,      num_return_sequences=2	,      batch_size=2	,      do_sample=SCREAMING_SNAKE_CASE_						)
            self.assertEqual(
                SCREAMING_SNAKE_CASE_	,      [
                    [{"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}, {"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}],
                    [{"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}, {"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}],
                ]	,      )

       with self.assertRaises(SCREAMING_SNAKE_CASE_						):
            UpperCamelCase__				=    text_generator("""test"""	,      return_full_text=SCREAMING_SNAKE_CASE_	,      return_text=SCREAMING_SNAKE_CASE_						)
       with self.assertRaises(SCREAMING_SNAKE_CASE_						):
            UpperCamelCase__				=    text_generator("""test"""	,      return_full_text=SCREAMING_SNAKE_CASE_	,      return_tensors=SCREAMING_SNAKE_CASE_						)
       with self.assertRaises(SCREAMING_SNAKE_CASE_						):
            UpperCamelCase__				=    text_generator("""test"""	,      return_text=SCREAMING_SNAKE_CASE_	,      return_tensors=SCREAMING_SNAKE_CASE_						)

       # Empty prompt is slighly special
       # it requires BOS token to exist.
       # Special case for Pegasus which will always append EOS so will
       # work even without BOS.
       if (
           text_generator.tokenizer.bos_token_id is not None
           or "Pegasus" in tokenizer.__class__.__name__
           or "Git" in model.__class__.__name__
       ):
            UpperCamelCase__				=    text_generator(""""""						)
            self.assertEqual(SCREAMING_SNAKE_CASE_	,      [{"""generated_text""": ANY(SCREAMING_SNAKE_CASE_						)}]						)
       else:
            with self.assertRaises((ValueError, AssertionError)						):
                 UpperCamelCase__				=    text_generator(""""""						)

       if text_generator.framework == "tf":
            # TF generation does not support max_new_tokens, and it's impossible
            # to control long generation with only max_length without
            # fancy calculation, dismissing tests for now.
            return
       # We don't care about infinite range models.
       # They already work.
       # Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
       UpperCamelCase__				=    ["""RwkvForCausalLM""", """XGLMForCausalLM""", """GPTNeoXForCausalLM"""]
       if (
           tokenizer.model_max_length < 1_00_00
           and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
       ):
            # Handling of large generations
            with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)						):
                 text_generator("""This is a test""" * 5_00	,      max_new_tokens=20						)

            UpperCamelCase__				=    text_generator("""This is a test""" * 5_00	,      handle_long_generation="""hole"""	,      max_new_tokens=20						)
            # Hole strategy cannot work
            with self.assertRaises(SCREAMING_SNAKE_CASE_						):
                 text_generator(
                     """This is a test""" * 5_00	,      handle_long_generation="""hole"""	,      max_new_tokens=tokenizer.model_max_length + 10	,      )







  @require_torch
  @require_accelerate
  @require_torch_gpu
  def 	UpperCAmelCase_ (self						):
       import torch

       # Classic `model_kwargs`
       UpperCamelCase__				=    pipeline(
           model="""hf-internal-testing/tiny-random-bloom"""	,      model_kwargs={"""device_map""": """auto""", """torch_dtype""": torch.bfloataa}	,      )
       self.assertEqual(pipe.model.device	,      torch.device(0						)						)
       self.assertEqual(pipe.model.lm_head.weight.dtype	,      torch.bfloataa						)
       UpperCamelCase__				=    pipe("""This is a test"""						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               {
                   """generated_text""": (
                       """This is a test test test test test test test test test test test test test test test test"""
                       """ test"""
                   )
               }
           ]	,      )

       # Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
       UpperCamelCase__				=    pipeline(model="""hf-internal-testing/tiny-random-bloom"""	,      device_map="""auto"""	,      torch_dtype=torch.bfloataa						)
       self.assertEqual(pipe.model.device	,      torch.device(0						)						)
       self.assertEqual(pipe.model.lm_head.weight.dtype	,      torch.bfloataa						)
       UpperCamelCase__				=    pipe("""This is a test"""						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               {
                   """generated_text""": (
                       """This is a test test test test test test test test test test test test test test test test"""
                       """ test"""
                   )
               }
           ]	,      )

       # torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
       UpperCamelCase__				=    pipeline(model="""hf-internal-testing/tiny-random-bloom"""	,      device_map="""auto"""						)
       self.assertEqual(pipe.model.device	,      torch.device(0						)						)
       self.assertEqual(pipe.model.lm_head.weight.dtype	,      torch.floataa						)
       UpperCamelCase__				=    pipe("""This is a test"""						)
       self.assertEqual(
           SCREAMING_SNAKE_CASE_	,      [
               {
                   """generated_text""": (
                       """This is a test test test test test test test test test test test test test test test test"""
                       """ test"""
                   )
               }
           ]	,      )







  @require_torch
  @require_torch_gpu
  def 	UpperCAmelCase_ (self						):
       import torch

       UpperCamelCase__				=    pipeline(model="""hf-internal-testing/tiny-random-bloom"""	,      device=0	,      torch_dtype=torch.floataa						)
       pipe("""This is a test"""						)







  @require_torch
  @require_accelerate
  @require_torch_gpu
  def 	UpperCAmelCase_ (self						):
       import torch

       UpperCamelCase__				=    pipeline(model="""hf-internal-testing/tiny-random-bloom"""	,      device_map="""auto"""	,      torch_dtype=torch.floataa						)
       pipe("""This is a test"""	,      do_sample=SCREAMING_SNAKE_CASE_	,      top_p=0.5						)







  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    """Hello world"""
       UpperCamelCase__				=    pipeline("""text-generation"""	,      model="""hf-internal-testing/tiny-random-gpt2"""						)
       if text_generator.model.framework == "tf":
            UpperCamelCase__				=    logging.get_logger("""transformers.generation.tf_utils"""						)
       else:
            UpperCamelCase__				=    logging.get_logger("""transformers.generation.utils"""						)
       UpperCamelCase__				=    """Both `max_new_tokens`"""  # The beggining of the message to be checked in this test

       # Both are set by the user -> log warning
       with CaptureLogger(SCREAMING_SNAKE_CASE_						) as cl:
            UpperCamelCase__				=    text_generator(SCREAMING_SNAKE_CASE_	,      max_length=10	,      max_new_tokens=1						)
       self.assertIn(SCREAMING_SNAKE_CASE_	,      cl.out						)

       # The user only sets one -> no warning
       with CaptureLogger(SCREAMING_SNAKE_CASE_						) as cl:
            UpperCamelCase__				=    text_generator(SCREAMING_SNAKE_CASE_	,      max_new_tokens=1						)
       self.assertNotIn(SCREAMING_SNAKE_CASE_	,      cl.out						)

       with CaptureLogger(SCREAMING_SNAKE_CASE_						) as cl:
            UpperCamelCase__				=    text_generator(SCREAMING_SNAKE_CASE_	,      max_length=10						)
       self.assertNotIn(SCREAMING_SNAKE_CASE_	,      cl.out						)







import unittest

import numpy as np
import requests

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
    import torch

    from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
    lowerCamelCase_						     =					False

if is_vision_available():
    from PIL import Image

    from transformers import PixaStructImageProcessor




class      __A(    unittest.TestCase			):

  """simple docstring"""







  def __init__(self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_=7	,      SCREAMING_SNAKE_CASE_=3	,      SCREAMING_SNAKE_CASE_=18	,      SCREAMING_SNAKE_CASE_=30	,      SCREAMING_SNAKE_CASE_=4_00	,      SCREAMING_SNAKE_CASE_=None	,      SCREAMING_SNAKE_CASE_=True	,      SCREAMING_SNAKE_CASE_=True	,      SCREAMING_SNAKE_CASE_=None	,      ):
       UpperCamelCase__				=    size if size is not None else {"""height""": 20, """width""": 20}
       UpperCamelCase__				=    parent
       UpperCamelCase__				=    batch_size
       UpperCamelCase__				=    num_channels
       UpperCamelCase__				=    image_size
       UpperCamelCase__				=    min_resolution
       UpperCamelCase__				=    max_resolution
       UpperCamelCase__				=    size
       UpperCamelCase__				=    do_normalize
       UpperCamelCase__				=    do_convert_rgb
       UpperCamelCase__				=    [5_12, 10_24, 20_48, 40_96]
       UpperCamelCase__				=    patch_size if patch_size is not None else {"""height""": 16, """width""": 16}







  def 	UpperCAmelCase_ (self						):
       return {"do_normalize": self.do_normalize, "do_convert_rgb": self.do_convert_rgb}







  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    """https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg"""
       UpperCamelCase__				=    Image.open(requests.get(SCREAMING_SNAKE_CASE_	,      stream=SCREAMING_SNAKE_CASE_						).raw						).convert("""RGB"""						)
       return raw_image






@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11    ,				reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""    ,				)
@require_torch
@require_vision
class      __A(    __lowerCamelCase    ,				unittest.TestCase			):

  """simple docstring"""
  SCREAMING_SNAKE_CASE__         =      PixaStructImageProcessor if is_vision_available() else None







  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    PixaStructImageProcessingTester(self						)







  @property
  def 	UpperCAmelCase_ (self						):
       return self.image_processor_tester.prepare_image_processor_dict()







  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    self.image_processing_class(**self.image_processor_dict						)
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_	,      """do_normalize"""						)						)
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_	,      """do_convert_rgb"""						)						)







  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    self.image_processor_tester.prepare_dummy_image()

       UpperCamelCase__				=    self.image_processing_class(**self.image_processor_dict						)
       UpperCamelCase__				=    20_48

       UpperCamelCase__				=    image_processor(SCREAMING_SNAKE_CASE_	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						)
       self.assertTrue(torch.allclose(inputs.flattened_patches.mean()	,      torch.tensor(0.0606						)	,      atol=1E-3	,      rtol=1E-3						)						)







  def 	UpperCAmelCase_ (self						):
       # Initialize image_processor
       UpperCamelCase__				=    self.image_processing_class(**self.image_processor_dict						)
       # create random PIL images
       UpperCamelCase__				=    prepare_image_inputs(self.image_processor_tester	,      equal_resolution=SCREAMING_SNAKE_CASE_						)
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_	,      Image.Image						)

       # Test not batched input
       UpperCamelCase__				=    (
           (self.image_processor_tester.patch_size["""height"""] * self.image_processor_tester.patch_size["""width"""])
           * self.image_processor_tester.num_channels
       ) + 2

       for max_patch in self.image_processor_tester.max_patches:
            # Test not batched input
            UpperCamelCase__				=    image_processor(
                image_inputs[0]	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (1, max_patch, expected_hidden_dim)	,      )

            # Test batched
            UpperCamelCase__				=    image_processor(
                SCREAMING_SNAKE_CASE_	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)	,      )







  def 	UpperCAmelCase_ (self						):
       # Initialize image_processor
       UpperCamelCase__				=    self.image_processing_class(**self.image_processor_dict						)
       # create random PIL images
       UpperCamelCase__				=    prepare_image_inputs(self.image_processor_tester	,      equal_resolution=SCREAMING_SNAKE_CASE_						)
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_	,      Image.Image						)

       # Test not batched input
       UpperCamelCase__				=    (
           (self.image_processor_tester.patch_size["""height"""] * self.image_processor_tester.patch_size["""width"""])
           * self.image_processor_tester.num_channels
       ) + 2

       UpperCamelCase__				=    True

       for max_patch in self.image_processor_tester.max_patches:
            # Test not batched input
            with self.assertRaises(SCREAMING_SNAKE_CASE_						):
                 UpperCamelCase__				=    image_processor(
                     image_inputs[0]	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						).flattened_patches

            UpperCamelCase__				=    """Hello"""

            UpperCamelCase__				=    image_processor(
                image_inputs[0]	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_	,      header_text=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (1, max_patch, expected_hidden_dim)	,      )

            # Test batched
            UpperCamelCase__				=    image_processor(
                SCREAMING_SNAKE_CASE_	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_	,      header_text=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)	,      )







  def 	UpperCAmelCase_ (self						):
       # Initialize image_processor
       UpperCamelCase__				=    self.image_processing_class(**self.image_processor_dict						)
       # create random numpy tensors
       UpperCamelCase__				=    prepare_image_inputs(self.image_processor_tester	,      equal_resolution=SCREAMING_SNAKE_CASE_	,      numpify=SCREAMING_SNAKE_CASE_						)
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_	,      np.ndarray						)

       UpperCamelCase__				=    (
           (self.image_processor_tester.patch_size["""height"""] * self.image_processor_tester.patch_size["""width"""])
           * self.image_processor_tester.num_channels
       ) + 2

       for max_patch in self.image_processor_tester.max_patches:
            # Test not batched input
            UpperCamelCase__				=    image_processor(
                image_inputs[0]	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (1, max_patch, expected_hidden_dim)	,      )

            # Test batched
            UpperCamelCase__				=    image_processor(
                SCREAMING_SNAKE_CASE_	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)	,      )







  def 	UpperCAmelCase_ (self						):
       # Initialize image_processor
       UpperCamelCase__				=    self.image_processing_class(**self.image_processor_dict						)
       # create random PyTorch tensors
       UpperCamelCase__				=    prepare_image_inputs(self.image_processor_tester	,      equal_resolution=SCREAMING_SNAKE_CASE_	,      torchify=SCREAMING_SNAKE_CASE_						)
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_	,      torch.Tensor						)

       # Test not batched input
       UpperCamelCase__				=    (
           (self.image_processor_tester.patch_size["""height"""] * self.image_processor_tester.patch_size["""width"""])
           * self.image_processor_tester.num_channels
       ) + 2

       for max_patch in self.image_processor_tester.max_patches:
            # Test not batched input
            UpperCamelCase__				=    image_processor(
                image_inputs[0]	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (1, max_patch, expected_hidden_dim)	,      )

            # Test batched
            UpperCamelCase__				=    image_processor(
                SCREAMING_SNAKE_CASE_	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)	,      )






@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11    ,				reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""    ,				)
@require_torch
@require_vision
class      __A(    __lowerCamelCase    ,				unittest.TestCase			):

  """simple docstring"""
  SCREAMING_SNAKE_CASE__         =      PixaStructImageProcessor if is_vision_available() else None







  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    PixaStructImageProcessingTester(self	,      num_channels=4						)
       UpperCamelCase__				=    3







  @property
  def 	UpperCAmelCase_ (self						):
       return self.image_processor_tester.prepare_image_processor_dict()







  def 	UpperCAmelCase_ (self						):
       UpperCamelCase__				=    self.image_processing_class(**self.image_processor_dict						)
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_	,      """do_normalize"""						)						)
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_	,      """do_convert_rgb"""						)						)







  def 	UpperCAmelCase_ (self						):
       # Initialize image_processor
       UpperCamelCase__				=    self.image_processing_class(**self.image_processor_dict						)
       # create random PIL images
       UpperCamelCase__				=    prepare_image_inputs(self.image_processor_tester	,      equal_resolution=SCREAMING_SNAKE_CASE_						)
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_	,      Image.Image						)

       # Test not batched input
       UpperCamelCase__				=    (
           (self.image_processor_tester.patch_size["""height"""] * self.image_processor_tester.patch_size["""width"""])
           * (self.image_processor_tester.num_channels - 1)
       ) + 2

       for max_patch in self.image_processor_tester.max_patches:
            # Test not batched input
            UpperCamelCase__				=    image_processor(
                image_inputs[0]	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (1, max_patch, expected_hidden_dim)	,      )

            # Test batched
            UpperCamelCase__				=    image_processor(
                SCREAMING_SNAKE_CASE_	,      return_tensors="""pt"""	,      max_patches=SCREAMING_SNAKE_CASE_						).flattened_patches
            self.assertEqual(
                encoded_images.shape	,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)	,      )





