






import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import (
			    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
			    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
			    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
			    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
			    LayoutLMvaConfig,
			    LayoutLMvaForQuestionAnswering,
			    LayoutLMvaForSequenceClassification,
			    LayoutLMvaForTokenClassification,
			    LayoutLMvaModel,
			)
			from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
			from PIL import Image

			from transformers import LayoutLMvaImageProcessor
class 			lowerCAmelCase_							:




							def __init__( self  : Union[str, Any]			,				SCREAMING_SNAKE_CASE_  : Tuple			,				SCREAMING_SNAKE_CASE_  : str=2			,				SCREAMING_SNAKE_CASE_  : Optional[int]=3			,				SCREAMING_SNAKE_CASE_  : List[str]=4			,				SCREAMING_SNAKE_CASE_  : Union[str, Any]=2			,				SCREAMING_SNAKE_CASE_  : Any=7			,				SCREAMING_SNAKE_CASE_  : Any=True			,				SCREAMING_SNAKE_CASE_  : Tuple=True			,				SCREAMING_SNAKE_CASE_  : List[str]=True			,				SCREAMING_SNAKE_CASE_  : Dict=True			,				SCREAMING_SNAKE_CASE_  : Union[str, Any]=99			,				SCREAMING_SNAKE_CASE_  : Optional[int]=36			,				SCREAMING_SNAKE_CASE_  : Tuple=3			,				SCREAMING_SNAKE_CASE_  : int=4			,				SCREAMING_SNAKE_CASE_  : str=37			,				SCREAMING_SNAKE_CASE_  : List[Any]="gelu"			,				SCREAMING_SNAKE_CASE_  : Optional[int]=0.1			,				SCREAMING_SNAKE_CASE_  : Any=0.1			,				SCREAMING_SNAKE_CASE_  : Optional[int]=512			,				SCREAMING_SNAKE_CASE_  : Optional[int]=16			,				SCREAMING_SNAKE_CASE_  : Any=2			,				SCREAMING_SNAKE_CASE_  : List[Any]=0.02			,				SCREAMING_SNAKE_CASE_  : Tuple=6			,				SCREAMING_SNAKE_CASE_  : int=6			,				SCREAMING_SNAKE_CASE_  : List[Any]=3			,				SCREAMING_SNAKE_CASE_  : str=4			,				SCREAMING_SNAKE_CASE_  : Union[str, Any]=None			,				SCREAMING_SNAKE_CASE_  : Optional[Any]=1_000			,				):
											lowerCAmelCase__         =    parent
											lowerCAmelCase__         =    batch_size
											lowerCAmelCase__         =    num_channels
											lowerCAmelCase__         =    image_size
											lowerCAmelCase__         =    patch_size
											lowerCAmelCase__         =    text_seq_length
											lowerCAmelCase__         =    is_training
											lowerCAmelCase__         =    use_input_mask
											lowerCAmelCase__         =    use_token_type_ids
											lowerCAmelCase__         =    use_labels
											lowerCAmelCase__         =    vocab_size
											lowerCAmelCase__         =    hidden_size
											lowerCAmelCase__         =    num_hidden_layers
											lowerCAmelCase__         =    num_attention_heads
											lowerCAmelCase__         =    intermediate_size
											lowerCAmelCase__         =    hidden_act
											lowerCAmelCase__         =    hidden_dropout_prob
											lowerCAmelCase__         =    attention_probs_dropout_prob
											lowerCAmelCase__         =    max_position_embeddings
											lowerCAmelCase__         =    type_vocab_size
											lowerCAmelCase__         =    type_sequence_label_size
											lowerCAmelCase__         =    initializer_range
											lowerCAmelCase__         =    coordinate_size
											lowerCAmelCase__         =    shape_size
											lowerCAmelCase__         =    num_labels
											lowerCAmelCase__         =    num_choices
											lowerCAmelCase__         =    scope
											lowerCAmelCase__         =    range_bbox

											# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
											lowerCAmelCase__         =    text_seq_length
											lowerCAmelCase__         =    (image_size // patch_size) ** 2 + 1
											lowerCAmelCase__         =    self.text_seq_length + self.image_seq_length




							def     __snake_case       ( self  : List[Any]						):
											lowerCAmelCase__         =    ids_tensor([self.batch_size, self.text_seq_length]			,				self.vocab_size						)

											lowerCAmelCase__         =    ids_tensor([self.batch_size, self.text_seq_length, 4]			,				self.range_bbox						)
											# Ensure that bbox is legal
											for i in range(bbox.shape[0]						):
															for j in range(bbox.shape[1]						):
																			if bbox[i, j, 3] < bbox[i, j, 1]:
																							lowerCAmelCase__         =    bbox[i, j, 3]
																							lowerCAmelCase__         =    bbox[i, j, 1]
																							lowerCAmelCase__         =    t
																			if bbox[i, j, 2] < bbox[i, j, 0]:
																							lowerCAmelCase__         =    bbox[i, j, 2]
																							lowerCAmelCase__         =    bbox[i, j, 0]
																							lowerCAmelCase__         =    t

											lowerCAmelCase__         =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

											lowerCAmelCase__         =    None
											if self.use_input_mask:
															lowerCAmelCase__         =    random_attention_mask([self.batch_size, self.text_seq_length]						)

											lowerCAmelCase__         =    None
											if self.use_token_type_ids:
															lowerCAmelCase__         =    ids_tensor([self.batch_size, self.text_seq_length]			,				self.type_vocab_size						)

											lowerCAmelCase__         =    None
											lowerCAmelCase__         =    None
											if self.use_labels:
															lowerCAmelCase__         =    ids_tensor([self.batch_size]			,				self.type_sequence_label_size						)
															lowerCAmelCase__         =    ids_tensor([self.batch_size, self.text_seq_length]			,				self.num_labels						)

											lowerCAmelCase__         =    LayoutLMvaConfig(
											    vocab_size=self.vocab_size			,				hidden_size=self.hidden_size			,				num_hidden_layers=self.num_hidden_layers			,				num_attention_heads=self.num_attention_heads			,				intermediate_size=self.intermediate_size			,				hidden_act=self.hidden_act			,				hidden_dropout_prob=self.hidden_dropout_prob			,				attention_probs_dropout_prob=self.attention_probs_dropout_prob			,				max_position_embeddings=self.max_position_embeddings			,				type_vocab_size=self.type_vocab_size			,				initializer_range=self.initializer_range			,				coordinate_size=self.coordinate_size			,				shape_size=self.shape_size			,				input_size=self.image_size			,				patch_size=self.patch_size			,				)

											return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels




							def     __snake_case       ( self  : List[Any]			,				SCREAMING_SNAKE_CASE_  : Dict			,				SCREAMING_SNAKE_CASE_  : Tuple			,				SCREAMING_SNAKE_CASE_  : List[Any]			,				SCREAMING_SNAKE_CASE_  : Any			,				SCREAMING_SNAKE_CASE_  : Any			,				SCREAMING_SNAKE_CASE_  : Any			,				SCREAMING_SNAKE_CASE_  : Any			,				SCREAMING_SNAKE_CASE_  : Union[str, Any]						):
											lowerCAmelCase__         =    LayoutLMvaModel(config=SCREAMING_SNAKE_CASE_						)
											model.to(SCREAMING_SNAKE_CASE_						)
											model.eval()

											# text + image
											lowerCAmelCase__         =    model(SCREAMING_SNAKE_CASE_			,				pixel_values=SCREAMING_SNAKE_CASE_						)
											lowerCAmelCase__         =    model(
											    SCREAMING_SNAKE_CASE_			,				bbox=SCREAMING_SNAKE_CASE_			,				pixel_values=SCREAMING_SNAKE_CASE_			,				attention_mask=SCREAMING_SNAKE_CASE_			,				token_type_ids=SCREAMING_SNAKE_CASE_						)
											lowerCAmelCase__         =    model(SCREAMING_SNAKE_CASE_			,				bbox=SCREAMING_SNAKE_CASE_			,				pixel_values=SCREAMING_SNAKE_CASE_			,				token_type_ids=SCREAMING_SNAKE_CASE_						)
											lowerCAmelCase__         =    model(SCREAMING_SNAKE_CASE_			,				bbox=SCREAMING_SNAKE_CASE_			,				pixel_values=SCREAMING_SNAKE_CASE_						)

											self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size)						)

											# text only
											lowerCAmelCase__         =    model(SCREAMING_SNAKE_CASE_						)
											self.parent.assertEqual(
											    result.last_hidden_state.shape			,				(self.batch_size, self.text_seq_length, self.hidden_size)						)

											# image only
											lowerCAmelCase__         =    model(pixel_values=SCREAMING_SNAKE_CASE_						)
											self.parent.assertEqual(
											    result.last_hidden_state.shape			,				(self.batch_size, self.image_seq_length, self.hidden_size)						)




							def     __snake_case       ( self  : int			,				SCREAMING_SNAKE_CASE_  : List[Any]			,				SCREAMING_SNAKE_CASE_  : Optional[int]			,				SCREAMING_SNAKE_CASE_  : List[str]			,				SCREAMING_SNAKE_CASE_  : Optional[int]			,				SCREAMING_SNAKE_CASE_  : Tuple			,				SCREAMING_SNAKE_CASE_  : Dict			,				SCREAMING_SNAKE_CASE_  : List[str]			,				SCREAMING_SNAKE_CASE_  : int						):
											lowerCAmelCase__         =    self.num_labels
											lowerCAmelCase__         =    LayoutLMvaForSequenceClassification(SCREAMING_SNAKE_CASE_						)
											model.to(SCREAMING_SNAKE_CASE_						)
											model.eval()
											lowerCAmelCase__         =    model(
											    SCREAMING_SNAKE_CASE_			,				bbox=SCREAMING_SNAKE_CASE_			,				pixel_values=SCREAMING_SNAKE_CASE_			,				attention_mask=SCREAMING_SNAKE_CASE_			,				token_type_ids=SCREAMING_SNAKE_CASE_			,				labels=SCREAMING_SNAKE_CASE_			,				)
											self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels)						)




							def     __snake_case       ( self  : List[Any]			,				SCREAMING_SNAKE_CASE_  : Optional[Any]			,				SCREAMING_SNAKE_CASE_  : Tuple			,				SCREAMING_SNAKE_CASE_  : Dict			,				SCREAMING_SNAKE_CASE_  : Any			,				SCREAMING_SNAKE_CASE_  : int			,				SCREAMING_SNAKE_CASE_  : Any			,				SCREAMING_SNAKE_CASE_  : str			,				SCREAMING_SNAKE_CASE_  : List[str]						):
											lowerCAmelCase__         =    self.num_labels
											lowerCAmelCase__         =    LayoutLMvaForTokenClassification(config=SCREAMING_SNAKE_CASE_						)
											model.to(SCREAMING_SNAKE_CASE_						)
											model.eval()
											lowerCAmelCase__         =    model(
											    SCREAMING_SNAKE_CASE_			,				bbox=SCREAMING_SNAKE_CASE_			,				pixel_values=SCREAMING_SNAKE_CASE_			,				attention_mask=SCREAMING_SNAKE_CASE_			,				token_type_ids=SCREAMING_SNAKE_CASE_			,				labels=SCREAMING_SNAKE_CASE_			,				)
											self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.text_seq_length, self.num_labels)						)




							def     __snake_case       ( self  : Dict			,				SCREAMING_SNAKE_CASE_  : Tuple			,				SCREAMING_SNAKE_CASE_  : Optional[Any]			,				SCREAMING_SNAKE_CASE_  : Dict			,				SCREAMING_SNAKE_CASE_  : Tuple			,				SCREAMING_SNAKE_CASE_  : Union[str, Any]			,				SCREAMING_SNAKE_CASE_  : Union[str, Any]			,				SCREAMING_SNAKE_CASE_  : Any			,				SCREAMING_SNAKE_CASE_  : Optional[int]						):
											lowerCAmelCase__         =    LayoutLMvaForQuestionAnswering(config=SCREAMING_SNAKE_CASE_						)
											model.to(SCREAMING_SNAKE_CASE_						)
											model.eval()
											lowerCAmelCase__         =    model(
											    SCREAMING_SNAKE_CASE_			,				bbox=SCREAMING_SNAKE_CASE_			,				pixel_values=SCREAMING_SNAKE_CASE_			,				attention_mask=SCREAMING_SNAKE_CASE_			,				token_type_ids=SCREAMING_SNAKE_CASE_			,				start_positions=SCREAMING_SNAKE_CASE_			,				end_positions=SCREAMING_SNAKE_CASE_			,				)
											self.parent.assertEqual(result.start_logits.shape			,				(self.batch_size, self.seq_length)						)
											self.parent.assertEqual(result.end_logits.shape			,				(self.batch_size, self.seq_length)						)




							def     __snake_case       ( self  : List[Any]						):
											lowerCAmelCase__         =    self.prepare_config_and_inputs()
											(
											    (
											    lowerCAmelCase__ 
											)      ,		(
											    lowerCAmelCase__ 
											)      ,		(
											    lowerCAmelCase__ 
											)      ,		(
											    lowerCAmelCase__ 
											)      ,		(
											    lowerCAmelCase__ 
											)      ,		(
											    lowerCAmelCase__ 
											)      ,		(
											    lowerCAmelCase__ 
											)      ,		(
											    lowerCAmelCase__ 
											)      ,		 
											)         =    config_and_inputs
											lowerCAmelCase__         =    {
											    '''input_ids''': input_ids,
											    '''bbox''': bbox,
											    '''pixel_values''': pixel_values,
											    '''token_type_ids''': token_type_ids,
											    '''attention_mask''': input_mask,
											}
											return config, inputs_dict



