






from __future__ import annotations

import unittest

from transformers import LEDConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFLEDForConditionalGeneration, TFLEDModel



@require_tf
class 							_UpperCamelCase			:
      snake_case_  =							LEDConfig
      snake_case_  =							{}
      snake_case_  =							"""gelu"""


      def __init__(	self					,						__UpperCamelCase					,						__UpperCamelCase=1_3					,						__UpperCamelCase=7					,						__UpperCamelCase=True					,						__UpperCamelCase=False					,						__UpperCamelCase=9_9					,						__UpperCamelCase=3_2					,						__UpperCamelCase=2					,						__UpperCamelCase=4					,						__UpperCamelCase=3_7					,						__UpperCamelCase=0.1					,						__UpperCamelCase=0.1					,						__UpperCamelCase=2_0					,						__UpperCamelCase=2					,						__UpperCamelCase=1					,						__UpperCamelCase=0					,						__UpperCamelCase=4					,						)->	Tuple:
           __lowerCAmelCase								=					parent
           __lowerCAmelCase								=					batch_size
           __lowerCAmelCase								=					seq_length
           __lowerCAmelCase								=					is_training
           __lowerCAmelCase								=					use_labels
           __lowerCAmelCase								=					vocab_size
           __lowerCAmelCase								=					hidden_size
           __lowerCAmelCase								=					num_hidden_layers
           __lowerCAmelCase								=					num_attention_heads
           __lowerCAmelCase								=					intermediate_size

           __lowerCAmelCase								=					hidden_dropout_prob
           __lowerCAmelCase								=					attention_probs_dropout_prob
           __lowerCAmelCase								=					max_position_embeddings
           __lowerCAmelCase								=					eos_token_id
           __lowerCAmelCase								=					pad_token_id
           __lowerCAmelCase								=					bos_token_id
           __lowerCAmelCase								=					attention_window

           # `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
           # [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
           # returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
           # because its local attention only attends to `self.attention_window` and one before and one after
           __lowerCAmelCase								=					self.attention_window + 2

           # because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
           # the `test_attention_outputs` and `test_hidden_states_output` tests
           __lowerCAmelCase								=					(
               self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
           )


      def  __UpperCAmelCase		(	self	)->	Dict:
           __lowerCAmelCase								=					ids_tensor([self.batch_size, self.seq_length - 1]					,						self.vocab_size	)
           __lowerCAmelCase								=					tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size	)					,						1	)
           __lowerCAmelCase								=					tf.concat([input_ids, eos_tensor]					,						axis=1	)

           __lowerCAmelCase								=					ids_tensor([self.batch_size, self.seq_length]					,						self.vocab_size	)

           __lowerCAmelCase								=					self.config_cls(
               vocab_size=self.vocab_size					,						d_model=self.hidden_size					,						encoder_layers=self.num_hidden_layers					,						decoder_layers=self.num_hidden_layers					,						encoder_attention_heads=self.num_attention_heads					,						decoder_attention_heads=self.num_attention_heads					,						encoder_ffn_dim=self.intermediate_size					,						decoder_ffn_dim=self.intermediate_size					,						dropout=self.hidden_dropout_prob					,						attention_dropout=self.attention_probs_dropout_prob					,						max_position_embeddings=self.max_position_embeddings					,						eos_token_ids=[2]					,						bos_token_id=self.bos_token_id					,						pad_token_id=self.pad_token_id					,						decoder_start_token_id=self.pad_token_id					,						attention_window=self.attention_window					,						**self.config_updates					,						)
           __lowerCAmelCase								=					prepare_led_inputs_dict(__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)
           __lowerCAmelCase								=					tf.concat(
               [tf.zeros_like(__UpperCamelCase	)[:, :-1], tf.ones_like(__UpperCamelCase	)[:, -1:]]					,						axis=-1					,						)
           __lowerCAmelCase								=					global_attention_mask
           return config, inputs_dict


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase	)->	Optional[Any]:
           __lowerCAmelCase								=					TFLEDModel(config=__UpperCamelCase	).get_decoder()
           __lowerCAmelCase								=					inputs_dict["input_ids"]

           __lowerCAmelCase								=					input_ids[:1, :]
           __lowerCAmelCase								=					inputs_dict["attention_mask"][:1, :]
           __lowerCAmelCase								=					1

           # first forward pass
           __lowerCAmelCase								=					model(__UpperCamelCase					,						attention_mask=__UpperCamelCase					,						use_cache=__UpperCamelCase	)

           __lowerCAmelCase			, __lowerCAmelCase								=					outputs.to_tuple()

           # create hypothetical next token and extent to next_input_ids
           __lowerCAmelCase								=					ids_tensor((self.batch_size, 3)					,						config.vocab_size	)
           __lowerCAmelCase								=					tf.cast(ids_tensor((self.batch_size, 3)					,						2	)					,						tf.inta	)

           # append to next input_ids and
           __lowerCAmelCase								=					tf.concat([input_ids, next_tokens]					,						axis=-1	)
           __lowerCAmelCase								=					tf.concat([attention_mask, next_attn_mask]					,						axis=-1	)

           __lowerCAmelCase								=					model(__UpperCamelCase					,						attention_mask=__UpperCamelCase	)[0]
           __lowerCAmelCase								=					model(__UpperCamelCase					,						attention_mask=__UpperCamelCase					,						past_key_values=__UpperCamelCase	)[0]

           self.parent.assertEqual(next_tokens.shape[1]					,						output_from_past.shape[1]	)

           # select random slice
           __lowerCAmelCase								=					int(ids_tensor((1,)					,						output_from_past.shape[-1]	)	)
           __lowerCAmelCase								=					output_from_no_past[:, -3:, random_slice_idx]
           __lowerCAmelCase								=					output_from_past[:, :, random_slice_idx]

           # test that outputs are equal for slice
           tf.debugging.assert_near(__UpperCamelCase					,						__UpperCamelCase					,						rtol=1e-3	)





