



from typing import Dict

from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available
from transformers.testing_utils import (
    TestCasePlus,
    execute_subprocess_async,
    get_torch_dist_unique_port,
    require_torch_multi_gpu,
    require_torch_neuroncore,
)
from transformers.training_args import ParallelMode
from transformers.utils import logging


_snake_case		=  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):







													def __init__(   self,			__a = 101):

																				'''simple docstring'''

																				_lowerCAmelCase     :							str    =    length







													def __len__(   self):

																				'''simple docstring'''

																				return self.length







													def __getitem__(   self,			__a):

																				'''simple docstring'''

																				return i



						class   UpperCAmelCase_    :







													def __call__(   self,			__a):

																				'''simple docstring'''

																				return {"input_ids": torch.tensor(__a), "labels": torch.tensor(__a)}



						class   UpperCAmelCase_    (       nn.Module):







													def __init__(   self):

																				'''simple docstring'''

																				super().__init__()
																				# Add some (unused) params otherwise DDP will complain.
																				_lowerCAmelCase     :							str    =    nn.Linear(120,			80)







													def    snake_case__      (   self,			__a,			__a=None):

																				'''simple docstring'''

																				if labels is not None:
																											return torch.tensor(0.0,			device=input_ids.device), input_ids
																				else:
																											return input_ids



class   UpperCAmelCase_    (       a):







							@require_torch_neuroncore
							def    snake_case__      (   self):

														'''simple docstring'''

														_lowerCAmelCase     :							int    =    f"--nproc_per_node=2\n            --master_port={get_torch_dist_unique_port()}\n            {self.test_file_dir}/test_trainer_distributed.py\n        ".split()
														_lowerCAmelCase     :							Tuple    =    self.get_auto_remove_tmp_dir()
														_lowerCAmelCase     :							Optional[int]    =    f"--output_dir {output_dir}".split()
														_lowerCAmelCase     :							List[Any]    =    ["torchrun"] + distributed_args + args
														execute_subprocess_async(__a,			env=self.get_env())
														# successful return here == success - any errors would have caused an error in the sub-call



class   UpperCAmelCase_    (       a):







							@require_torch_multi_gpu
							def    snake_case__      (   self):

														'''simple docstring'''

														_lowerCAmelCase     :							Dict    =    f"--nproc_per_node={torch.cuda.device_count()}\n            --master_port={get_torch_dist_unique_port()}\n            {self.test_file_dir}/test_trainer_distributed.py\n        ".split()
														_lowerCAmelCase     :							Any    =    self.get_auto_remove_tmp_dir()
														_lowerCAmelCase     :							Optional[int]    =    f"--output_dir {output_dir}".split()
														_lowerCAmelCase     :							Any    =    ["torchrun"] + distributed_args + args
														execute_subprocess_async(__a,			env=self.get_env())
														# successful return here == success - any errors would have caused an error in the sub-call


if __name__ == "__main__":
						# The script below is meant to be run under torch.distributed, on a machine with multiple GPUs:
						#
						# PYTHONPATH="src" python -m torch.distributed.run --nproc_per_node 2 --output_dir output_dir ./tests/test_trainer_distributed.py

						_snake_case		=  HfArgumentParser((TrainingArguments,))
						_snake_case		=  parser.parse_args_into_dataclasses()[0]

						logger.warning(
						    f'''Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, '''
						    f'''distributed training: {training_args.parallel_mode != ParallelMode.NOT_DISTRIBUTED}'''
						)

						# 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 [101, 40, 7]:
												_snake_case		=  DummyDataset(dataset_length)






												def 				A				(					_lowerCamelCase  ):





																			'''simple docstring'''




																			_lowerCAmelCase     :							Dict    =    list(range(len(_lowerCamelCase  )  )  )
																			_lowerCAmelCase     :							Union[str, Any]    =    p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential
																			if not success and training_args.local_rank == 0:
																										logger.warning(
																										    "Predictions and/or labels do not match expected results:\n  - predictions: "
																										    F"{p.predictions.tolist()}\n  - labels: {p.label_ids.tolist()}\n  - expected: {sequential}"  )
																			return {"success": success}

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

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

												_snake_case		=  2

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

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



												_snake_case		=  None





import argparse
from collections import defaultdict

import yaml


_snake_case		=  "docs/source/en/_toctree.yml"






