
class      UpperCamelCase_			:







						'''simple docstring'''



						def __init__( self       :str    )     ->None:
										# numbermap keys are the number and its values are lists of indexes sorted
										# in ascending order
										lowercase						    =			{}
										# indexmap keys are an index and it's values are the number at that index
										lowercase						    =			{}





						def 					SCREAMING_SNAKE_CASE( self       :Optional[Any]		,						lowerCAmelCase__       :list | str | range		,						lowerCAmelCase__       :int    )     ->list[int]:
										if isinstance(lowerCAmelCase__		,						(range, str)    ):
														lowercase						    =			list(lowerCAmelCase__    )
										elif not isinstance(lowerCAmelCase__		,						lowerCAmelCase__    ):
														raise TypeError(
														    "binary_search_delete() only accepts either a list, range or str"    )

										lowercase						    =			0
										lowercase						    =			len(lowerCAmelCase__    ) - 1

										while low <= high:
														lowercase						    =			(low + high) // 2
														if array[mid] == item:
																		array.pop(lowerCAmelCase__    )
																		return array
														elif array[mid] < item:
																		lowercase						    =			mid + 1
														else:
																		lowercase						    =			mid - 1
										raise ValueError(
										    "Either the item is not in the array or the array was unsorted"    )





						def 					SCREAMING_SNAKE_CASE( self       :Tuple		,						lowerCAmelCase__       :list | str | range		,						lowerCAmelCase__       :int    )     ->list[int]:
										if isinstance(lowerCAmelCase__		,						(range, str)    ):
														lowercase						    =			list(lowerCAmelCase__    )
										elif not isinstance(lowerCAmelCase__		,						lowerCAmelCase__    ):
														raise TypeError(
														    "binary_search_insert() only accepts either a list, range or str"    )

										lowercase						    =			0
										lowercase						    =			len(lowerCAmelCase__    ) - 1

										while low <= high:
														lowercase						    =			(low + high) // 2
														if array[mid] == index:
																		# If the item already exists in the array,
																		# insert it after the existing item
																		array.insert(mid + 1		,						lowerCAmelCase__    )
																		return array
														elif array[mid] < index:
																		lowercase						    =			mid + 1
														else:
																		lowercase						    =			mid - 1

														# If the item doesn't exist in the array, insert it at the appropriate position
										array.insert(lowerCAmelCase__		,						lowerCAmelCase__    )
										return array





						def 					SCREAMING_SNAKE_CASE( self       :int		,						lowerCAmelCase__       :int		,						lowerCAmelCase__       :int    )     ->None:
										# Remove previous index
										if index in self.indexmap:
														lowercase						    =			self.indexmap[index]
														if len(self.numbermap[n]    ) == 1:
																		del self.numbermap[n]
														else:
																		lowercase						    =			self.binary_search_delete(self.numbermap[n]		,						lowerCAmelCase__    )

														# Set new index
										lowercase						    =			number

										# Number not seen before or empty so insert number value
										if number not in self.numbermap:
														lowercase						    =			[index]

										# Here we need to perform a binary search insertion in order to insert
										# The item in the correct place
										else:
														lowercase						    =			self.binary_search_insert(
														    self.numbermap[number]		,						lowerCAmelCase__    )





						def 					SCREAMING_SNAKE_CASE( self       :Optional[int]		,						lowerCAmelCase__       :int    )     ->int:
										return self.numbermap.get(lowerCAmelCase__		,						[-1]    )[0]


if __name__ == "__main__":
						import doctest

						doctest.testmod()


# This test is meant to be run in on an instance with TPUs like this:
#
#   python examples/pytorch/xla_spawn.py --num_cores=8 tests/test_trainer_tpu.py
#
# Replace 8 with the number of TPU cores you have.
#

import sys
from typing import Dict

from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available
from transformers.utils import logging


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


if is_torch_available():
						import torch
						from torch import nn
						from torch.utils.data import Dataset

						from transformers import Trainer





						class      UpperCamelCase_			(			__a		):







												'''simple docstring'''



												def __init__( self       :Optional[int]		,						lowerCAmelCase__       :int = 101    )     ->Any:
																lowercase						    =			length





												def __len__( self       :Tuple    )     ->Any:
																return self.length





												def __getitem__( self       :Any		,						lowerCAmelCase__       :Tuple    )     ->int:
																return i





						class      UpperCamelCase_			:







												'''simple docstring'''



												def __call__( self       :Optional[Any]		,						lowerCAmelCase__       :List[Any]    )     ->int:
																return {"input_ids": torch.tensor(lowerCAmelCase__    ), "labels": torch.tensor(lowerCAmelCase__    )}





						class      UpperCamelCase_			(			nn.Module		):







												'''simple docstring'''



												def __init__( self       :Any    )     ->str:
																super().__init__()
																# Add some (unused) params otherwise DDP will complain.
																lowercase						    =			nn.Linear(120		,						80    )





												def 					SCREAMING_SNAKE_CASE( self       :int		,						lowerCAmelCase__       :Optional[int]		,						lowerCAmelCase__       :Union[str, Any]=None    )     ->List[Any]:
																if labels is not None:
																				return torch.tensor(0.0		,						device=input_ids.device    ), input_ids
																else:
																				return input_ids

def    __snake_case       (  ):







				'''simple docstring'''


				lowercase						    =			HfArgumentParser((TrainingArguments,)	)
				sys.argv += ["--output_dir", "./examples"]
				lowercase						    =			parser.parse_args_into_dataclasses()[0]

				logger.warning(
				    F'''Process rank: {training_args.local_rank}, device: {training_args.device}, '''
				    F'''tpu_num_cores: {training_args.tpu_num_cores}'''		,						)

				# Essentially, what we want to verify in the distributed case is
				# that we get all samples back, in the right order.
				# (this is crucial for prediction for instance)
				for dataset_length in [1001, 256, 15]:
								lowercase						    =			DummyDataset(__magic_name__	)

								def compute_metrics(__magic_name__	) -> Dict:
												lowercase						    =			list(range(len(__magic_name__	)	)	)
												lowercase						    =			p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential
												return {"success": success}

								lowercase						    =			Trainer(
								    model=DummyModel()		,						args=__magic_name__		,						data_collator=DummyDataCollator()		,						eval_dataset=__magic_name__		,						compute_metrics=__magic_name__		,						)
								lowercase						    =			trainer.evaluate()
								logger.info(__magic_name__	)
								if metrics["eval_success"] is not True:
												logger.error(__magic_name__	)
												exit(1	)

								lowercase						    =			trainer.predict(__magic_name__	)
								logger.info(p.metrics	)
								if p.metrics["test_success"] is not True:
												logger.error(p.metrics	)
												exit(1	)

								lowercase						    =			2

								lowercase						    =			trainer.evaluate()
								logger.info(__magic_name__	)
								if metrics["eval_success"] is not True:
												logger.error(__magic_name__	)
												exit(1	)

								lowercase						    =			trainer.predict(__magic_name__	)
								logger.info(p.metrics	)
								if p.metrics["test_success"] is not True:
												logger.error(p.metrics	)
												exit(1	)

								lowercase						    =			None

				logger.info("🔥 All distributed tests successful"	)

def    __snake_case       (  __magic_name__	):







				'''simple docstring'''


				main()


if __name__ == "__main__":
						main()