def       __lowerCAmelCase      (						__snake_case					, __snake_case					, __snake_case					, __snake_case=None					, __snake_case=None					, __snake_case=None					, __snake_case=None					, ):
     if attention_mask is None:
          __lowerCAmelCase								=					tf.cast(tf.math.not_equal(__snake_case					, config.pad_token_id       )					, tf.inta       )
     if decoder_attention_mask is None:
          __lowerCAmelCase								=					tf.concat(
              [
                  tf.ones(decoder_input_ids[:, :1].shape					, dtype=tf.inta       ),
                  tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]					, config.pad_token_id       )					, tf.inta       ),
              ]					, axis=-1					, )
     if head_mask is None:
          __lowerCAmelCase								=					tf.ones((config.encoder_layers, config.encoder_attention_heads)       )
     if decoder_head_mask is None:
          __lowerCAmelCase								=					tf.ones((config.decoder_layers, config.decoder_attention_heads)       )
     return {
         "input_ids": input_ids,
         "attention_mask": attention_mask,
         "decoder_input_ids": decoder_input_ids,
         "decoder_attention_mask": decoder_attention_mask,
         "head_mask": head_mask,
         "decoder_head_mask": decoder_head_mask,
     }



@require_tf
class 							_UpperCamelCase			(a_							,		a_							,		unittest.TestCase			):
      snake_case_  =							(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
      snake_case_  =							(TFLEDForConditionalGeneration,) if is_tf_available() else ()
      snake_case_  =							(
          {
              """conversational""": TFLEDForConditionalGeneration,
              """feature-extraction""": TFLEDModel,
              """summarization""": TFLEDForConditionalGeneration,
              """text2text-generation""": TFLEDForConditionalGeneration,
              """translation""": TFLEDForConditionalGeneration,
          }
          if is_tf_available()
          else {}
      )
      snake_case_  =							True
      snake_case_  =							False
      snake_case_  =							False
      snake_case_  =							False


      def  __UpperCAmelCase		(	self	)->	Dict:
           __lowerCAmelCase								=					TFLEDModelTester(self	)
           __lowerCAmelCase								=					ConfigTester(self					,						config_class=__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Any:
           self.config_tester.run_common_tests()


      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           __lowerCAmelCase								=					self.model_tester.prepare_config_and_inputs_for_common()
           self.model_tester.check_decoder_model_past_large_inputs(*__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Dict:
           __lowerCAmelCase			, __lowerCAmelCase								=					self.model_tester.prepare_config_and_inputs_for_common()
           __lowerCAmelCase								=					tf.zeros_like(inputs_dict["attention_mask"]	)
           __lowerCAmelCase								=					2
           __lowerCAmelCase								=					tf.where(
               tf.range(self.model_tester.seq_length	)[None, :] < num_global_attn_indices					,						1					,						inputs_dict["global_attention_mask"]					,						)

           __lowerCAmelCase								=					True
           __lowerCAmelCase								=					self.model_tester.seq_length
           __lowerCAmelCase								=					self.model_tester.encoder_seq_length

           def check_decoder_attentions_output(__UpperCamelCase	):
                __lowerCAmelCase								=					outputs.decoder_attentions
                self.assertEqual(len(__UpperCamelCase	)					,						self.model_tester.num_hidden_layers	)
                self.assertListEqual(
                    list(decoder_attentions[0].shape[-3:]	)					,						[self.model_tester.num_attention_heads, seq_length, seq_length]					,						)

           def check_encoder_attentions_output(__UpperCamelCase	):
                __lowerCAmelCase								=					[t.numpy() for t in outputs.encoder_attentions]
                __lowerCAmelCase								=					[t.numpy() for t in outputs.encoder_global_attentions]
                self.assertEqual(len(__UpperCamelCase	)					,						self.model_tester.num_hidden_layers	)
                self.assertEqual(len(__UpperCamelCase	)					,						self.model_tester.num_hidden_layers	)
                self.assertListEqual(
                    list(attentions[0].shape[-3:]	)					,						[self.model_tester.num_attention_heads, seq_length, seq_length]					,						)
                self.assertListEqual(
                    list(global_attentions[0].shape[-3:]	)					,						[self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]					,						)

           for model_class in self.all_model_classes:
                __lowerCAmelCase								=					True
                __lowerCAmelCase								=					False
                __lowerCAmelCase								=					False
                __lowerCAmelCase								=					model_class(__UpperCamelCase	)
                __lowerCAmelCase								=					model(self._prepare_for_class(__UpperCamelCase					,						__UpperCamelCase	)	)
                __lowerCAmelCase								=					len(__UpperCamelCase	)
                self.assertEqual(config.output_hidden_states					,						__UpperCamelCase	)
                check_encoder_attentions_output(__UpperCamelCase	)

                if self.is_encoder_decoder:
                     __lowerCAmelCase								=					model_class(__UpperCamelCase	)
                     __lowerCAmelCase								=					model(self._prepare_for_class(__UpperCamelCase					,						__UpperCamelCase	)	)
                     self.assertEqual(config.output_hidden_states					,						__UpperCamelCase	)
                     check_decoder_attentions_output(__UpperCamelCase	)

                # Check that output attentions can also be changed via the config
                del inputs_dict["output_attentions"]
                __lowerCAmelCase								=					True
                __lowerCAmelCase								=					model_class(__UpperCamelCase	)
                __lowerCAmelCase								=					model(self._prepare_for_class(__UpperCamelCase					,						__UpperCamelCase	)	)
                self.assertEqual(config.output_hidden_states					,						__UpperCamelCase	)
                check_encoder_attentions_output(__UpperCamelCase	)

                # Check attention is always last and order is fine
                __lowerCAmelCase								=					True
                __lowerCAmelCase								=					True
                __lowerCAmelCase								=					model_class(__UpperCamelCase	)
                __lowerCAmelCase								=					model(self._prepare_for_class(__UpperCamelCase					,						__UpperCamelCase	)	)

                self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)					,						len(__UpperCamelCase	)	)
                self.assertEqual(model.config.output_hidden_states					,						__UpperCamelCase	)
                check_encoder_attentions_output(__UpperCamelCase	)


      @unittest.skip("LED keeps using potentially symbolic tensors in conditionals and breaks tracing."	)
      def  __UpperCAmelCase		(	self	)->	List[Any]:
           pass


      def  __UpperCAmelCase		(	self	)->	Tuple:
           # TODO: Head-masking not yet implement
           pass





def       __lowerCAmelCase      (						__snake_case       ):
     return tf.constant(__snake_case					, dtype=tf.intaa       )


lowerCamelCase			:					Optional[Any]         =	1E-4



@slow
@require_tf
class 							_UpperCamelCase			(unittest.TestCase			):


      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384"	).led

           # change to intended input here
           __lowerCAmelCase								=					_long_tensor([5_1_2 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]	)
           __lowerCAmelCase								=					_long_tensor([1_2_8 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]	)
           __lowerCAmelCase								=					prepare_led_inputs_dict(model.config					,						__UpperCamelCase					,						__UpperCamelCase	)
           __lowerCAmelCase								=					model(**__UpperCamelCase	)[0]
           __lowerCAmelCase								=					(1, 1_0_2_4, 7_6_8)
           self.assertEqual(output.shape					,						__UpperCamelCase	)
           # change to expected output here
           __lowerCAmelCase								=					tf.convert_to_tensor(
               [[2.3_0_5_0, 2.8_2_7_9, 0.6_5_3_1], [-1.8_4_5_7, -0.1_4_5_5, -3.5_6_6_1], [-1.0_1_8_6, 0.4_5_8_6, -2.2_0_4_3]]					,						)
           tf.debugging.assert_near(output[:, :3, :3]					,						__UpperCamelCase					,						atol=1e-3	)


      def  __UpperCAmelCase		(	self	)->	int:
           __lowerCAmelCase								=					TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384"	)

           # change to intended input here
           __lowerCAmelCase								=					_long_tensor([5_1_2 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]	)
           __lowerCAmelCase								=					_long_tensor([1_2_8 * [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9]]	)
           __lowerCAmelCase								=					prepare_led_inputs_dict(model.config					,						__UpperCamelCase					,						__UpperCamelCase	)
           __lowerCAmelCase								=					model(**__UpperCamelCase	)[0]
           __lowerCAmelCase								=					(1, 1_0_2_4, model.config.vocab_size)
           self.assertEqual(output.shape					,						__UpperCamelCase	)
           # change to expected output here
           __lowerCAmelCase								=					tf.convert_to_tensor(
               [[3_3.6_5_0_7, 6.4_5_7_2, 1_6.8_0_8_9], [5.8_7_3_9, -2.4_2_3_8, 1_1.2_9_0_2], [-3.2_1_3_9, -4.3_1_4_9, 4.2_7_8_3]]					,						)
           tf.debugging.assert_near(output[:, :3, :3]					,						__UpperCamelCase					,						atol=1e-3					,						rtol=1e-3	)














from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_batched,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


lowerCamelCase			:					Optional[Any]         =	logging.get_logger(__name__)



class 							_UpperCamelCase			(a_			):
      snake_case_  =							["""pixel_values"""]


      def __init__(	self					,						__UpperCamelCase = True					,						__UpperCamelCase = None					,						__UpperCamelCase = PILImageResampling.BICUBIC					,						__UpperCamelCase = True					,						__UpperCamelCase = True					,						__UpperCamelCase = 1 / 2_5_5					,						__UpperCamelCase = None					,						__UpperCamelCase = True					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						**__UpperCamelCase					,						)->	None:
           super().__init__(**__UpperCamelCase	)
           __lowerCAmelCase								=					size if size is not None else {"height": 2_2_4, "width": 2_2_4}
           __lowerCAmelCase								=					get_size_dict(__UpperCamelCase	)
           __lowerCAmelCase								=					crop_size if crop_size is not None else {"height": 2_2_4, "width": 2_2_4}
           __lowerCAmelCase								=					get_size_dict(__UpperCamelCase					,						default_to_square=__UpperCamelCase					,						param_name="crop_size"	)

           __lowerCAmelCase								=					do_resize
           __lowerCAmelCase								=					do_rescale
           __lowerCAmelCase								=					do_normalize
           __lowerCAmelCase								=					do_center_crop
           __lowerCAmelCase								=					crop_size
           __lowerCAmelCase								=					size
           __lowerCAmelCase								=					resample
           __lowerCAmelCase								=					rescale_factor
           __lowerCAmelCase								=					image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
           __lowerCAmelCase								=					image_std if image_std is not None else IMAGENET_DEFAULT_STD


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase = PILImageResampling.BILINEAR					,						__UpperCamelCase = None					,						**__UpperCamelCase					,						)->	np.ndarray:
           __lowerCAmelCase								=					get_size_dict(__UpperCamelCase	)

           if "shortest_edge" in size:
                __lowerCAmelCase								=					get_resize_output_image_size(__UpperCamelCase					,						size=size["shortest_edge"]					,						default_to_square=__UpperCamelCase	)
                # size = get_resize_output_image_size(image, size["shortest_edge"], size["longest_edge"])
           elif "height" in size and "width" in size:
                __lowerCAmelCase								=					(size["height"], size["width"])
           else:
                raise ValueError(F"""Size must contain 'height' and 'width' keys or 'shortest_edge' key. Got {size.keys()}"""	)
           return resize(__UpperCamelCase					,						size=__UpperCamelCase					,						resample=__UpperCamelCase					,						data_format=__UpperCamelCase					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase = None					,						**__UpperCamelCase					,						)->	np.ndarray:
           __lowerCAmelCase								=					get_size_dict(__UpperCamelCase	)
           if "height" not in size or "width" not in size:
                raise ValueError(F"""The `size` parameter must contain the keys (height, width). Got {size.keys()}"""	)
           return center_crop(__UpperCamelCase					,						size=(size["height"], size["width"])					,						data_format=__UpperCamelCase					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase = None					,						**__UpperCamelCase	)->	np.ndarray:
           return rescale(__UpperCamelCase					,						scale=__UpperCamelCase					,						data_format=__UpperCamelCase					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase = None					,						**__UpperCamelCase					,						)->	np.ndarray:
           return normalize(__UpperCamelCase					,						mean=__UpperCamelCase					,						std=__UpperCamelCase					,						data_format=__UpperCamelCase					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = None					,						__UpperCamelCase = ChannelDimension.FIRST					,						**__UpperCamelCase					,						)->	BatchFeature:
           __lowerCAmelCase								=					do_resize if do_resize is not None else self.do_resize
           __lowerCAmelCase								=					do_rescale if do_rescale is not None else self.do_rescale
           __lowerCAmelCase								=					do_normalize if do_normalize is not None else self.do_normalize
           __lowerCAmelCase								=					do_center_crop if do_center_crop is not None else self.do_center_crop
           __lowerCAmelCase								=					crop_size if crop_size is not None else self.crop_size
           __lowerCAmelCase								=					get_size_dict(__UpperCamelCase					,						param_name="crop_size"					,						default_to_square=__UpperCamelCase	)
           __lowerCAmelCase								=					resample if resample is not None else self.resample
           __lowerCAmelCase								=					rescale_factor if rescale_factor is not None else self.rescale_factor
           __lowerCAmelCase								=					image_mean if image_mean is not None else self.image_mean
           __lowerCAmelCase								=					image_std if image_std is not None else self.image_std

           __lowerCAmelCase								=					size if size is not None else self.size
           __lowerCAmelCase								=					get_size_dict(__UpperCamelCase	)

           if not is_batched(__UpperCamelCase	):
                __lowerCAmelCase								=					[images]

           if not valid_images(__UpperCamelCase	):
                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_center_crop and crop_size is None:
                raise ValueError("Crop size must be specified if do_center_crop is True."	)

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

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

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

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

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

           if do_normalize:
                __lowerCAmelCase								=					[self.normalize(image=__UpperCamelCase					,						mean=__UpperCamelCase					,						std=__UpperCamelCase	) for image in images]

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

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