def 				A				(					_lowerCamelCase  ):





							'''simple docstring'''




							_lowerCAmelCase     :							Dict    =    defaultdict(_lowerCamelCase  )
							_lowerCAmelCase     :							Any    =    []
							_lowerCAmelCase     :							List[str]    =    []
							for doc in doc_list:
														if "local" in doc:
																					counts[doc["local"]] += 1

														if doc["title"].lower() == "overview":
																					overview_doc.append({"local": doc["local"], "title": doc["title"]}  )
														else:
																					new_doc_list.append(_lowerCamelCase  )

							_lowerCAmelCase     :							Optional[Any]    =    new_doc_list
							_lowerCAmelCase     :							List[Any]    =    [key for key, value in counts.items() if value > 1]

							_lowerCAmelCase     :							str    =    []
							for duplicate_key in duplicates:
														_lowerCAmelCase     :							List[str]    =    list({doc["title"] for doc in doc_list if doc["local"] == duplicate_key}  )
														if len(_lowerCamelCase  ) > 1:
																					raise ValueError(
																					    F"{duplicate_key} is present several times in the documentation table of content at "
																					    "`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the "
																					    "others."  )
														# Only add this once
														new_doc.append({"local": duplicate_key, "title": titles[0]}  )

							# Add none duplicate-keys
							new_doc.extend([doc for doc in doc_list if "local" not in counts or counts[doc["local"]] == 1]  )
							_lowerCAmelCase     :							Optional[Any]    =    sorted(_lowerCamelCase				, key=lambda _lowerCamelCase  : s["title"].lower()  )

							# "overview" gets special treatment and is always first
							if len(_lowerCamelCase  ) > 1:
														raise ValueError("{doc_list} has two 'overview' docs which is not allowed."  )

							overview_doc.extend(_lowerCamelCase  )

							# Sort
							return overview_doc






def 				A				(					_lowerCamelCase=False  ):





							'''simple docstring'''




							with open(_lowerCamelCase				, encoding="utf-8"  ) as f:
														_lowerCAmelCase     :							int    =    yaml.safe_load(f.read()  )

							# Get to the API doc
							_lowerCAmelCase     :							Optional[Any]    =    0
							while content[api_idx]["title"] != "API":
														api_idx += 1
							_lowerCAmelCase     :							List[str]    =    content[api_idx]["sections"]

							# Then to the model doc
							_lowerCAmelCase     :							Union[str, Any]    =    0
							while api_doc[scheduler_idx]["title"] != "Schedulers":
														scheduler_idx += 1

							_lowerCAmelCase     :							Optional[Any]    =    api_doc[scheduler_idx]["sections"]
							_lowerCAmelCase     :							Optional[Any]    =    clean_doc_toc(_lowerCamelCase  )

							_lowerCAmelCase     :							int    =    False
							if new_scheduler_doc != scheduler_doc:
														_lowerCAmelCase     :							List[Any]    =    True
														if overwrite:
																					_lowerCAmelCase     :							Dict    =    new_scheduler_doc

							if diff:
														if overwrite:
																					_lowerCAmelCase     :							Tuple    =    api_doc
																					with open(_lowerCamelCase				, "w"				, encoding="utf-8"  ) as f:
																												f.write(yaml.dump(_lowerCamelCase				, allow_unicode=_lowerCamelCase  )  )
														else:
																					raise ValueError(
																					    "The model doc part of the table of content is not properly sorted, run `make style` to fix this."  )






def 				A				(					_lowerCamelCase=False  ):





							'''simple docstring'''




							with open(_lowerCamelCase				, encoding="utf-8"  ) as f:
														_lowerCAmelCase     :							Tuple    =    yaml.safe_load(f.read()  )

							# Get to the API doc
							_lowerCAmelCase     :							Optional[int]    =    0
							while content[api_idx]["title"] != "API":
														api_idx += 1
							_lowerCAmelCase     :							int    =    content[api_idx]["sections"]

							# Then to the model doc
							_lowerCAmelCase     :							List[str]    =    0
							while api_doc[pipeline_idx]["title"] != "Pipelines":
														pipeline_idx += 1

							_lowerCAmelCase     :							Dict    =    False
							_lowerCAmelCase     :							Optional[int]    =    api_doc[pipeline_idx]["sections"]
							_lowerCAmelCase     :							Tuple    =    []

							# sort sub pipeline docs
							for pipeline_doc in pipeline_docs:
														if "section" in pipeline_doc:
																					_lowerCAmelCase     :							List[Any]    =    pipeline_doc["section"]
																					_lowerCAmelCase     :							Union[str, Any]    =    clean_doc_toc(_lowerCamelCase  )
																					if overwrite:
																												_lowerCAmelCase     :							Optional[Any]    =    new_sub_pipeline_doc
														new_pipeline_docs.append(_lowerCamelCase  )

							# sort overall pipeline doc
							_lowerCAmelCase     :							Union[str, Any]    =    clean_doc_toc(_lowerCamelCase  )

							if new_pipeline_docs != pipeline_docs:
														_lowerCAmelCase     :							Dict    =    True
														if overwrite:
																					_lowerCAmelCase     :							Optional[int]    =    new_pipeline_docs

							if diff:
														if overwrite:
																					_lowerCAmelCase     :							Optional[int]    =    api_doc
																					with open(_lowerCamelCase				, "w"				, encoding="utf-8"  ) as f:
																												f.write(yaml.dump(_lowerCamelCase				, allow_unicode=_lowerCamelCase  )  )
														else:
																					raise ValueError(
																					    "The model doc part of the table of content is not properly sorted, run `make style` to fix this."  )


if __name__ == "__main__":
						_snake_case		=  argparse.ArgumentParser()
						parser.add_argument("--fix_and_overwrite", action="store_true", help="Whether to fix inconsistencies.")
						_snake_case		=  parser.parse_args()

						check_scheduler_doc(args.fix_and_overwrite)
						check_pipeline_doc(args.fix_and_overwrite)