@require_torch
class 			lowerCAmelCase_							(					snake_case__  ,     snake_case__  ,     unittest.TestCase       ):
							UpperCamelCase_		:Optional[int]		   =     False
							UpperCamelCase_		:List[Any]		   =     False
							UpperCamelCase_		:Tuple		   =     False

							UpperCamelCase_		:str		   =     (
							    (
							        LayoutLMvaModel,
							        LayoutLMvaForSequenceClassification,
							        LayoutLMvaForTokenClassification,
							        LayoutLMvaForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							UpperCamelCase_		:Dict		   =     (
							    {'document-question-answering': LayoutLMvaForQuestionAnswering, 'feature-extraction': LayoutLMvaModel}
							    if is_torch_available()
							    else {}
							)




							def     __snake_case       ( self  : Optional[int]			,				SCREAMING_SNAKE_CASE_  : str			,				SCREAMING_SNAKE_CASE_  : Tuple			,				SCREAMING_SNAKE_CASE_  : Dict			,				SCREAMING_SNAKE_CASE_  : int			,				SCREAMING_SNAKE_CASE_  : List[str]						):
											# `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
											# embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
											# the sequence dimension of the text embedding only.
											# (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
											return True




							def     __snake_case       ( self  : Optional[int]						):
											lowerCAmelCase__         =    LayoutLMvaModelTester(self						)
											lowerCAmelCase__         =    ConfigTester(self			,				config_class=SCREAMING_SNAKE_CASE_			,				hidden_size=37						)




							def     __snake_case       ( self  : Optional[int]			,				SCREAMING_SNAKE_CASE_  : str			,				SCREAMING_SNAKE_CASE_  : Any			,				SCREAMING_SNAKE_CASE_  : Union[str, Any]=False						):
											lowerCAmelCase__         =    copy.deepcopy(SCREAMING_SNAKE_CASE_						)
											if model_class in get_values(SCREAMING_SNAKE_CASE_						):
															lowerCAmelCase__         =    {
															    k: v.unsqueeze(1						).expand(-1			,				self.model_tester.num_choices			,				-1						).contiguous()
															    if isinstance(SCREAMING_SNAKE_CASE_			,				torch.Tensor						) and v.ndim > 1
															    else v
															    for k, v in inputs_dict.items()
															}
											if return_labels:
															if model_class in get_values(SCREAMING_SNAKE_CASE_						):
																			lowerCAmelCase__         =    torch.ones(self.model_tester.batch_size			,				dtype=torch.long			,				device=SCREAMING_SNAKE_CASE_						)
															elif model_class in get_values(SCREAMING_SNAKE_CASE_						):
																			lowerCAmelCase__         =    torch.zeros(
																			    self.model_tester.batch_size			,				dtype=torch.long			,				device=SCREAMING_SNAKE_CASE_						)
																			lowerCAmelCase__         =    torch.zeros(
																			    self.model_tester.batch_size			,				dtype=torch.long			,				device=SCREAMING_SNAKE_CASE_						)
															elif model_class in [
															    *get_values(SCREAMING_SNAKE_CASE_						),
															]:
																			lowerCAmelCase__         =    torch.zeros(
																			    self.model_tester.batch_size			,				dtype=torch.long			,				device=SCREAMING_SNAKE_CASE_						)
															elif model_class in [
															    *get_values(SCREAMING_SNAKE_CASE_						),
															]:
																			lowerCAmelCase__         =    torch.zeros(
																			    (self.model_tester.batch_size, self.model_tester.text_seq_length)			,				dtype=torch.long			,				device=SCREAMING_SNAKE_CASE_			,				)

											return inputs_dict




							def     __snake_case       ( self  : int						):
											self.config_tester.run_common_tests()




							def     __snake_case       ( self  : str						):
											lowerCAmelCase__         =    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_						)




							def     __snake_case       ( self  : str						):
											lowerCAmelCase__         =    self.model_tester.prepare_config_and_inputs()
											for type in ["absolute", "relative_key", "relative_key_query"]:
															lowerCAmelCase__         =    type
															self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_						)




							def     __snake_case       ( self  : Optional[int]						):
											lowerCAmelCase__         =    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE_						)




							def     __snake_case       ( self  : List[Any]						):
											lowerCAmelCase__         =    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE_						)




							def     __snake_case       ( self  : List[str]						):
											lowerCAmelCase__         =    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE_						)




							@slow
							def     __snake_case       ( self  : Optional[int]						):
											for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowerCAmelCase__         =    LayoutLMvaModel.from_pretrained(SCREAMING_SNAKE_CASE_						)
															self.assertIsNotNone(SCREAMING_SNAKE_CASE_						)





