




import json
import logging
import os
import sys
from time import time
from unittest.mock import patch

from transformers.testing_utils import TestCasePlus, require_torch_tpu


logging.basicConfig(level=logging.DEBUG)

lowerCamelCase	:	int				=   logging.getLogger()




def 						SCREAMING_SNAKE_CASE__ (   lowercase					)  ->       List[Any]:
   snake_case				:    Any           =	{}
   snake_case				:    List[str]           =	os.path.join(lowercase						,"""all_results.json"""					)
   if os.path.exists(lowercase					):
      with open(lowercase						,"""r"""					) as f:
         snake_case				:    Tuple           =	json.load(lowercase					)
   else:
      raise ValueError(f"""can't find {path}"""					)
   return results


lowerCamelCase	:	Dict				=   logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)




@require_torch_tpu
class 						__lowercase		(UpperCamelCase__							):




      """simple docstring"""





      def      UpperCAmelCase				(				self     )		->    Tuple:
         import xla_spawn

         snake_case				:    List[str]           =	self.get_auto_remove_tmp_dir()
         snake_case				:    str           =	f"""
            ./examples/pytorch/text-classification/run_glue.py
            --num_cores=8
            ./examples/pytorch/text-classification/run_glue.py
            --model_name_or_path distilbert-base-uncased
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv
            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
            --do_train
            --do_eval
            --debug tpu_metrics_debug
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --learning_rate=1e-4
            --max_steps=10
            --warmup_steps=2
            --seed=42
            --max_seq_length=128
            """.split()

         with patch.object(A    ,				"""argv"""    ,				A     ):
            snake_case				:    Tuple           =	time()
            xla_spawn.main()
            snake_case				:    Dict           =	time()

            snake_case				:    Any           =	get_results(A     )
            self.assertGreaterEqual(result["""eval_accuracy"""]    ,				0.75     )

            # Assert that the script takes less than 500 seconds to make sure it doesn't hang.
            self.assertLess(end - start    ,				5_0_0     )

      def      UpperCAmelCase				(				self     )		->    Optional[int]:
         import xla_spawn

         snake_case				:    List[str]           =	"""
            ./tests/test_trainer_tpu.py
            --num_cores=8
            ./tests/test_trainer_tpu.py
            """.split()
         with patch.object(A    ,				"""argv"""    ,				A     ):
            xla_spawn.main()







def 						SCREAMING_SNAKE_CASE__ (   )  ->       Dict:
   snake_case				:    Optional[int]           =	[]
   snake_case				:    Tuple           =	1

   while len(lowercase					) < 1E6:
      constant.append(str(lowercase					)					)
      i += 1

   snake_case				:    int           =	"""""".join(lowercase					)

   return (
       int(constant[0]					)
       * int(constant[9]					)
       * int(constant[99]					)
       * int(constant[999]					)
       * int(constant[9999]					)
       * int(constant[99999]					)
       * int(constant[999999]					)
   )


if __name__ == "__main__":
       print(solution())