def 						lowerCAmelCase_		()		->     Tuple:


				'''simple docstring'''




				lowerCAmelCase__         =    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
				return image




@require_torch
class 			lowerCAmelCase_							(					unittest.TestCase       ):




							@cached_property
							def     __snake_case       ( self  : List[str]						):
											return LayoutLMvaImageProcessor(apply_ocr=SCREAMING_SNAKE_CASE_						) if is_vision_available() else None




							@slow
							def     __snake_case       ( self  : str						):
											lowerCAmelCase__         =    LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''						).to(SCREAMING_SNAKE_CASE_						)

											lowerCAmelCase__         =    self.default_image_processor
											lowerCAmelCase__         =    prepare_img()
											lowerCAmelCase__         =    image_processor(images=SCREAMING_SNAKE_CASE_			,				return_tensors='''pt'''						).pixel_values.to(SCREAMING_SNAKE_CASE_						)

											lowerCAmelCase__         =    torch.tensor([[1, 2]]						)
											lowerCAmelCase__         =    torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]						).unsqueeze(0						)

											# forward pass
											lowerCAmelCase__         =    model(
											    input_ids=input_ids.to(SCREAMING_SNAKE_CASE_						)			,				bbox=bbox.to(SCREAMING_SNAKE_CASE_						)			,				pixel_values=pixel_values.to(SCREAMING_SNAKE_CASE_						)			,				)

											# verify the logits
											lowerCAmelCase__         =    torch.Size((1, 199, 768)						)
											self.assertEqual(outputs.last_hidden_state.shape			,				SCREAMING_SNAKE_CASE_						)

											lowerCAmelCase__         =    torch.tensor(
											    [[-0.0_529, 0.3_618, 0.1_632], [-0.1_587, -0.1_667, -0.0_400], [-0.1_557, -0.1_671, -0.0_505]]						).to(SCREAMING_SNAKE_CASE_						)

											self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]			,				SCREAMING_SNAKE_CASE_			,				atol=1e-4						)						)







"""simple docstring"""


from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import pyarrow as pa


if TYPE_CHECKING:
						from .features import FeatureType




@dataclass
class  __lowerCamelCase  :
				a__:      List[str]
				a__:      Optional[str]          =    None
				# Automatically constructed
				a__:      ClassVar[str]          =    "dict"
				a__:      ClassVar[Any]          =    None
				a__:      str          =    field(default='Translation'						,	init=lowerCAmelCase						,	repr=lowerCAmelCase			)




				def __call__(				self   ):
							return pa.struct({lang: pa.string() for lang in sorted(self.languages   )}   )





				def        UpperCAmelCase__						(				self   ):
							from .features import Value

							return {k: Value('''string'''   ) for k in sorted(self.languages   )}




@dataclass
class  __lowerCamelCase  :
				a__:      Optional[List]          =    None
				a__:      Optional[int]          =    None
				a__:      Optional[str]          =    None
				# Automatically constructed
				a__:      ClassVar[str]          =    "dict"
				a__:      ClassVar[Any]          =    None
				a__:      str          =    field(default='TranslationVariableLanguages'						,	init=lowerCAmelCase						,	repr=lowerCAmelCase			)




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  sorted(set(self.languages   )   ) if self.languages else None
							lowerCamelCase_					=  len(self.languages   ) if self.languages else None




				def __call__(				self   ):
							return pa.struct({'''language''': pa.list_(pa.string()   ), '''translation''': pa.list_(pa.string()   )}   )




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							lowerCamelCase_					=  set(self.languages   )
							if self.languages and set(UpperCAmelCase   ) - lang_set:
										raise ValueError(
										    f"Some languages in example ({', '.join(sorted(set(UpperCAmelCase   ) - lang_set   )   )}) are not in valid set ({', '.join(UpperCAmelCase   )})."   )

							# Convert dictionary into tuples, splitting out cases where there are
							# multiple translations for a single language.
							lowerCamelCase_					=  []
							for lang, text in translation_dict.items():
										if isinstance(UpperCAmelCase							,						UpperCAmelCase   ):
													translation_tuples.append((lang, text)   )
										else:
													translation_tuples.extend([(lang, el) for el in text]   )

        # Ensure translations are in ascending order by language code.
							lowerCamelCase_		, lowerCamelCase_					=  zip(*sorted(UpperCAmelCase   )   )

							return {"language": languages, "translation": translations}





				def        UpperCAmelCase__						(				self   ):
							from .features import Sequence, Value

							return {
							    "language": Sequence(Value('''string'''   )   ),
							    "translation": Sequence(Value('''string'''   )   ),
							}



