+
    QV-jxx ã                   óø!  a € ER† Etù0 t ^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RI	t	^ RI
t
^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIHtHt ^ RIHtHtHtHtH t  ^ RIH!t! ^ RI"H#t#H$t$ ^ RIH%t%H&t& ^ RI'H(t( ^ RI)H*t* ^ R	I+H,t,H-t- ^ R
IH.t. ^ RI/H0t0 ^ RI1t1^ RI2H3t3H4t4 ^ RI5H6t6 ^ RI7Ht8 ],'       d   ^RI9H:t: M]-t:^RI;H<t<H=t=H>t>H?t?H@t@HAtAHBtB ^RICHDtD ^RIEHFtFHGtGHHtHHItIHJtJHKtKHLtLHMtMHNtNHOtOHPtPHQtQHRtRHStSHTtTHUtUHVtVHWtWHXtXHYtYHZtZH[t[H\t\H]t]H^t^H_t_H`t`HataHbtbHctcHdtdHeteHftfHgtgHhthHitiHjtjHktkHltlHmtmHntnHotoHptpHqtqHrtrHstsHtttHutuHvtvHwtwHxtxHytyHztzH{t{H|t|H}t}H~t~HtH€t€H�t�H‚t‚HƒtƒH„t„H…t…H†t†H‡t‡HˆtˆH‰t‰HŠtŠH‹t‹HŒtŒH�t�HŽtŽH�t�H�t�H‘t‘H’t’H“t“H”t”H•t•H–t–H—t—H˜t˜H™t™HštšH›t›HœtœH�t�HžtžHŸtŸH t H¡t¡H¢t¢H£t£H¤t¤H¥t¥H¦t¦H§t§H¨t¨H©t©HªtªH«t«H¬t¬H­t­H®t® ]K! 4       '       d   ^ RI¯H°t°H±t± ^ RI²H³t³ ]…! 4       '       d&   ^ RI´HµtµH¶t¶H·t·H¸t¸H¹t¹HºtºH»t» ^ RI¼H½t½ ^ RI¾H¿t¿ ^ RIÀHÁtÁ M]Âtµ]ÂtÁRtÃRtÄRtÅRtÆRtÇRtÈRR R!R"R#R$R%R&R'R(/tÉRR R)R*R+R,R-R./tÊ/ R/^bR0^bR1R2bR3R2bR4R2bR5^cbR6^ bR7^bR8^bR9^bR:^ bR;R<bR=R>bR?^ bR@^bRA^bRB^bRC^ RD^RE^$RFR2RG^RH^RI^/CtË]™! 4       '       dh   ^ RIÌtÌ^ RJIÍHÎtÎ ^RKIÏHÐtÐHÑtÑ ]ÌPl                  EP¤                  RJtÓ]ÌPl                  EP¨                  RJtÕ]Ö! ]ÌPl                  RLR4      RJt×]Ö! ]ÌRMR4      RJtØMRNtÓRNtÕRNt×RNtØ]8EP²                  ! ]Ú4      tÛER‡RO ltÜERˆRP ltÝ]Ü! RQRNRR7      tÞ]Ü! RSR2RR7      tß]Ü! RTRNRR7      tà]Ü! RURNRR7      tá]Ü! RVR2RR7      tâ]Ü! RWRNRR7      tã]Ü! RXR2RR7      tä]Ü! RYR2RR7      tåRZ tæR[ tçR\ tèR] téR^ têR_ tëR` tìRa tíRb tîRc tïRd tðRe tñRf tòRg tóRh tôRi tõRj töRk t÷Rl tøRm tù]F3Rn Ro lltú]I3Rp Rq lltû]G3Rr Rs lltüER‰Rt Ru lltýRv tþRw tÿRx Et Ry EtRz EtR{ EtR| EtR} EtR~ R lEtR€ R� lEtR‚ EtRƒ Et	R„ Et
R… EtR† EtR‡ EtRˆ EtR‰ EtRŠ EtR‹ EtRŒ EtR� EtRŽ EtR� EtR� EtR‘ EtR’ EtR“ EtR” EtR• EtR– EtR— EtR˜ EtR™ Rš lEtR› Et Rœ Et!R� Et"Rž Et#RŸ Et$R  Et%R¡ Et&R¢ Et'R£ Et(R¤ Et)R¥ Et*R¦ Et+R§ Et,R¨ Et-]™! 4       '       Ed²   ^ RIÌtÌR©]EP\                  9   d,   ]EP\                  R©,          Et/ ]EP`                  ! E]/4      Et1R¬]EP\                  9   dñ   ]EP\                  R¬,          Et4E]4R­8X  d1   ]ÌEP¨                  EPk                  4       '       g   E]6! R®E]4 R¯24      hE]4RL8X  d   ]¦! 4       '       g   E]6! R®E]4 R°24      hE]4RM8X  d   ] ! 4       '       g   E]6! R®E]4 R±24      hE]4R²8X  d   ]ž! 4       '       g   E]6! R®E]4 R³24      hE]4R´8X  d   ]�! 4       '       g   E]6! R®E]4 Rµ24      h ]ÌEPn                  ! E]44      Et1Mq]ÌEP¨                  EPk                  4       '       d   R­Et4MK] ! 4       '       d   RMEt4M:]ž! 4       '       d   R²Et4M)]�! 4       '       d   R´Et4M]¦! 4       '       d   RLEt4MR·Et4MREt4R¸ Et9R¹ Et:Rº Et;R» Et<R¼ Et=ERŠR½ R¾ llEt>ER‹R¿ RÀ llEt?ERˆRÁ^/RÂ RÃ lllEt@RÄ EtARÅ EtBRÆ EtCRÇ EtDRÈ EtERÉ EtFRÊ EtGRË EtHRÌ EtIRÍ EtJRÎ EtKRÏ EtLRÐ EtMRÑ EtNRÒ EtORÓ EtPRÔ EtQRÕ EtRRÖ EtSR× EtTRØ EtURÙ EtVRÚ EtWRÛ EtXRÜ EtYRÝ EtZRÞ Et[Rß Et\Rà Et]Rá Et^Râ Et_Rã Et`Rä EtaRå EtbRæ EtcRç EtdRè EteRé EtfRê EtgRë EthRì EtiRí EtjRî EtkRï EtlRð EtmRñ EtnRò EtoRó EtpRô EtqRõ EtrRö EtsR÷ EttRø EtuRù EtvRú EtwRû EtxRü EtyERˆRý lEtzRþ Rÿ lEt{ER  ER lEt|ER Et}ER Et~ER EtER Et€ ! ER ER4      Et� ! ER ER	E]�4      Et‚ ! ER
 ERE]�4      Etƒ ! ER ER4      Et„]PB                  ER 4       Et… ! ER ER4      Et†]PB                  ER ER l4       Et‡ ! ER ER]EP                  4      Et‰ER EtŠ]PB                  ER 4       Et‹/ EtŒER Et�ER EtŽ^ REI�Et� ! ER ER4      Et�ER Et‘ERŒER ER llEt’ER�ER ER llEt“ER  Et”ER! Et•ERŽER" lEt–ER# Et—ER$ Et˜ ! ER% ER&E]™4      EtšER‡ER' ER( llEt› ! ER) ER*4      EtœER�ER+ ER, llEt�ER�ER- ER. llEtžER/ EtŸER‘ER0 lEt ER1 Et¡ ER2 Et¢ ! ER3 ER4]EPF                  4      Et¤ ! ER5 ER6]µ4      Et¥ER7 ER8 lEt¦]™! 4       '       Ed1   R­]ÌEP¨                  EPN                  R·]ÌEPN                  ER9]ÌEPN                  /Et¨R­]ÌEP¨                  EPR                  R·RER9R/EtªR­]ÌEP¨                  EPV                  R·ER: ER9ER; /Et¬R­]ÌEP¨                  EPZ                  R·RER9R/Et®R­]ÌEP¨                  EP^                  R·^ ER9^ /Et°R­]ÌEP¨                  EPb                  R·RER9R/Et²R­]ÌEP¨                  EPf                  R·^ ER9^ /Et´R­]ÌEP¨                  EPj                  R·RER9R/Et¶R­]ÌEP¨                  R·RER9R/Et·M8ER9R/Et¨ER9R/EtªER9ER< /Et¬ER9R/Et®ER9R/Et²ER9^ /Et°ER9^ /Et´ER9R/Et¶ER9R/Et·]�! 4       '       dJ   ]ÌEPp                  EPN                  E]¨R´&   ]ÌEPp                  EPV                  E]¬R´&   ]ÌEPp                  E]·R´&   ]ž! 4       '       df   ]ÌEPr                  EPR                  E]ªR²&   ]ÌEPr                  EPN                  E]¨R²&   ]ÌEPr                  EPV                  E]¬R²&   ]ÌEPr                  E]·R²&   ] ! 4       '       df   ]ÌEPt                  EPR                  E]ªRM&   ]ÌEPt                  EPN                  E]¨RM&   ]ÌEPt                  EPV                  E]¬RM&   ]ÌEPt                  E]·RM&   ]¦! 4       '       dò   ]ÌEPv                  EPR                  E]ªRL&   ]ÌEPv                  EPN                  E]¨RL&   ]ÌEPv                  EPV                  E]¬RL&   ]ÌEPv                  EPb                  E]®RL&   ]ÌEPv                  EPb                  E]²RL&   ]ÌEPv                  EP^                  E]°RL&   ]ÌEPv                  EPf                  E]´RL&   ]ÌEPv                  EPj                  E]¶RL&   ]ÌEPv                  E]·RL&   ]¥! 4       '       dX   ]ÌEP¨                  EPR                  E]ªER=&   ]ÌEP¨                  EPN                  E]¨ER=&   ]ÌEP¨                  EPV                  E]¬ER=&   ER> ER? lEt¼ER@ ERA lEt½ERB ERC lEt¾ERD ERE lEt¿ERF ERG lEtÀERH ERI lEtÁERJ ERK lEtÂERL ERM lEtÃERN ERO lEtÄ]™! 4       '       Edc   ERP]EP\                  9   EdO   ]EP\                  ERP,          EtÅ]*! E]Å4      EP�                  4       '       g   E]6! ERQE]Å 24      h]EPŽ                  EP‘                  ]EPŽ                  EP“                  E]Å4      4      w  EtÊEt1]EPŽ                  EP—                  E]Ê4        E]ÅRE]ÅEP™                  ERR4       EtÍ]EP`                  ! E]Í4      EtÎ E]ÎEPž                  EtÐR¬]EP\                  9   d/   E]4E]Ð8w  d&   ERUE]4 ERVE]Ð ERW2EtÒE]ÒERX,          EtÒE]6! E]Ò4      hE]ÐEt4ERY ERZ lEtÓE]Ó! E]¨ER[4       E]Ó! E]ªER\4       E]Ó! E]¬ER]4       ER^ EtÔE]ER‡ER_ ER` ll4       EtÕE]ÖE]×R,          E]ØR,          E]ØR,          3,          EtÙE]ÖE]×R,          RE]Ø,          E]ÖE]ØE]Ø3,          ,          3,          EtÚ]%ERa ERb l4       EtÛERˆERc ERd llEtÜ ! ERe ERf]E]Ú]-3,          4      EtÝERg EtÞERh EtßERi EtàERj EtáERk EtâERl EtãERm EtäERn EtåER’ERo ERp llEtæER“ERq lEtçERr EtèER”ERs lEtéERt EtêERu Etë ! ERv ERw4      Etì ! ERx ERy]EPÚ                  4      EtîE]ï! 4       Etð] ^ k ERz ER{ lEtñER| ER} lEtò]EPæ                  ! ER~. ER•O4      Etô ! ER ER€4      EtõERˆER� ER‚ llEtöERƒ ER„ lEt÷]!ER… 4       EtøR#   E]2 d   Et3E]2! RªE]/ R«E]3 24      E]3hREt3EA3ii ; i  E]8 d   Et3E]8! R¶E]4 24      E]3hREt3EA3ii ; i  E]6 d   Et3E]6! ERSE]Å 24      E]3hREt3EA3ii ; i  E]Ñ d   Et3E]Ñ! ERT4      E]3hREt3EA3ii ; i(–  é    N)ÚUserDictÚdefaultdict)ÚCallableÚ	GeneratorÚIterableÚIteratorÚMapping)Úcontextmanager)ÚMISSINGÚfields)ÚcacheÚwraps)ÚStringIO)ÚPath)ÚTYPE_CHECKINGÚAny)Úmock)Úpatch)Úcreate_repoÚdelete_repo)Úversion)Úlogging)ÚTrainer)Úis_clearml_availableÚis_optuna_availableÚis_ray_availableÚis_swanlab_availableÚis_tensorboard_availableÚis_trackio_availableÚis_wandb_available)Úis_deepspeed_available)iÚACCELERATE_MIN_VERSIONÚGGUF_MIN_VERSIONÚSAFE_WEIGHTS_INDEX_NAMEÚTRITON_MIN_VERSIONÚWEIGHTS_INDEX_NAMEÚis_accelerate_availableÚis_apex_availableÚis_apollo_torch_availableÚis_aqlm_availableÚis_auto_round_availableÚis_av_availableÚis_bitsandbytes_availableÚis_bs4_availableÚis_causal_conv1d_availableÚis_compressed_tensors_availableÚis_cv2_availableÚis_cython_availableÚis_decord_availableÚis_detectron2_availableÚis_essentia_availableÚis_faiss_availableÚis_fbgemm_gpu_availableÚis_flash_attn_2_availableÚis_flash_attn_3_availableÚis_flash_attn_4_availableÚ#is_flash_linear_attention_availableÚis_flute_availableÚis_fouroversix_availableÚis_fp_quant_availableÚis_fsdp_availableÚis_g2p_en_availableÚis_galore_torch_availableÚis_gguf_availableÚis_gptqmodel_availableÚis_grokadamw_availableÚis_hadamard_availableÚis_hqq_availableÚ#is_huggingface_hub_greater_or_equalÚis_ipython_availableÚis_jinja_availableÚis_jmespath_availableÚis_jumanpp_availableÚis_kernels_availableÚis_levenshtein_availableÚis_librosa_availableÚis_liger_kernel_availableÚis_lomo_availableÚis_mistral_common_availableÚis_multipart_availableÚis_natten_availableÚis_nltk_availableÚis_numba_availableÚis_onnx_availableÚis_openai_availableÚis_optimum_availableÚis_optimum_quanto_availableÚis_pandas_availableÚis_peft_availableÚis_phonemizer_availableÚis_pretty_midi_availableÚis_psutil_availableÚis_pyctcdecode_availableÚis_pytesseract_availableÚis_pytest_availableÚis_pytest_order_availableÚ!is_pytorch_quantization_availableÚis_quark_availableÚis_qutlass_availableÚis_rjieba_availableÚis_sacremoses_availableÚis_schedulefree_availableÚis_scipy_availableÚis_sentencepiece_availableÚis_seqio_availableÚis_serve_availableÚis_spacy_availableÚis_speech_availableÚis_spqr_availableÚis_sudachi_availableÚis_sudachi_projection_availableÚis_tiktoken_availableÚis_timm_availableÚis_tokenizers_availableÚis_torch_availableÚ!is_torch_bf16_available_on_deviceÚ!is_torch_fp16_available_on_deviceÚis_torch_greater_or_equalÚis_torch_hpu_availableÚis_torch_mlu_availableÚis_torch_neuroncore_availableÚis_torch_npu_availableÚis_torch_optimi_availableÚis_torch_tensorrt_fx_availableÚis_torch_tf32_availableÚis_torch_tpu_availableÚis_torch_xla_availableÚis_torch_xpu_availableÚis_torchao_availableÚis_torchaudio_availableÚis_torchcodec_availableÚis_torchvision_availableÚis_triton_availableÚis_vision_availableÚis_vptq_availableÚ	strtobool)ÚAcceleratorStateÚPartialState)Úis_fp8_available)ÚModuleÚ_get_checkerÚ_get_continue_on_failureÚ_get_runnerÚ
_is_mockedÚ_patch_unwrap_mock_awareÚget_optionflags)Úskip)Úimport_path)ÚDoctestItemzjulien-c/bert-xsmall-dummyzjulien-c/dummy-unknownzjulien-c/dummy-diff-tokenizerÚ__DUMMY_TRANSFORMERS_USER__zhttps://hub-ci.huggingface.coÚ%hf_94wBhPGp6KrrTH3KDchhKpRxZwd6dmHWLLÚconfig_classÚConfigÚcausal_lm_classÚForCausalLMÚquestion_answering_classÚForQuestionAnsweringÚsequence_classification_classÚForSequenceClassificationÚtoken_classification_classÚForTokenClassificationÚtext_config_classÚ
TextConfigÚvision_config_classÚVisionConfigÚconditional_generation_classÚForConditionalGenerationÚ
batch_sizeÚ
seq_lengthÚis_trainingTÚuse_input_maskÚ
use_labelsÚ
vocab_sizeÚhidden_sizeÚnum_hidden_layersÚnum_attention_headsÚnum_key_value_headsÚintermediate_sizeÚ
hidden_actÚgeluÚmax_position_embeddingsi   Úpad_token_idÚbos_token_idÚeos_token_idÚexpert_intervalÚmoe_layer_start_indexÚmoe_intermediate_sizeÚshared_expert_intermediate_sizeÚshared_expert_gateÚmoe_num_shared_expertsÚnum_experts_per_tokÚnum_experts)Ú	load_file)ÚFLASH_ATTN_KERNEL_FALLBACKÚPreTrainedModelÚxpuÚnpuFc                 ó²   €  \         P                  V ,          p \        V4      pV#   \         d    \        R T  R24      hi ; i  \         d    Tp T# i ; i)úIf set, z must be yes or no.)ÚosÚenvironrŠ   Ú
ValueErrorÚKeyError©ÚkeyÚdefaultÚvalueÚ_values   &&  Úk/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/lib/python3.14/site-packages/transformers/testing_utils.pyÚparse_flag_from_envrÔ     sp   € ðBÜ—
‘
˜3•ˆð	BÜ˜uÓ%ˆFð €Møô ô 	Bä˜x¨ uÐ,?Ð@ÓAÐAð	Bûô ô à‰ð €Mðúó   ‚A š' §AÁAÁAc                 ó²   €  \         P                  V ,          p \        V4      pV#   \         d    \        R T  R24      hi ; i  \         d    Tp T# i ; i)rÉ   z must be a int.)rÊ   rË   ÚintrÌ   rÍ   rÎ   s   &&  rÓ   Úparse_int_from_envrØ   *  sj   € ð>Ü—
‘
˜3•ˆð	>Ü˜“ZˆFð €Møô ô 	>Ü˜x¨ u¨OÐ<Ó=Ð=ð	>ûô ô Ø‰ð €MðúrÕ   ÚRUN_SLOW©rÐ   Ú	RUN_FLAKYÚRUN_CUSTOM_TOKENIZERSÚHUGGINGFACE_CO_STAGINGÚRUN_PIPELINE_TESTSÚRUN_AGENT_TESTSÚRUN_TRAINING_TESTSÚRUN_TENSOR_PARALLEL_TESTSc                óÄ   € \         '       g   \        P                  ! RR7      ! V 4      #  ^ RIpVP                  P                  4       ! V 4      #   \         d    T u # i ; i)z’
Decorator marking a test as a staging test.

Those tests will run using the staging environment of huggingface.co instead of the real model hub.
ztest is staging test©ÚreasonN)Ú_run_stagingÚunittestr•   ÚpytestÚmarkÚis_staging_testÚImportError©Ú	test_caserç   s   & rÓ   ré   ré   A  sW   € ÷ ‹<Ü�}Š}Ð$:Õ;¸IÓFÐFð	<Ûð —;‘;×.Ñ.Ô0°Ó;Ð;øô ô 	ØÒð	úó   «A ÁAÁAc                óÄ   € \         '       g   \        P                  ! RR7      ! V 4      #  ^ RIpVP                  P                  4       ! V 4      #   \         d    T u # i ; i)zz
Decorator marking a test as a pipeline test. If RUN_PIPELINE_TESTS is set to a falsy value, those tests will be
skipped.
ztest is pipeline testrã   N)Ú_run_pipeline_testsræ   r•   rç   rè   Úis_pipeline_testrê   rë   s   & rÓ   rð   rð   R  óX   € ÷
 ÓÜ�}Š}Ð$;Õ<¸YÓGÐGð	=Ûð —;‘;×/Ñ/Ô1°)Ó<Ð<øô ô 	ØÒð	úrí   c                óÄ   € \         '       g   \        P                  ! RR7      ! V 4      #  ^ RIpVP                  P                  4       ! V 4      #   \         d    T u # i ; i)zt
Decorator marking a test as an agent test. If RUN_TOOL_TESTS is set to a falsy value, those tests will be skipped.
ztest is an agent testrã   N)Ú_run_agent_testsræ   r•   rç   rè   Úis_agent_testrê   rë   s   & rÓ   rô   rô   b  sX   € ÷ ÓÜ�}Š}Ð$;Õ<¸YÓGÐGð	:Ûð —;‘;×,Ñ,Ô.¨yÓ9Ð9øô ô 	ØÒð	úrí   c                óÄ   € \         '       g   \        P                  ! RR7      ! V 4      #  ^ RIpVP                  P                  4       ! V 4      #   \         d    T u # i ; i)zz
Decorator marking a test as a training test. If RUN_TRAINING_TESTS is set to a falsy value, those tests will be
skipped.
ztest is training testrã   N)Ú_run_training_testsræ   r•   rç   rè   Úis_training_testrê   rë   s   & rÓ   r÷   r÷   q  rñ   rí   c                óÄ   € \         '       g   \        P                  ! RR7      ! V 4      #  ^ RIpVP                  P                  4       ! V 4      #   \         d    T u # i ; i)zˆ
Decorator marking a test as a tensor parallel test. If RUN_TENSOR_PARALLEL_TESTS is set to a falsy value, those
tests will be skipped.
ztest is tensor parallel testrã   N)Ú_run_tensor_parallel_testsræ   r•   rç   rè   Úis_tensor_parallel_testrê   rë   s   & rÓ   rú   rú   �  sY   € ÷
 &Ó%Ü�}Š}Ð$BÕCÀIÓNÐNð	DÛð —;‘;×6Ñ6Ô8¸ÓCÐCøô ô 	ØÒð	úrí   c                óD   € \         P                  ! \        R4      ! V 4      # )z�
Decorator marking a test as slow.

Slow tests are skipped by default. Set the RUN_SLOW environment variable to a truthy value to run them.

ztest is slow)ræ   Ú
skipUnlessÚ_run_slow_tests©rì   s   &rÓ   Úslowrÿ   ‘  s   € ô ×Òœ°Ô?À	ÓJÐJó    c                ó<   € \         P                  ! RR7      ! V 4      # )z¼
Decorator marking a test as too slow.

Slow tests are skipped while they're in the process of being fixed. No test should stay tagged as "tooslow" as
these will not be tested by the CI.

ztest is too slowrã   )ræ   r•   rþ   s   &rÓ   Útooslowr  ›  s   € ô �=Š=Ð 2Õ3°IÓ>Ð>r   c                 óF   a € \         P                  ! S 4      V 3R  l4       pV# )c                  ón   <€  S! V / VB #   \          d   p\        P                  ! R T 24      hRp?ii ; i)z)Test skipped due to NotImplementedError: N)ÚNotImplementedErrorræ   ÚSkipTest)ÚargsÚkwargsÚeÚ	test_funcs   *, €rÓ   ÚwrapperÚ(skip_if_not_implemented.<locals>.wrapper§  sE   ø€ ð	UÙ˜dÐ- fÑ-Ð-øÜ"ô 	UÜ×#Ò#Ð&OÐPQÈsÐ$SÓTÐTûð	Uús   ƒ ‹4–/¯4)Ú	functoolsr   )r
  r  s   f rÓ   Úskip_if_not_implementedr  ¦  s'   ø€ Ü‡_‚_�YÓôUó  ðUð €Nr   c                óÂ   € \        V 4       FO  pVP                  R4      '       g   K  \        W4      p\        V4      '       g   K:  \	        W\        V4      4       KQ  	  V # )zH
Class decorator to apply @skip_if_not_implemented to all test methods.
Útest_)ÚdirÚ
startswithÚgetattrÚcallableÚsetattrr  )ÚclsÚ	attr_nameÚattrs   &  rÓ   Úapply_skip_if_not_implementedr  ±  sM   € ô ˜–Xˆ	Ø×Ñ ×(Ô(Ü˜3Ó*ˆDÜ˜�~Œ~Ü˜Ô(?ÀÓ(EÖFñ	 ð
 €Jr   c                óD   € \         P                  ! \        R4      ! V 4      # )zÔ
Decorator marking a test for a custom tokenizer.

Custom tokenizers require additional dependencies, and are skipped by default. Set the RUN_CUSTOM_TOKENIZERS
environment variable to a truthy value to run them.
ztest of custom tokenizers)ræ   rü   Ú_run_custom_tokenizersrþ   s   &rÓ   Úcustom_tokenizersr  ½  s   € ô ×ÒÔ5Ð7RÔSÐT]Ó^Ð^r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zu
Decorator marking a test that requires BeautifulSoup4. These tests are skipped when BeautifulSoup4 isn't installed.
ztest requires BeautifulSoup4)ræ   rü   r.   rþ   s   &rÓ   Úrequire_bs4r  Ç  s"   € ô ×ÒÔ/Ó1Ð3QÔRÐS\Ó]Ð]r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z‹
Decorator marking a test that requires GaLore. These tests are skipped when GaLore isn't installed.
https://github.com/jiaweizzhao/GaLore
ztest requires GaLore)ræ   rü   rA   rþ   s   &rÓ   Úrequire_galore_torchr   Î  ó"   € ô
 ×ÒÔ8Ó:Ð<RÔSÐT]Ó^Ð^r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zŠ
Decorator marking a test that requires GaLore. These tests are skipped when APOLLO isn't installed.
https://github.com/zhuhanqing/APOLLO
ztest requires APOLLO)ræ   rü   r)   rþ   s   &rÓ   Úrequire_apollo_torchr#  Ö  r!  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z–
Decorator marking a test that requires torch-optimi. These tests are skipped when torch-optimi isn't installed.
https://github.com/jxnl/torch-optimi
ztest requires torch-optimi)ræ   rü   r}   rþ   s   &rÓ   Úrequire_torch_optimir%  Þ  ó"   € ô
 ×ÒÔ8Ó:Ð<XÔYÐZcÓdÐdr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z‰
Decorator marking a test that requires LOMO. These tests are skipped when LOMO-optim isn't installed.
https://github.com/OpenLMLab/LOMO
ztest requires LOMO)ræ   rü   rP   rþ   s   &rÓ   Úrequire_lomor(  æ  s!   € ô
 ×ÒÔ0Ó2Ð4HÔIÈ)ÓTÐTr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zk
Decorator marking a test that requires GrokAdamW. These tests are skipped when GrokAdamW isn't installed.
ztest requires GrokAdamW)ræ   rü   rD   rþ   s   &rÓ   Úrequire_grokadamwr*  î  ó"   € ô ×ÒÔ5Ó7Ð9RÔSÐT]Ó^Ð^r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z£
Decorator marking a test that requires schedulefree. These tests are skipped when schedulefree isn't installed.
https://github.com/facebookresearch/schedule_free
ztest requires schedulefree)ræ   rü   rh   rþ   s   &rÓ   Úrequire_schedulefreer-  õ  r&  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zg
Decorator marking a test that requires OpenCV.

These tests are skipped when OpenCV isn't installed.

ztest requires OpenCV)ræ   rü   r1   rþ   s   &rÓ   Úrequire_cv2r/  ý  s!   € ô ×ÒÔ/Ó1Ð3IÔJÈ9ÓUÐUr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zq
Decorator marking a test that requires Levenshtein.

These tests are skipped when Levenshtein isn't installed.

ztest requires Levenshtein)ræ   rü   rM   rþ   s   &rÓ   Úrequire_levenshteinr1    ó"   € ô ×ÒÔ7Ó9Ð;VÔWÐXaÓbÐbr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zc
Decorator marking a test that requires NLTK.

These tests are skipped when NLTK isn't installed.

ztest requires NLTK)ræ   rü   rT   rþ   s   &rÓ   Úrequire_nltkr4    ó!   € ô ×ÒÔ0Ó2Ð4HÔIÈ)ÓTÐTr   c                ó$   € V ^8„  d   QhR\         /# ©é   Úmin_version©Ústr)Úformats   "rÓ   Ú__annotate__r=    s   € ÷ ñ ¬sñ r   c                óT   € \         P                  ! \        V4      RV 24      ! V 4      # )zm
Decorator marking a test that requires accelerate. These tests are skipped when accelerate isn't installed.
z$test requires accelerate version >= )ræ   rü   r'   ©rì   r9  s   &&rÓ   Úrequire_accelerater@    s3   € ô ×ÒÜ Ó,Ð0TÐU`ÐTaÐ.bôàóð r   c                ó$   € V ^8„  d   QhR\         /# r7  r:  )r<  s   "rÓ   r=  r=  $  s   € ÷ 
ñ 
¤ñ 
r   c                ó   a € V 3R lpV# )ze
Decorator marking a test that requires triton. These tests are skipped when triton isn't installed.
c                 óV   <€ \         P                  ! \        S4      R S 24      ! V 4      # )z test requires triton version >= )ræ   rü   r‡   r?  s   &€rÓ   Ú	decoratorÚ!require_triton.<locals>.decorator)  s0   ø€ Ü×"Ò"Ô#6°{Ó#CÐGgÐhsÐgtÐEuÔvØó
ð 	
r   © )r9  rD  s   f rÓ   Úrequire_tritonrG  $  s   ø€ õ

ð
 Ðr   c                ó$   € V ^8„  d   QhR\         /# r7  r:  )r<  s   "rÓ   r=  r=  1  ó   € ÷ ñ ¬ñ r   c                óT   € \         P                  ! \        V4      RV 24      ! V 4      # )zb
Decorator marking a test that requires ggguf. These tests are skipped when gguf isn't installed.
ztest requires gguf version >= )ræ   rü   rB   r?  s   &&rÓ   Úrequire_ggufrK  1  s1   € ô ×ÒÔ0°Ó=ÐA_Ð`kÐ_lÐ?mÔnØóð r   c                ó$   € V ^8„  d   QhR\         /# r7  r:  )r<  s   "rÓ   r=  r=  :  rI  r   c                óT   € \         P                  ! \        V4      RV 24      ! V 4      # )za
Decorator marking a test that requires fsdp. These tests are skipped when fsdp isn't installed.
ztest requires torch version >= )ræ   rü   r?   r?  s   &&rÓ   Úrequire_fsdprN  :  s1   € ô ×ÒÔ0°Ó=ÐA`ÐalÐ`mÐ?nÔoØóð r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zl
Decorator marking a test that requires g2p_en. These tests are skipped when SentencePiece isn't installed.
ztest requires g2p_en)ræ   rü   r@   rþ   s   &rÓ   Úrequire_g2p_enrP  C  ó!   € ô ×ÒÔ2Ó4Ð6LÔMÈiÓXÐXr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )ze
Decorator marking a test that requires rjieba. These tests are skipped when rjieba isn't installed.
ztest requires rjieba)ræ   rü   rf   rþ   s   &rÓ   Úrequire_rjiebarS  J  rQ  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zc
Decorator marking a test that requires jinja. These tests are skipped when jinja isn't installed.
ztest requires jinja)ræ   rü   rI   rþ   s   &rÓ   Úrequire_jinjarU  Q  ó!   € ô ×ÒÔ1Ó3Ð5JÔKÈIÓVÐVr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zi
Decorator marking a test that requires jmespath. These tests are skipped when jmespath isn't installed.
ztest requires jmespath)ræ   rü   rJ   rþ   s   &rÓ   Úrequire_jmespathrX  X  ó"   € ô ×ÒÔ4Ó6Ð8PÔQÐR[Ó\Ð\r   c                 óL   € \         P                  ! \        4       R 4      ! V 4      # )ztest requires ONNX)ræ   rü   rV   rþ   s   &rÓ   Úrequire_onnxr[  _  s   € Ü×ÒÔ0Ó2Ð4HÔIÈ)ÓTÐTr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zc
Decorator marking a test that requires Timm.

These tests are skipped when Timm isn't installed.

ztest requires Timm)ræ   rü   rs   rþ   s   &rÓ   Úrequire_timmr]  c  r5  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zg
Decorator marking a test that requires NATTEN.

These tests are skipped when NATTEN isn't installed.

ztest requires natten)ræ   rü   rS   rþ   s   &rÓ   Úrequire_nattenr_  m  ó!   € ô ×ÒÔ2Ó4Ð6LÔMÈiÓXÐXr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zi
Decorator marking a test that requires PyTorch.

These tests are skipped when PyTorch isn't installed.

útest requires PyTorch)ræ   rü   ru   rþ   s   &rÓ   Úrequire_torchrc  w  s!   € ô ×ÒÔ1Ó3Ð5LÔMÈiÓXÐXr   c                ó$   € V ^8„  d   QhR\         /# ©r8  r   r:  )r<  s   "rÓ   r=  r=  �  s   € ÷ ñ ¬Cñ r   c                ó   a € V 3R lpV# )zŒ
Decorator marking a test that requires PyTorch version >= `version`.

These tests are skipped when PyTorch version is less than `version`.
c                 óV   <€ \         P                  ! \        S4      R S 24      ! V 4      # )z!test requires PyTorch version >= )ræ   rü   rx   ©rì   r   s   &€rÓ   rD  Ú1require_torch_greater_or_equal.<locals>.decoratorˆ  s0   ø€ Ü×"Ò"Ô#<¸WÓ#EÐIjÐkrÐjsÐGtÔuØó
ð 	
r   rF  ©r   rD  s   f rÓ   Úrequire_torch_greater_or_equalrk  �  s   ø€ õ
ð
 Ðr   c                ó$   € V ^8„  d   QhR\         /# re  r:  )r<  s   "rÓ   r=  r=  �  s   € ÷ ñ ´cñ r   c                ó   a € V 3R lpV# )zœ
Decorator marking a test that requires huggingface_hub version >= `version`.

These tests are skipped when huggingface_hub version is less than `version`.
c                 óV   <€ \         P                  ! \        S4      R S 24      ! V 4      # )z)test requires huggingface_hub version >= )ræ   rü   rG   rh  s   &€rÓ   rD  Ú;require_huggingface_hub_greater_or_equal.<locals>.decorator—  s2   ø€ Ü×"Ò"Ü/°Ó8Ð<eÐfmÐenÐ:oô
à
óð 	r   rF  rj  s   f rÓ   Ú(require_huggingface_hub_greater_or_equalrp  �  s   ø€ õð
 Ðr   c                óØ   € \        4       p\        4       p ^ RIHp V! \        R,          4       \        P                  ! W!,          R4      ! V 4      #   \
         d   pRp Rp?L5Rp?ii ; i)zy
Decorator marking a test that requires Flash Attention.

These tests are skipped when Flash Attention isn't installed.

©Ú
get_kernelÚflash_attention_2FNztest requires Flash Attention)r8   rL   Úkernelsrs  rÄ   Ú	Exceptionræ   rü   ©rì   Úflash_attn_availableÚkernels_availablers  Ú_s   &    rÓ   Úrequire_flash_attnr{  Ÿ  se   € ô 5Ó6ÐÜ,Ó.Ðð"Ý&áÔ-Ð.AÕBÔCô ×ÒÐ0ÕGÐIhÔiÐjsÓtÐtøô ô "Ø!Õûð"ús   –A ÁA)ÁA$Á$A)c                óL   € \         P                  ! \        4       R4      ! V 4      # )z�
Decorator marking a test that requires the kernels library.

These tests are skipped when the kernels library isn't installed.

z!test requires the kernels library)ræ   rü   rL   rþ   s   &rÓ   Úrequire_kernelsr}  ²  s"   € ô ×ÒÔ3Ó5Ð7ZÔ[Ð\eÓfÐfr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z|
Decorator marking a test that requires Flash Attention 3.

These tests are skipped when Flash Attention 3 isn't installed.
ztest requires Flash Attention 3)ræ   rü   r9   rþ   s   &rÓ   Úrequire_flash_attn_3r  ¼  ó"   € ô ×ÒÔ8Ó:Ð<]Ô^Ð_hÓiÐir   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z|
Decorator marking a test that requires Flash Attention 4.

These tests are skipped when Flash Attention 4 isn't installed.
ztest requires Flash Attention 4)ræ   rü   r:   rþ   s   &rÓ   Úrequire_flash_attn_4r‚  Å  r€  r   c                 ó  € \        4       p\        4       p ^ RIHp V! \        R,          4       \        P                  ! \        W,          \        4       \        4       34      R4      ! V 4      #   \
         d   pRp Rp?LQRp?ii ; i)r   rr  rt  FNz3test requires all mainline Flash Attention packages)r8   rL   ru  rs  rÄ   rv  ræ   rü   Úallr9   r:   rw  s   &    rÓ   Úrequire_all_flash_attnr…  Î  s†   € Ü4Ó6ÐÜ,Ó.Ðð"Ý&áÔ-Ð.AÕBÔCô ×ÒÜà$Õ8Ü)Ó+Ü)Ó+ðó	
ð 	>ô	ð ó	ð 	øô ô "Ø!Õûð"ús   –A. Á.BÁ9B Â Bc                óL   € \         P                  ! \        4       R4      ! V 4      # )z†
Decorator marking a test that requires Flash Linear Attention.

These tests are skipped when Flash Linear Attention isn't installed.
z&test requires `flash-linear-attention`)ræ   rü   r;   rþ   s   &rÓ   Úrequire_flash_linear_attentionr‡  ä  s*   € ô ×ÒÜ+Ó-Ø0ôð óð r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zt
Decorator marking a test that requires causal-conv1d.

These tests are skipped when causal-conv1d isn't installed.
ztest requires `causal-conv1d`)ræ   rü   r/   rþ   s   &rÓ   Úrequire_causal_conv1dr‰  ñ  s*   € ô ×ÒÜ"Ó$Ø'ôð óð r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zc
Decorator marking a test that requires PEFT.

These tests are skipped when PEFT isn't installed.

ztest requires PEFT)ræ   rü   r[   rþ   s   &rÓ   Úrequire_peftr‹  þ  r5  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zq
Decorator marking a test that requires Torchvision.

These tests are skipped when Torchvision isn't installed.

ztest requires Torchvision)ræ   rü   r†   rþ   s   &rÓ   Úrequire_torchvisionr�    r2  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zo
Decorator marking a test that requires Torchcodec.

These tests are skipped when Torchcodec isn't installed.

ztest requires Torchcodec)ræ   rü   r…   rþ   s   &rÓ   Úrequire_torchcodecr�    s"   € ô ×ÒÔ6Ó8Ð:TÔUÐV_Ó`Ð`r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zm
Decorator marking a test that requires torchaudio. These tests are skipped when torchaudio isn't installed.
útest requires torchaudio)ræ   rü   r„   rþ   s   &rÓ   Úrequire_torchaudior’    ó"   € ô ×ÒÔ6Ó8Ð:TÔUÐV_Ó`Ð`r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )ús
Decorator marking a test that requires SentencePiece. These tests are skipped when SentencePiece isn't installed.
ztest requires SentencePiece)ræ   rü   rj   rþ   s   &rÓ   Úrequire_sentencepiecer–  #  s"   € ô ×ÒÔ9Ó;Ð=ZÔ[Ð\eÓfÐfr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zm
Decorator marking a test that requires Sacremoses. These tests are skipped when Sacremoses isn't installed.
ztest requires Sacremoses)ræ   rü   rg   rþ   s   &rÓ   Úrequire_sacremosesr˜  *  r“  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )r•  ztest requires Seqio)ræ   rü   rk   rþ   s   &rÓ   Úrequire_seqiorš  1  rV  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zk
Decorator marking a test that requires Scipy. These tests are skipped when SentencePiece isn't installed.
ztest requires Scipy)ræ   rü   ri   rþ   s   &rÓ   Úrequire_scipyrœ  8  rV  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )uw   
Decorator marking a test that requires ðŸ¤— Tokenizers. These tests are skipped when ðŸ¤— Tokenizers isn't installed.
ztest requires tokenizers)ræ   rü   rt   rþ   s   &rÓ   Úrequire_tokenizersrž  ?  r“  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )ze
Decorator marking a test that requires pandas. These tests are skipped when pandas isn't installed.
ztest requires pandas)ræ   rü   rZ   rþ   s   &rÓ   Úrequire_pandasr   F  rQ  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zo
Decorator marking a test that requires PyTesseract. These tests are skipped when PyTesseract isn't installed.
ztest requires PyTesseract)ræ   rü   r`   rþ   s   &rÓ   Úrequire_pytesseractr¢  M  ó"   € ô ×ÒÔ7Ó9Ð;VÔWÐXaÓbÐbr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z‘
Decorator marking a test that requires PyTorch Quantization Toolkit. These tests are skipped when PyTorch
Quantization Toolkit isn't installed.
z*test requires PyTorch Quantization Toolkit)ræ   rü   rc   rþ   s   &rÓ   Úrequire_pytorch_quantizationr¥  T  s&   € ô
 ×ÒÔ@ÓBÐDpÔqØóð r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zz
Decorator marking a test that requires the vision dependencies. These tests are skipped when torchaudio isn't
installed.
ztest requires vision)ræ   rü   rˆ   rþ   s   &rÓ   Úrequire_visionr§  ^  s!   € ô
 ×ÒÔ2Ó4Ð6LÔMÈiÓXÐXr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zc
Decorator marking a test that requires SpaCy. These tests are skipped when SpaCy isn't installed.
ztest requires spacy)ræ   rü   rm   rþ   s   &rÓ   Úrequire_spacyr©  f  rV  r   c                óÔ   € \        4       '       g   \        P                  ! RR7      ! V 4      # ^ RIp\        P                  ! VP
                  P                  4       ^8„  R4      ! V 4      # )a  
Decorator marking a test that requires a multi-GPU CUDA setup (in PyTorch). These tests are skipped on a machine without
multiple CUDA GPUs.

To run *only* the multi_gpu tests, assuming all test names contain multi_gpu: $ pytest -sv ./tests -k "multi_gpu"
rb  rã   Nz test requires multiple CUDA GPUs©ru   ræ   r•   Útorchrü   ÚcudaÚdevice_count©rì   r¬  s   & rÓ   Úrequire_torch_multi_gpur°  m  sQ   € ô ×ÒÜ�}Š}Ð$;Õ<¸YÓGÐGãä×Ò˜uŸz™z×6Ñ6Ó8¸1Ñ<Ð>`ÔaÐbkÓlÐlr   c                ó¶   € \        4       '       g   \        P                  ! RR7      ! V 4      # \        P                  ! \	        \
        4      ^8„  R4      ! V 4      # )a  
Decorator marking a test that requires a multi-accelerator (in PyTorch). These tests are skipped on a machine
without multiple accelerators. To run *only* the multi_accelerator tests, assuming all test names contain
multi_accelerator: $ pytest -sv ./tests -k "multi_accelerator"
rb  rã   z#test requires multiple accelerators©ru   ræ   r•   rü   Úbackend_device_countÚtorch_devicerþ   s   &rÓ   Úrequire_torch_multi_acceleratorrµ  |  sK   € ô ×ÒÜ�}Š}Ð$;Õ<¸YÓGÐGä×ÒÔ3´LÓAÀAÑEÐGlÔmØóð r   c                ó$   € V ^8„  d   QhR\         /# )r8  Ún©r×   )r<  s   "rÓ   r=  r=  Š  s   € ÷ 
ñ 
¤Cñ 
r   c                ó   a € V 3R lpV# )zNDecorator marking a test that requires at least `n` accelerators (in PyTorch).c                 óÀ   <€ \        4       '       g   \        P                  ! R R7      ! V 4      # \        P                  ! \	        \
        4      S8¬  RS R24      ! V 4      # )rb  rã   ztest requires >= z acceleratorsr²  )rì   r·  s   &€rÓ   rD  Ú/require_torch_n_accelerators.<locals>.decorator�  sV   ø€ Ü!×#Ò#Ü—=’=Ð(?Õ@ÀÓKÐKÜ×"Ò"Ô#7¼Ó#EÈÑ#JÐN_Ð`aÐ_bÐboÐLpÔqØó
ð 	
r   rF  )r·  rD  s   f rÓ   Úrequire_torch_n_acceleratorsr¼  Š  s   ø€ õ
ð Ðr   c                óÔ   € \        4       '       g   \        P                  ! RR7      ! V 4      # ^ RIp\        P                  ! VP
                  P                  4       ^8  R4      ! V 4      # )zG
Decorator marking a test that requires 0 or 1 GPU setup (in PyTorch).
rb  rã   Nztest requires 0 or 1 GPUr«  r¯  s   & rÓ   Úrequire_torch_non_multi_gpur¾  —  sQ   € ô ×ÒÜ�}Š}Ð$;Õ<¸YÓGÐGãä×Ò˜uŸz™z×6Ñ6Ó8¸1Ñ<Ð>XÔYÐZcÓdÐdr   c                ó¶   € \        4       '       g   \        P                  ! RR7      ! V 4      # \        P                  ! \	        \
        4      ^8  R4      ! V 4      # )zO
Decorator marking a test that requires 0 or 1 accelerator setup (in PyTorch).
rb  rã   z test requires 0 or 1 acceleratorr²  rþ   s   &rÓ   Ú#require_torch_non_multi_acceleratorrÀ  £  sG   € ô ×ÒÜ�}Š}Ð$;Õ<¸YÓGÐGä×ÒÔ3´LÓAÀAÑEÐGiÔjÐktÓuÐur   c                óÔ   € \        4       '       g   \        P                  ! RR7      ! V 4      # ^ RIp\        P                  ! VP
                  P                  4       ^8  R4      ! V 4      # )zL
Decorator marking a test that requires 0 or 1 or 2 GPU setup (in PyTorch).
rb  rã   Nztest requires 0 or 1 or 2 GPUsr«  r¯  s   & rÓ   Úrequire_torch_up_to_2_gpusrÂ  ­  sQ   € ô ×ÒÜ�}Š}Ð$;Õ<¸YÓGÐGãä×Ò˜uŸz™z×6Ñ6Ó8¸1Ñ<Ð>^Ô_Ð`iÓjÐjr   c                ó¶   € \        4       '       g   \        P                  ! RR7      ! V 4      # \        P                  ! \	        \
        4      ^8  R4      ! V 4      # )zT
Decorator marking a test that requires 0 or 1 or 2 accelerator setup (in PyTorch).
rb  rã   z&test requires 0 or 1 or 2 acceleratorsr²  rþ   s   &rÓ   Ú"require_torch_up_to_2_acceleratorsrÄ  ¹  sK   € ô ×ÒÜ�}Š}Ð$;Õ<¸YÓGÐGä×ÒÔ3´LÓAÀAÑEÐGoÔpØóð r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z?
Decorator marking a test that requires TorchXLA (in PyTorch).
ztest requires TorchXLA)ræ   rü   r�   rþ   s   &rÓ   Úrequire_torch_xlarÆ  Å  s"   € ô ×ÒÔ5Ó7Ð9QÔRÐS\Ó]Ð]r   c                óP   € \         P                  ! \        RR7      R4      ! V 4      # )zA
Decorator marking a test that requires NeuronCore (in PyTorch).
F)Úcheck_devicez test requires PyTorch NeuronCore)ræ   rü   r{   rþ   s   &rÓ   Úrequire_torch_neuroncorerÉ  Ì  s(   € ô ×ÒÔ<È%ÔPÐRtÔuØóð r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zH
Decorator marking a test that requires TPU (in PyTorch via torch_tpu).
ztest requires PyTorch TPU)ræ   rü   r€   rþ   s   &rÓ   Úrequire_torch_tpurË  Õ  ó"   € ô ×ÒÔ5Ó7Ð9TÔUÐV_Ó`Ð`r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z:
Decorator marking a test that requires NPU (in PyTorch).
útest requires PyTorch NPU)ræ   rü   r|   rþ   s   &rÓ   Úrequire_torch_npurÏ  Ü  rÌ  r   c                óÔ   € \        4       '       g   \        P                  ! RR7      ! V 4      # \        P                  ! \        P
                  P                  4       ^8„  R4      ! V 4      # )z÷
Decorator marking a test that requires a multi-NPU setup (in PyTorch). These tests are skipped on a machine without
multiple NPUs.

To run *only* the multi_npu tests, assuming all test names contain multi_npu: $ pytest -sv ./tests -k "multi_npu"
rÎ  rã   ztest requires multiple NPUs)r|   ræ   r•   rü   r¬  rÇ   r®  rþ   s   &rÓ   Úrequire_torch_multi_npurÑ  ã  óN   € ô "×#Ò#Ü�}Š}Ð$?Õ@ÀÓKÐKä×ÒœuŸy™y×5Ñ5Ó7¸!Ñ;Ð=ZÔ[Ð\eÓfÐfr   c                óJ   € \         P                  ! \        R8g  R4      ! V 4      # )z:
Decorator marking a test that should be skipped for HPU.
Úhpuztest requires a non-HPU©ræ   rü   r´  rþ   s   &rÓ   Úrequire_non_hpurÖ  ð  ó#   € ô ×Òœ|¨uÑ4Ð6OÔPÐQZÓ[Ð[r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zv
Decorator marking a test that requires XPU (in PyTorch).

These tests are skipped when XPU backend is not available.
ztest requires XPU device)ræ   rü   r‚   rþ   s   &rÓ   Úrequire_torch_xpurÙ  ÷  s"   € ô ×ÒÔ5Ó7Ð9SÔTÐU^Ó_Ð_r   c                óJ   € \         P                  ! \        R8g  R4      ! V 4      # )z:
Decorator marking a test that should be skipped for XPU.
rÆ   ztest requires a non-XPUrÕ  rþ   s   &rÓ   Úrequire_non_xpurÛ     r×  r   c                óÔ   € \        4       '       g   \        P                  ! RR7      ! V 4      # \        P                  ! \        P
                  P                  4       ^8„  R4      ! V 4      # )z÷
Decorator marking a test that requires a multi-XPU setup (in PyTorch). These tests are skipped on a machine without
multiple XPUs.

To run *only* the multi_xpu tests, assuming all test names contain multi_xpu: $ pytest -sv ./tests -k "multi_xpu"
ztest requires PyTorch XPUrã   ztest requires multiple XPUs)r‚   ræ   r•   rü   r¬  rÆ   r®  rþ   s   &rÓ   Úrequire_torch_multi_xpurÝ    rÒ  r   c                óÔ   € \        4       '       g   \        P                  ! RR7      ! V 4      # \        P                  ! \        P
                  P                  4       ^8„  R4      ! V 4      # )z÷
Decorator marking a test that requires a multi-HPU setup (in PyTorch). These tests are skipped on a machine without
multiple HPUs.

To run *only* the multi_hpu tests, assuming all test names contain multi_hpu: $ pytest -sv ./tests -k "multi_hpu"
ztest requires PyTorch HPUrã   ztest requires multiple HPUs)ry   ræ   r•   rü   r¬  rÔ  r®  rþ   s   &rÓ   Úrequire_torch_multi_hpurß    rÒ  r   ÚTRANSFORMERS_TEST_BACKENDz.Failed to import `TRANSFORMERS_TEST_BACKEND` 'zf'! This should be the name of an installed module. The original error (look up to see its traceback):
ÚTRANSFORMERS_TEST_DEVICEr­  zTRANSFORMERS_TEST_DEVICE=zH, but CUDA is unavailable. Please double-check your testing environment.zG, but XPU is unavailable. Please double-check your testing environment.zG, but NPU is unavailable. Please double-check your testing environment.ÚmluzG, but MLU is unavailable. Please double-check your testing environment.rÔ  zG, but HPU is unavailable. Please double-check your testing environment.zUUnknown testing device specified by environment variable `TRANSFORMERS_TEST_DEVICE`: Úcpuc                óL   € \         P                  ! \        4       R4      ! V 4      # )z.Decorator marking a test that requires torchaoztest requires torchao)ræ   rü   rƒ   rþ   s   &rÓ   Úrequire_torchaorå  ]  s    € ä×ÒÔ3Ó5Ð7NÔOÐPYÓZÐZr   c                 ó   a € V 3R  lpV# )c                 ó:  <€ \        4       ;'       di    \        P                  ! \        P                  ! \        P                  P                  R 4      4      P
                  4      \        P                  ! S4      8¬  p\        P                  ! VRS R24      ! V 4      # )Útorchaoz4Test requires torchao with the version greater than Ú.)rƒ   r   ÚparseÚ	importlibÚmetadataÚbase_versionræ   rü   )rì   Úcorrect_torchao_versionÚtorchao_versions   & €rÓ   rD  Ú;require_torchao_version_greater_or_equal.<locals>.decoratorc  s„   ø€ Ü"6Ó"8÷ #,ð #,¼W¿]º]Ü�MŠMœ)×,Ñ,×4Ñ4°YÓ?Ó@×MÑMó>
ä�]Š]˜?Ó+ñ>,Ðô ×"Ò"Ø#Ð'[Ð\kÐ[lÐlmÐ%nô
à
óð 	r   rF  )rï  rD  s   f rÓ   Ú(require_torchao_version_greater_or_equalrñ  b  s   ø€ õð Ðr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z8Decorator marking a test that requires Torch-TensorRT FXztest requires Torch-TensorRT FX)ræ   rü   r~   rþ   s   &rÓ   Úrequire_torch_tensorrt_fxró  n  s    € ä×ÒÔ=Ó?ÐAbÔcÐdmÓnÐnr   c                óJ   € \         P                  ! \        R8H  R4      ! V 4      # )ú8Decorator marking a test that requires CUDA and PyTorch.r­  ztest requires CUDArÕ  rþ   s   &rÓ   Úrequire_torch_gpurö  s  s    € ä×Òœ|¨vÑ5Ð7KÔLÈYÓWÐWr   c                óJ   € \         P                  ! \        R8H  R4      ! V 4      # )rõ  Úmpsztest requires MPSrÕ  rþ   s   &rÓ   Úrequire_torch_mpsrù  x  s    € ä×Òœ|¨uÑ4Ð6IÔJÈ9ÓUÐUr   c                ó$   € V ^8„  d   QhR\         /# ©r8  Úmemory©Úfloat)r<  s   "rÓ   r=  r=  }  s   € ÷ 
ñ 
¬Uñ 
r   c                ó´   € \        4       '       g   V # ^ RIp\        P                  ! VP	                  4       P
                  R,          V8„  RV R24      ! V 4      # )zWDecorator marking a test that requires a CPU RAM with more than `memory` GiB of memory.Nz'test requires a machine with more than z GiB of CPU RAM memoryé   @)r^   Úpsutilræ   rü   Úvirtual_memoryÚtotal)rì   rü  r  s   && rÓ   Úrequire_large_cpu_ramr  }  sZ   € ä× Ò ØÐãä×ÒØ×ÑÓ×%Ñ%¨Õ/°&Ñ8Ø
1°&°Ð9OÐPôð óð r   c                ó$   € V ^8„  d   QhR\         /# rû  rý  )r<  s   "rÓ   r=  r=  Š  s   € ÷ ñ ¬uñ r   c                óþ   € \         R8w  d"   \        P                  ! RV R2R7      ! V 4      # \        P                  ! \        P
                  P                  ^ 4      P                  R,          V8„  RV R24      ! V 4      # )zXDecorator marking a test that requires a CUDA GPU with more than `memory` GiB of memory.r­  z(test requires a CUDA GPU with more than ú GiB of memoryrã   z#test requires a GPU with more than r   )r´  ræ   r•   rü   r¬  r­  Úget_device_propertiesÚtotal_memory)rì   rü  s   &&rÓ   Úrequire_torch_large_gpur
  Š  su   € ä�vÔÜ�}Š}Ð&NÈvÈhÐVdÐ$eÕfÐgpÓqÐqä×ÒÜ�
‰
×(Ñ(¨Ó+×8Ñ8¸7ÕBÀVÑKØ
-¨f¨X°^ÐDôð óð r   rü  c                ó$   € V ^8„  d   QhR\         /# rû  rý  )r<  s   "rÓ   r=  r=  •  s   € ÷ Rñ R¼uñ Rr   c               ó,   a€ V3R lpV f   V# V! V 4      # )z\Decorator marking a test that requires an accelerator with more than `memory` GiB of memory.c                 ó
  <€ \         R9  d!   \        P                  ! RS R24      ! V 4      # \        \        \         4      p\        P
                  ! VP                  ^ 4      P                  R,          S8„  RS R24      ! V 4      # )r­  z*test requires a GPU or XPU with more than r  )r­  rÆ   r   )r´  ræ   r•   r  r¬  rü   r  r	  )ÚtcÚtorch_accelrü  s   & €rÓ   Úmemory_decoratorÚ9require_torch_large_accelerator.<locals>.memory_decorator˜  s~   ø€ Ü˜Ô.Ü—=’=Ð#MÈfÈXÐUcÐ!dÔeÐfhÓiÐiäœe¤\Ó2ˆÜ×"Ò"Ø×-Ñ-¨aÓ0×=Ñ=ÀÕGÈ&ÑPØ8¸¸ÀÐOô
ð óð 	r   rF  )rì   rü  r  s   &d rÓ   Úrequire_torch_large_acceleratorr  •  s!   ø€ õð  )Ò0ÐÐQÑ6FÀyÓ6QÐQr   c                ój   € \         P                  ! \        RJ;'       d
    \        R8g  R4      ! V 4      # )zMDecorator marking a test that requires an accessible accelerator and PyTorch.Nrã  ztest requires acceleratorrÕ  rþ   s   &rÓ   Úrequire_torch_acceleratorr  ¥  s2   € ä×Òœ|°4Ð7×QÐQ¼LÈEÑ<QÐSnÔoØóð r   c                óV   € \         P                  ! \        \        4      R4      ! V 4      # )zBDecorator marking a test that requires a device that supports fp16z&test requires device with fp16 support)ræ   rü   rw   r´  rþ   s   &rÓ   Úrequire_torch_fp16r  ¬  ó(   € ä×ÒÜ)¬,Ó7Ð9aôàóð r   c                óp   € \         P                  ! \        4       ;'       d    \        4       R4      ! V 4      # )z7Decorator marking a test that requires supports for fp8ztest requires fp8 support)ræ   rü   r'   r�   rþ   s   &rÓ   Úrequire_fp8r  ³  s0   € ä×ÒÔ6Ó8×OÐOÔ=MÓ=OÐQlÔmØóð r   c                óÆ   € ^ RI pVP                  P                  4       '       g   R # VP                  P                  4       p\        P
                  ! W0V38  RV  RV 24      # )u  Decorator: when running on CUDA, skip if device capability is below the given
threshold. On non-CUDA backends this is a no-op â€” pair with :func:`require_torch_gpu`
if the test is CUDA-only, or leave alone if it should also run on other backends
(which won't be capability-gated).Nc                 ó   € V # ©NrF  rþ   s   &rÓ   Ú<lambda>Ú2require_cuda_capability_at_least.<locals>.<lambda>Â  s   € ¡r   zRequires CUDA capability >= ré  )r¬  r­  Úis_availableÚget_device_capabilityræ   ÚskipIf)ÚmajorÚminorr¬  Ú
capabilitys   &&  rÓ   Ú require_cuda_capability_at_leastr%  º  s]   € ó
 à�:‰:×"Ñ"×$Ò$Ù*Ð*Ø—‘×1Ñ1Ó3€JÜ�?Š?˜:°¨Ñ6Ð:VÐW\ÐV]Ð]^Ð_dÐ^eÐ8fÓgÐgr   c                óV   € \         P                  ! \        \        4      R4      ! V 4      # )zBDecorator marking a test that requires a device that supports bf16z&test requires device with bf16 support)ræ   rü   rv   r´  rþ   s   &rÓ   Úrequire_torch_bf16r'  Ç  r  r   c                 ó0   a € \        S 4      V 3R  l4       pV# )c                  óþ   <€ \        4       '       dK   \        P                  ! 4       p \        P                  ! R 4       S! V / VB \        P                  ! V4       # S! V / VB #   \        P                  ! T4       i ; i©T)r‚   r¬  Ú$are_deterministic_algorithms_enabledÚuse_deterministic_algorithms)r  r  Úoriginal_staterì   s   *, €rÓ   r  Ú.require_deterministic_for_xpu.<locals>.wrapperÏ  sk   ø€ ä!×#Ò#Ü"×GÒGÓIˆNðCÜ×2Ò2°4Ô8Ù  $Ð1¨&Ñ1ä×2Ò2°>ÕBá˜dÐ- fÑ-Ð-øô ×2Ò2°>ÕBús   ¨A$ Á$A<)r   )rì   r  s   f rÓ   Úrequire_deterministic_for_xpur/  Î  s!   ø€ Ü
ˆ9Óô	.ó ð	.ð €Nr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z[Decorator marking a test that requires Ampere or a newer GPU arch, cuda>=11 and torch>=1.7.zAtest requires Ampere or a newer GPU arch, cuda>=11 and torch>=1.7)ræ   rü   r   rþ   s   &rÓ   Úrequire_torch_tf32r1  Þ  s&   € ä×ÒÜÓ!Ð#fôàóð r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z2Decorator marking a test that requires detectron2.ztest requires `detectron2`)ræ   rü   r4   rþ   s   &rÓ   Úrequire_detectron2r3  å  s    € ä×ÒÔ6Ó8Ð:VÔWÐXaÓbÐbr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z-Decorator marking a test that requires faiss.ztest requires `faiss`)ræ   rü   r6   rþ   s   &rÓ   Úrequire_faissr5  ê  s   € ä×ÒÔ1Ó3Ð5LÔMÈiÓXÐXr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zeDecorator marking a test that requires IPython. These tests are skipped when IPython isn't installed.ztest requires `IPython`)ræ   rü   rH   rþ   s   &rÓ   Úrequire_ipythonr7  ï  s    € ä×ÒÔ3Ó5Ð7PÔQÐR[Ó\Ð\r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zg
Decorator marking a test that requires optuna.

These tests are skipped when optuna isn't installed.

ztest requires optuna)ræ   rü   r   rþ   s   &rÓ   Úrequire_optunar9  ô  r`  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zk
Decorator marking a test that requires Ray/tune.

These tests are skipped when Ray/tune isn't installed.

ztest requires Ray/tune)ræ   rü   r   rþ   s   &rÓ   Úrequire_rayr;  þ  s!   € ô ×ÒÔ/Ó1Ð3KÔLÈYÓWÐWr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zi
Decorator marking a test that requires swanlab.

These tests are skipped when swanlab isn't installed.

ztest requires swanlab)ræ   rü   r   rþ   s   &rÓ   Úrequire_swanlabr=    ó"   € ô ×ÒÔ3Ó5Ð7NÔOÐPYÓZÐZr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zi
Decorator marking a test that requires trackio.

These tests are skipped when trackio isn't installed.

ztest requires trackio)ræ   rü   r   rþ   s   &rÓ   Úrequire_trackior@    r>  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )ze
Decorator marking a test that requires wandb.

These tests are skipped when wandb isn't installed.

ztest requires wandb)ræ   rü   r    rþ   s   &rÓ   Úrequire_wandbrB    s!   € ô ×ÒÔ1Ó3Ð5JÔKÈIÓVÐVr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zd
Decorator marking a test requires clearml.

These tests are skipped when clearml isn't installed.

ztest requires clearml)ræ   rü   r   rþ   s   &rÓ   Úrequire_clearmlrD  &  r>  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z2
Decorator marking a test that requires deepspeed
ztest requires deepspeed)ræ   rü   r!   rþ   s   &rÓ   Úrequire_deepspeedrF  0  r+  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z-
Decorator marking a test that requires apex
ztest requires apex)ræ   rü   r(   rþ   s   &rÓ   Úrequire_apexrH  7  ó!   € ô ×ÒÔ0Ó2Ð4HÔIÈ)ÓTÐTr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z-
Decorator marking a test that requires aqlm
ztest requires aqlm)ræ   rü   r*   rþ   s   &rÓ   Úrequire_aqlmrK  >  rI  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z-
Decorator marking a test that requires vptq
ztest requires vptq)ræ   rü   r‰   rþ   s   &rÓ   Úrequire_vptqrM  E  rI  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z-
Decorator marking a test that requires spqr
ztest requires spqr)ræ   rü   ro   rþ   s   &rÓ   Úrequire_spqrrO  L  rI  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z+
Decorator marking a test that requires av
ztest requires av)ræ   rü   r,   rþ   s   &rÓ   Ú
require_avrQ  S  s    € ô ×ÒœÓ0Ð2DÔEÀiÓPÐPr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z/
Decorator marking a test that requires decord
ztest requires decord)ræ   rü   r3   rþ   s   &rÓ   Úrequire_decordrS  Z  rQ  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z’
Decorator marking a test that requires the bitsandbytes library. Will be skipped when the library or its hard dependency torch is not installed.
ztest requires bitsandbytes)ræ   rü   r-   rþ   s   &rÓ   Úrequire_bitsandbytesrU  a  ó"   € ô ×ÒÔ8Ó:Ð<XÔYÐZcÓdÐdr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z"
Decorator for optimum dependency
ztest requires optimum)ræ   rü   rX   rþ   s   &rÓ   Úrequire_optimumrX  h  ó"   € ô ×ÒÔ3Ó5Ð7NÔOÐPYÓZÐZr   c                ó@   € \         P                  ! \        4       R4      # )z(
Decorator for `tensorboard` dependency
ztest requires tensorboard)ræ   rü   r   rþ   s   &rÓ   Úrequire_tensorboardr[  o  s   € ô ×ÒÔ7Ó9Ð;VÓWÐWr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z$
Decorator for gptqmodel dependency
ztest requires gptqmodel)ræ   rü   rC   rþ   s   &rÓ   Úrequire_gptqmodelr]  v  r+  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z
Decorator for hqq dependency
ztest requires hqq)ræ   rü   rF   rþ   s   &rÓ   Úrequire_hqqr_  }  s!   € ô ×ÒÔ/Ó1Ð3FÔGÈ	ÓRÐRr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z%
Decorator for auto_round dependency
ztest requires autoround)ræ   rü   r+   rþ   s   &rÓ   Úrequire_auto_roundra  „  s"   € ô ×ÒÔ6Ó8Ð:SÔTÐU^Ó_Ð_r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z!
Decorator for quanto dependency
ztest requires optimum-quanto)ræ   rü   rY   rþ   s   &rÓ   Úrequire_optimum_quantorc  ‹  ó"   € ô ×ÒÔ:Ó<Ð>\Ô]Ð^gÓhÐhr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z-
Decorator for compressed_tensors dependency
z test requires compressed_tensors)ræ   rü   r0   rþ   s   &rÓ   Úrequire_compressed_tensorsrf  ’  s"   € ô ×ÒÔ>Ó@ÐBdÔeÐfoÓpÐpr   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z%
Decorator for fbgemm_gpu dependency
ztest requires fbgemm-gpu)ræ   rü   r7   rþ   s   &rÓ   Úrequire_fbgemm_gpurh  ™  r“  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z 
Decorator for quark dependency
ztest requires quark)ræ   rü   rd   rþ   s   &rÓ   Úrequire_quarkrj     rV  r   c                óp   € \         P                  ! \        4       ;'       d    \        4       R4      ! V 4      # )z;
Decorator marking a test that requires higgs and hadamard
z/test requires flute and fast_hadamard_transform)ræ   rü   r<   rE   rþ   s   &rÓ   Úrequire_flute_hadamardrl  §  s4   € ô ×ÒÜÓ×8Ð8Ô!6Ó!8Ð:kôàóð r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z4
Decorator marking a test that requires fouroversix
ztest requires fouroversix)ræ   rü   r=   rþ   s   &rÓ   Úrequire_fouroversixrn  °  r£  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z=
Decorator marking a test that requires fp_quant and qutlass
ztest requires fp_quant)ræ   rü   r>   rþ   s   &rÓ   Úrequire_fp_quantrp  ·  rY  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z0
Decorator marking a test that requires qutlass
ztest requires qutlass)ræ   rü   re   rþ   s   &rÓ   Úrequire_qutlassrr  ¾  rY  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z3
Decorator marking a test that requires phonemizer
ztest requires phonemizer)ræ   rü   r\   rþ   s   &rÓ   Úrequire_phonemizerrt  Å  r“  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z4
Decorator marking a test that requires pyctcdecode
ztest requires pyctcdecode)ræ   rü   r_   rþ   s   &rÓ   Úrequire_pyctcdecoderv  Ì  r£  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z.
Decorator marking a test that requires numba
ztest requires numba)ræ   rü   rU   rþ   s   &rÓ   Úrequire_numbarx  Ó  rV  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z0
Decorator marking a test that requires librosa
ztest requires librosa)ræ   rü   rN   rþ   s   &rÓ   Úrequire_librosarz  Ú  rY  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z9
Decorator marking a test that requires python-multipart
ztest requires python-multipart)ræ   rü   rR   rþ   s   &rÓ   Úrequire_multipartr|  á  s"   € ô ×ÒÔ5Ó7Ð9YÔZÐ[dÓeÐer   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z5
Decorator marking a test that requires liger_kernel
ztest requires liger_kernel)ræ   rü   rO   rþ   s   &rÓ   Úrequire_liger_kernelr~  è  rV  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z1
Decorator marking a test that requires essentia
ztest requires essentia)ræ   rü   r5   rþ   s   &rÓ   Úrequire_essentiar€  ï  rY  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z4
Decorator marking a test that requires pretty_midi
ztest requires pretty_midi)ræ   rü   r]   rþ   s   &rÓ   Úrequire_pretty_midir‚  ö  r£  r   c                 ó2   € \         P                  ! V 4      R J# r  )ÚshutilÚwhich)Úcmds   &rÓ   Ú
cmd_existsr‡  ý  s   € Ü�<Š<˜Ó DÐ(Ð(r   c                óN   € \         P                  ! \        R4      R4      ! V 4      # )z8
Decorator marking a test that requires `/usr/bin/time`
ú/usr/bin/timeztest requires /usr/bin/time)ræ   rü   r‡  rþ   s   &rÓ   Úrequire_usr_bin_timerŠ    s#   € ô ×Òœz¨/Ó:Ð<YÔZÐ[dÓeÐer   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z0
Decorator marking a test that requires sudachi
ztest requires sudachi)ræ   rü   rp   rþ   s   &rÓ   Úrequire_sudachirŒ    rY  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z;
Decorator marking a test that requires sudachi_projection
z/test requires sudachi which supports projection)ræ   rü   rq   rþ   s   &rÓ   Úrequire_sudachi_projectionrŽ    s&   € ô ×ÒÔ>Ó@ÐBsÔtØóð r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )ú0
Decorator marking a test that requires jumanpp
ztest requires jumanpp)ræ   rü   rK   rþ   s   &rÓ   Úrequire_jumanppr‘    rY  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )r�  ztest requires cython)ræ   rü   r2   rþ   s   &rÓ   Úrequire_cythonr“    rQ  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zi
Decorator marking a test that requires TikToken. These tests are skipped when TikToken isn't installed.
ztest requires TikToken)ræ   rü   rr   rþ   s   &rÓ   Úrequire_tiktokenr•  &  rY  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )ze
Decorator marking a test that requires speech. These tests are skipped when speech isn't available.
r‘  )ræ   rü   rn   rþ   s   &rÓ   Úrequire_speechr—  -  s"   € ô ×ÒÔ2Ó4Ð6PÔQÐR[Ó\Ð\r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )z/
Decorator marking a test that requires openai
ztest requires openai)ræ   rü   rW   rþ   s   &rÓ   Úrequire_openair™  4  rQ  r   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zg
Decorator marking a test that requires the serving dependencies (fastapi, uvicorn, pydantic, openai).
z"test requires serving dependencies)ræ   rü   rl   rþ   s   &rÓ   Úrequire_server›  ;  s"   € ô ×ÒÔ1Ó3Ð5YÔZÐ[dÓeÐer   c                óL   € \         P                  ! \        4       R4      ! V 4      # )zu
Decorator marking a test that requires mistral-common. These tests are skipped when mistral-common isn't available.
ztest requires mistral-common)ræ   rü   rQ   rþ   s   &rÓ   Úrequire_mistral_commonr�  B  rd  r   c                 ób   € \        4       '       d   ^ RIp V P                  P                  4       # ^ # )z%
Return the number of available gpus
N)ru   r¬  r­  r®  )r¬  s    rÓ   Úget_gpu_countrŸ  I  s&   € ô ×ÒÛà�z‰z×&Ñ&Ó(Ð(ár   c                ó‚  € \         P                  ! 4       ^,          ^,          p\        P                  P	                  \        P                  P                  V4      4      pVP                  R4      '       g"   \        P                  P                  V4      pK8  V '       d    \        P                  P                  W 4      # V# )zû
Args:
    append_path: optional path to append to the tests dir path

Return:
    The full path to the `tests` dir, so that the tests can be invoked from anywhere. Optionally `append_path` is
    joined after the `tests` dir the former is provided.

Útests)ÚinspectÚstackrÊ   ÚpathÚabspathÚdirnameÚendswithÚjoin)Úappend_pathÚcaller__file__Ú	tests_dirs   &  rÓ   Úget_tests_dirr¬  U  sw   € ô —]’]“_ QÕ'¨Õ*€NÜ—‘—‘¤§¡§¡°Ó ?Ó@€Ià× Ñ  ×)Ò)Ü—G‘G—O‘O IÓ.Š	çÜ�w‰w�|‰|˜IÓ3Ð3àÐr   c                ó0   € V ^8„  d   QhR\         R\        /# )r8  ÚtrainerÚreturn)r   r×   )r<  s   "rÓ   r=  r=  l  s   € ÷ ñ ¤ð ¬Sñ r   c                 ót   € V P                   pV P                  4       pV P                  WR 7      pV^,          pV# ))r  Ú
dataloader)r  Úget_train_dataloaderÚset_initial_training_values)r®  Útraining_argsÚtrain_dataloaderÚinitial_training_valuesÚsteps_per_epochs   &    rÓ   Úget_steps_per_epochr¸  l  s>   € Ø—L‘L€MØ×3Ñ3Ó5Ðà%×AÑAÀ}ÐAÓrÐØ-¨aÕ0€OàÐr   c                ó¦   € V ^8„  d   QhR\         \        \        \        3,          ,          R\        \        \        \        3,          RR3,          /# )r8  Úside_effect_valuesr¯  N)ÚlistÚdictr;  rþ  r   )r<  s   "rÓ   r=  r=  v  s?   € ÷ 
%ñ 
%ÜœT¤#¤u *Õ-Õ.ð
%äŒt”Cœ�JÕ  tÐ+Õ,ñ
%r   c              #  ó>   "  € T  Rj  x€L
   V R,          x € K   L5i)z‰
Function that returns side effects for the _evaluate method.
Used when we're unsure of exactly how many times _evaluate will be called.
NéÿÿÿÿrF  )rº  s   &rÓ   Úevaluate_side_effect_factoryr¿  v  s#   é € ð "×!Ð!à
Ø  Õ$Ô$ñ "ùs   ‚ˆ‰c                 óR   € \         P                  ! R RV ^ \         P                  4      # )z^.*\rÚ )ÚreÚsubÚ	MULTILINE)Úbufs   &rÓ   Úapply_print_resetsrÆ  ’  s   € Ü�6Š6�(˜B  Q¬¯©Ó5Ð5r   c                 óž   € \        V 4      P                  4       pVP                  VP                  4       4      pVR8w  g   Q RV RV 24       hR# )é   zexpecting to find z in output: fNr¾  )rÆ  ÚlowerÚfind)ÚoutÚwhatÚout_prÚ	match_strs   &&  rÓ   Úassert_screenoutrÏ  –  sH   € Ü Ó$×*Ñ*Ó,€FØ—‘˜DŸJ™J›LÓ)€IØ˜Œ?ÐLÐ0°°°mÀFÀ8ÐLÓLŠ?r   c                 óÔ   € . ROpV F  p\        WR4       K  	  . ROpV FD  p\        W4      '       g   K  \        W4      f   K%  V F  p\        \        W4      VR4       K  	  KF  	  R# )Úrms_norm_epsç      ð?N)rÑ  Úlayer_norm_epsÚnorm_epsÚnorm_epsilonÚlayer_norm_epsilonÚbatch_norm_eps)Útext_configÚvision_configÚaudio_configÚtext_encoderÚaudio_encoderÚdecoder)r  Úhasattrr  )ÚconfigÚtarget_attrsÚtarget_attrÚattrsr  s   &    rÓ   Úset_config_for_less_flaky_testrã  œ  sa   € ò€Ló $ˆÜ� SÖ)ñ $ò
 i€EÛˆÜ�6× Ô ¤W¨VÓ%:Ô%FÛ+�Üœ Ó-¨{¸CÖ@ó  ,ó r   c                 ód  € Rp. ROp\        4       '       dš   \        V \        P                  P                  4      '       dn   V P                  4        FW  p\        V4      P                  P                  V4      '       g   K/  V F"  p\        W44      '       g   K  \        W4R4       K$  	  KY  	  R# R# R# )Ú	LayerNormrÒ  N)rå  Ú	GroupNormÚ	BatchNormÚRMSNormÚBatchNorm2dÚBatchNorm1dÚBitGroupNormActivationÚWeightStandardizedConv2d)ÚepsÚepsilonÚvariance_epsilon)ru   Ú
isinstancer¬  ÚnnrŽ   ÚmodulesÚtypeÚ__name__r§  rÞ  r  )ÚmodelÚtarget_namesrà  Úmoduler  s   &    rÓ   Úset_model_for_less_flaky_testrø  ±  s€   € ð	€Lò :€LÜ×Ò¤
¨5´%·(±(·/±/× BÒ BØ—m‘m–oˆFÜ�F‹|×$Ñ$×-Ñ-¨l×;Ô;Û(�DÜ˜v×,Ô,Ü ¨cÖ2ó )ó &ñ !CÑr   c                   ó@   a € ] tR tRt o RtR	R ltR tR tR tRt	V t
R# )
Ú
CaptureStdiÆ  aâ  
Context manager to capture:

    - stdout: replay it, clean it up and make it available via `obj.out`
    - stderr: replay it and make it available via `obj.err`

Args:
    out (`bool`, *optional*, defaults to `True`): Whether to capture stdout or not.
    err (`bool`, *optional*, defaults to `True`): Whether to capture stderr or not.
    replay (`bool`, *optional*, defaults to `True`): Whether to replay or not.
        By default each captured stream gets replayed back on context's exit, so that one can see what the test was
        doing. If this is a not wanted behavior and the captured data shouldn't be replayed, pass `replay=False` to
        disable this feature.

Examples:

```python
# to capture stdout only with auto-replay
with CaptureStdout() as cs:
    print("Secret message")
assert "message" in cs.out

# to capture stderr only with auto-replay
import sys

with CaptureStderr() as cs:
    print("Warning: ", file=sys.stderr)
assert "Warning" in cs.err

# to capture both streams with auto-replay
with CaptureStd() as cs:
    print("Secret message")
    print("Warning: ", file=sys.stderr)
assert "message" in cs.out
assert "Warning" in cs.err

# to capture just one of the streams, and not the other, with auto-replay
with CaptureStd(err=False) as cs:
    print("Secret message")
assert "message" in cs.out
# but best use the stream-specific subclasses

# to capture without auto-replay
with CaptureStd(replay=False) as cs:
    print("Secret message")
assert "message" in cs.out
```c                óÈ   € W0n         V'       d   \        4       V n        R V n        MRV n        RV n        V'       d   \        4       V n        R V n        R# RV n        RV n        R# )z=error: CaptureStd context is unfinished yet, called too earlyNznot capturing stdoutznot capturing stderr)Úreplayr   Úout_bufrË  Úerr_bufÚerr)ÚselfrË  rÿ  rü  s   &&&&rÓ   Ú__init__ÚCaptureStd.__init__÷  sI   € ØŒçÜ#›:ˆDŒLØVˆD�HàˆDŒLØ-ˆDŒHçÜ#›:ˆDŒLØVˆDŽHàˆDŒLØ-ˆDŽHr   c                óö   € V P                   '       d+   \        P                  V n        V P                   \        n        V P                  '       d+   \        P
                  V n        V P                  \        n        V # r  )rý  ÚsysÚstdoutÚout_oldrþ  ÚstderrÚerr_old©r   s   &rÓ   Ú	__enter__ÚCaptureStd.__enter__  sE   € Ø�<�<ˆ<ÜŸ:™:ˆDŒLØŸ™ŒCŒJà�<�<ˆ<ÜŸ:™:ˆDŒLØŸ™ŒCŒJàˆr   c                óþ  € V P                   '       dq   V P                  \        n        V P                   P	                  4       pV P
                  '       d    \        P                  P                  V4       \        V4      V n        V P                  '       di   V P                  \        n        V P                  P	                  4       pV P
                  '       d    \        P                  P                  V4       W n        R # R # r  )rý  r  r  r  Úgetvaluerü  ÚwriterÆ  rË  rþ  r  r  rÿ  )r   ÚexcÚcaptureds   &* rÓ   Ú__exit__ÚCaptureStd.__exit__  sš   € Ø�<�<ˆ<ØŸ™ŒCŒJØ—|‘|×,Ñ,Ó.ˆHØ�{�{ˆ{Ü—
‘
× Ñ  Ô*Ü)¨(Ó3ˆDŒHà�<�<ˆ<ØŸ™ŒCŒJØ—|‘|×,Ñ,Ó.ˆHØ�{�{ˆ{Ü—
‘
× Ñ  Ô*ØŽHñ r   c                ó®   € R pV P                   '       d   VRV P                   R2,          pV P                  '       d   VRV P                   R2,          pV# )rÁ  zstdout: Ú
ústderr: )rý  rË  rþ  rÿ  )r   Úmsgs   & rÓ   Ú__repr__ÚCaptureStd.__repr__"  sL   € ØˆØ�<�<ˆ<Ø�X˜dŸh™h˜Z rÐ*Õ*ˆCØ�<�<ˆ<Ø�X˜dŸh™h˜Z rÐ*Õ*ˆCØˆ
r   )rÿ  rþ  r  rË  rý  r  rü  N)TTT©rô  Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r  r
  r  r  Ú__static_attributes__Ú__classdictcell__©Ú__classdict__s   @rÓ   rú  rú  Æ  s$   ø‡ € ñ.ô`.ò"	ò ÷ð r   rú  c                   ó:   a a€ ] tR tRt oRtRV 3R lltRtVtV ;t# )ÚCaptureStdouti1  z+Same as CaptureStd but captures only stdoutc                ó*   <€ \         SV `  R VR7       R# )F)rÿ  rü  N©Úsuperr  ©r   rü  Ú	__class__s   &&€rÓ   r  ÚCaptureStdout.__init__4  ó   ø€ Ü‰Ñ˜U¨6ÐÖ2r   rF  r*  ©	rô  r  r  r  r  r  r  r  Ú__classcell__©r(  r!  s   @@rÓ   r#  r#  1  ó   ù‡ € Ù5÷3÷ 3r   r#  c                   ó:   a a€ ] tR tRt oRtRV 3R lltRtVtV ;t# )ÚCaptureStderri8  z+Same as CaptureStd but captures only stderrc                ó*   <€ \         SV `  R VR7       R# )F)rË  rü  Nr%  r'  s   &&€rÓ   r  ÚCaptureStderr.__init__;  r*  r   rF  r*  r+  r-  s   @@rÓ   r0  r0  8  r.  r   r0  c                   ó<   a € ] tR tRt o RtR tR tR tR tRt	V t
R# )	ÚCaptureLoggeri?  a:  
    Context manager to capture `logging` streams

    Args:
        logger: 'logging` logger object

    Returns:
        The captured output is available via `self.out`

    Example:

    ```python
    >>> from transformers import logging
    >>> from transformers.testing_utils import CaptureLogger

    >>> msg = "Testing 1, 2, 3"
    >>> logging.set_verbosity_info()
    >>> logger = logging.get_logger("transformers.models.bart.tokenization_bart")
    >>> with CaptureLogger(logger) as cl:
    ...     logger.info(msg)
    >>> assert cl.out, msg + "
"
    ```
    c                óˆ   € Wn         \        4       V n        \        P                  ! V P                  4      V n        R V n        R# )rÁ  N)Úloggerr   Úior   ÚStreamHandlerÚshrË  )r   r6  s   &&rÓ   r  ÚCaptureLogger.__init__X  s-   € ØŒÜ“*ˆŒÜ×'Ò'¨¯©Ó0ˆŒØˆŽr   c                óP   € V P                   P                  V P                  4       V # r  )r6  Ú
addHandlerr9  r	  s   &rÓ   r
  ÚCaptureLogger.__enter__^  s   € Ø�‰×Ñ˜tŸw™wÔ'Øˆr   c                óŽ   € V P                   P                  V P                  4       V P                  P	                  4       V n        R # r  )r6  ÚremoveHandlerr9  r7  r  rË  )r   r  s   &*rÓ   r  ÚCaptureLogger.__exit__b  s,   € Ø�‰×!Ñ! $§'¡'Ô*Ø—7‘7×#Ñ#Ó%ˆŽr   c                ó"   € R V P                    R2# )z
captured: r  )rË  r	  s   &rÓ   r  ÚCaptureLogger.__repr__f  s   € Ø˜DŸH™H˜: RÐ(Ð(r   )r7  r6  rË  r9  Nr  r   s   @rÓ   r4  r4  ?  s#   ø‡ € ñò0òò&÷)ð )r   r4  c              #  óÐ   "  € \         P                  ! 4       p \         P                  ! V 4       Rx € \         P                  ! V4       R#   \         P                  ! T4       i ; i5i)aE  
This is a context manager to temporarily change transformers modules logging level to the desired value and have it
restored to the original setting at the end of the scope.

Example:

```python
with LoggingLevel(logging.INFO):
    AutoModel.from_pretrained("openai-community/gpt2")  # calls logger.info() several times
```
N)Útransformers_loggingÚget_verbosityÚset_verbosity)ÚlevelÚ
orig_levels   & rÓ   ÚLoggingLevelrI  j  sH   é € ô &×3Ò3Ó5€Jð7Ü×*Ò*¨5Ô1Ûä×*Ò*¨:Ö6øÔ×*Ò*¨:Õ6üs   ‚A&™A ³A&ÁA#Á#A&c                   óF   a € ] tR tRt o RtR	V 3R lR lltR tR tRtV t	R# )
ÚTemporaryHubRepoi  aÐ  Create a temporary Hub repository and return its `RepoUrl` object. This is similar to
`tempfile.TemporaryDirectory` and can be used as a context manager. For example:

    with TemporaryHubRepo(token=self._token) as temp_repo:
        ...

Upon exiting the context, the repository and everything contained in it are removed.

Example:

```python
with TemporaryHubRepo(token=self._token) as temp_repo:
    model.push_to_hub(tmp_repo.repo_id, token=self._token)
```
Nc                óF   <€ V ^8„  d   QhRS[ R,          RS[ R,          RR/# )r8  Ú	namespaceNÚtokenr¯  r:  )r<  r!  s   "€rÓ   r=  ÚTemporaryHubRepo.__annotate__�  s0   ø€ ÷ Cñ C¡#¨¥*ð C¹CÀ$½Jð CÐRVñ Cr   c                óü   € W n         \        P                  ! 4       ;_uu_ 4       p\        V4      P                  pVe   V RV 2p\        W@P                   R7      V n        R R R 4       R #   + '       g   i     R # ; i)NÚ/)rN  )rN  ÚtempfileÚTemporaryDirectoryr   Únamer   Úrepo_url)r   rM  rN  Útmp_dirÚrepo_ids   &&&  rÓ   r  ÚTemporaryHubRepo.__init__�  s\   € ØŒ
Ü×(Ò(×*Ô*¨gÜ˜7“m×(Ñ(ˆGØÒ$Ø&˜K q¨¨	Ð2�Ü'¨·z±zÔBˆDŒM÷	 +×*×*Ò*ús   ¤<A*Á*A;	c                ó   € V P                   # r  )rU  r	  s   &rÓ   r
  ÚTemporaryHubRepo.__enter__˜  s   € Ø�}‰}Ðr   c                ó^   € \        V P                  P                  V P                  R R7       R# )T)rW  rN  Ú
missing_okN)r   rU  rW  rN  )r   r  rÑ   Útbs   &&&&rÓ   r  ÚTemporaryHubRepo.__exit__›  s   € Ü˜DŸM™M×1Ñ1¸¿¹ÐPT×Ur   )rU  rN  ©NN)
rô  r  r  r  r  r  r
  r  r  r  r   s   @rÓ   rK  rK    s'   ø‡ € ñ÷ Cò Cò÷Vð Vr   rK  c                óh   € V ^8„  d   QhR\         \        P                  ,          R\        R,          /# )r8  r¤  r¯  N)r;  rÊ   ÚPathLiker   )r<  s   "rÓ   r=  r=  ¡  s'   € ÷ ñ œœbŸk™kÕ)ð ¬h°t­nñ r   c              #  ó
  "  € \         P                  ! V 4      p  \        P                  P	                  ^ V 4       Rx € \        P                  P                  V 4       R#   \        P                  P                  T 4       i ; i5i)z˜
Temporary add given path to `sys.path`.

Usage :

```python
with ExtendSysPath("/path/to/dir"):
    mymodule = importlib.import_module("mymodule")
```
N)rÊ   Úfspathr  r¤  ÚinsertÚremove)r¤  s   &rÓ   ÚExtendSysPathrf  Ÿ  sN   é € ô �9Š9�T‹?€DðÜ�‰�‰˜˜4Ô Ûä�‰�‰˜ÖøŒ�‰�‰˜Õüs   ‚Bš$A ¾!BÁ!B Â Bc                   ó  a € ] tR tRt o RtR t]R 4       t]R 4       t]R 4       t	]R 4       t
]R 4       t]R	 4       t]R
 4       t]R 4       t]R 4       t]R 4       t]R 4       t]R 4       tR tRR ltR tR tRtV tR# )ÚTestCasePlusiµ  aÒ  
This class extends *unittest.TestCase* with additional features.

Feature 1: A set of fully resolved important file and dir path accessors.

In tests often we need to know where things are relative to the current test file, and it's not trivial since the
test could be invoked from more than one directory or could reside in sub-directories with different depths. This
class solves this problem by sorting out all the basic paths and provides easy accessors to them:

- `pathlib` objects (all fully resolved):

   - `test_file_path` - the current test file path (=`__file__`)
   - `test_file_dir` - the directory containing the current test file
   - `tests_dir` - the directory of the `tests` test suite
   - `examples_dir` - the directory of the `examples` test suite
   - `repo_root_dir` - the directory of the repository
   - `src_dir` - the directory of `src` (i.e. where the `transformers` sub-dir resides)

- stringified paths---same as above but these return paths as strings, rather than `pathlib` objects:

   - `test_file_path_str`
   - `test_file_dir_str`
   - `tests_dir_str`
   - `examples_dir_str`
   - `repo_root_dir_str`
   - `src_dir_str`

Feature 2: Flexible auto-removable temporary dirs which are guaranteed to get removed at the end of test.

1. Create a unique temporary dir:

```python
def test_whatever(self):
    tmp_dir = self.get_auto_remove_tmp_dir()
```

`tmp_dir` will contain the path to the created temporary dir. It will be automatically removed at the end of the
test.


2. Create a temporary dir of my choice, ensure it's empty before the test starts and don't
empty it after the test.

```python
def test_whatever(self):
    tmp_dir = self.get_auto_remove_tmp_dir("./xxx")
```

This is useful for debug when you want to monitor a specific directory and want to make sure the previous tests
didn't leave any data in there.

3. You can override the first two options by directly overriding the `before` and `after` args, leading to the
    following behavior:

`before=True`: the temporary dir will always be cleared at the beginning of the test.

`before=False`: if the temporary dir already existed, any existing files will remain there.

`after=True`: the temporary dir will always be deleted at the end of the test.

`after=False`: the temporary dir will always be left intact at the end of the test.

Note 1: In order to run the equivalent of `rm -r` safely, only subdirs of the project repository checkout are
allowed if an explicit `tmp_dir` is used, so that by mistake no `/tmp` or similar important part of the filesystem
will get nuked. i.e. please always pass paths that start with `./`

Note 2: Each test can register multiple temporary dirs and they all will get auto-removed, unless requested
otherwise.

Feature 3: Get a copy of the `os.environ` object that sets up `PYTHONPATH` specific to the current test suite. This
is useful for invoking external programs from the test suite - e.g. distributed training.


```python
def test_whatever(self):
    env = self.get_env()
```c                óf  € . V n         \        P                  ! V P                  4      V n        \        V P                  4      P                  4       pVP                  ^ ,          V n        R FT  pVP                  V,          pVR,          P                  4       '       g   K5  VR,          P                  4       '       g   KT   M	  X'       d   W0n
        M\        RV P                   24      hV P                  R,          V n        V P                  R,          V n        V P                  R,          V n        R# )r   Úsrcr¡  z+can't figure out the root of the repo from ÚexamplesN)rÈ  r8  é   )Úteardown_tmp_dirsr¢  Úgetfiler(  Ú_test_file_pathr   ÚresolveÚparentsÚ_test_file_dirÚis_dirÚ_repo_root_dirrÌ   Ú
_tests_dirÚ_examples_dirÚ_src_dir)r   r¤  ÚuprV  s   &   rÓ   ÚsetUpÚTestCasePlus.setUp  sç   € à!#ˆÔô  'Ÿš¨t¯~©~Ó>ˆÔÜ�D×(Ñ(Ó)×1Ñ1Ó3ˆØ"Ÿl™l¨1�oˆÔÛˆBØ—l‘l 2Õ&ˆGØ˜%•×'Ñ'×)Ô)¨w¸Õ/@×.HÑ.H×.JÔ.JÙñ ÷ Ø")ÕäÐJÈ4×K_ÑK_ÐJ`ÐaÓbÐbØ×-Ñ-°Õ7ˆŒØ!×0Ñ0°:Õ=ˆÔØ×+Ñ+¨eÕ3ˆŽr   c                ó   € V P                   # r  )ro  r	  s   &rÓ   Útest_file_pathÚTestCasePlus.test_file_path  s   € à×#Ñ#Ð#r   c                ó,   € \        V P                  4      # r  )r;  ro  r	  s   &rÓ   Útest_file_path_strÚTestCasePlus.test_file_path_str  s   € ä�4×'Ñ'Ó(Ð(r   c                ó   € V P                   # r  )rr  r	  s   &rÓ   Útest_file_dirÚTestCasePlus.test_file_dir   ó   € à×"Ñ"Ð"r   c                ó,   € \        V P                  4      # r  )r;  rr  r	  s   &rÓ   Útest_file_dir_strÚTestCasePlus.test_file_dir_str$  ó   € ä�4×&Ñ&Ó'Ð'r   c                ó   € V P                   # r  )ru  r	  s   &rÓ   r«  ÚTestCasePlus.tests_dir(  s   € à�‰Ðr   c                ó,   € \        V P                  4      # r  )r;  ru  r	  s   &rÓ   Útests_dir_strÚTestCasePlus.tests_dir_str,  s   € ä�4—?‘?Ó#Ð#r   c                ó   € V P                   # r  )rv  r	  s   &rÓ   Úexamples_dirÚTestCasePlus.examples_dir0  s   € à×!Ñ!Ð!r   c                ó,   € \        V P                  4      # r  )r;  rv  r	  s   &rÓ   Úexamples_dir_strÚTestCasePlus.examples_dir_str4  s   € ä�4×%Ñ%Ó&Ð&r   c                ó   € V P                   # r  )rt  r	  s   &rÓ   Úrepo_root_dirÚTestCasePlus.repo_root_dir8  r„  r   c                ó,   € \        V P                  4      # r  )r;  rt  r	  s   &rÓ   Úrepo_root_dir_strÚTestCasePlus.repo_root_dir_str<  rˆ  r   c                ó   € V P                   # r  )rw  r	  s   &rÓ   Úsrc_dirÚTestCasePlus.src_dir@  s   € à�}‰}Ðr   c                ó,   € \        V P                  4      # r  )r;  rw  r	  s   &rÓ   Úsrc_dir_strÚTestCasePlus.src_dir_strD  s   € ä�4—=‘=Ó!Ð!r   c                ó4  € \         P                  P                  4       pV P                  V P                  .pRV P
                  9   d   VP                  V P                  4       VP                  VP                  RR4      4       RP                  V4      VR&   V# )a†  
Return a copy of the `os.environ` object that sets up `PYTHONPATH` correctly, depending on the test suite it's
invoked from. This is useful for invoking external programs from the test suite - e.g. distributed training.

It always inserts `./src` first, then `./tests` or `./examples` depending on the test suite type and finally
the preset `PYTHONPATH` if any (all full resolved paths).

z	/examplesÚ
PYTHONPATHrÁ  Ú:)
rÊ   rË   Úcopyr˜  rž  r†  Úappendr’  Úgetr¨  )r   ÚenvÚpathss   &  rÓ   Úget_envÚTestCasePlus.get_envH  sx   € ô �j‰j�o‰oÓˆØ×'Ñ'¨×)9Ñ)9Ð:ˆØ˜$×0Ñ0Ô0Ø�L‰L˜×.Ñ.Ô/Ø�‰�S—W‘W˜\¨2Ó.Ô/àŸH™H U›OˆˆLÑØˆ
r   Nc                óú  € Ve”   Vf   RpVf   Rp\        V4      P                  4       pVP                  R4      '       g   \        RV R24      hVRJ d/   VP	                  4       '       d   \
        P                  ! VRR7       VP                  RRR7       M!Vf   RpVf   Rp\        P                  ! 4       pVRJ d   V P                  P                  V4       V'       d   \        V4      P                  4       # T# )aà  
Args:
    tmp_dir (`string`, *optional*):
        if `None`:

           - a unique temporary path will be created
           - sets `before=True` if `before` is `None`
           - sets `after=True` if `after` is `None`
        else:

           - `tmp_dir` will be created
           - sets `before=True` if `before` is `None`
           - sets `after=False` if `after` is `None`
    before (`bool`, *optional*):
        If `True` and the `tmp_dir` already exists, make sure to empty it right away if `False` and the
        `tmp_dir` already exists, any existing files will remain there.
    after (`bool`, *optional*):
        If `True`, delete the `tmp_dir` at the end of the test if `False`, leave the `tmp_dir` and its contents
        intact at the end of the test.
    return_pathlib_obj (`bool`, *optional*):
        If `True` will return a pathlib.Path object

Returns:
    tmp_dir(`string`): either the same value as passed via *tmp_dir* or the path to the auto-selected tmp dir
TFz./zI`tmp_dir` can only be a relative path, i.e. `./some/path`, but received `Ú`©Úignore_errors©rq  Úexist_ok)r   rp  r  rÌ   Úexistsr„  ÚrmtreeÚmkdirrR  Úmkdtemprm  r¤  )r   rV  ÚbeforeÚafterÚreturn_pathlib_objr¤  s   &&&&& rÓ   Úget_auto_remove_tmp_dirÚ$TestCasePlus.get_auto_remove_tmp_dirZ  sï   € ð4 Òð
 Š~Ø�ØŠ}Ø�ô ˜“=×(Ñ(Ó*ˆDð ×%Ñ% d×+Ò+Ü Ø_Ð`gÐ_hÐhiÐjóð ð
 ˜‹~ $§+¡+§-¢-Ü—’˜g°TÕ:à�J‰J˜t¨dˆJÕ3ð Š~Ø�ØŠ}Ø�ô ×&Ò&Ó(ˆGà�D‹=à×"Ñ"×)Ñ)¨'Ô2ç*<Œt�G‹}×$Ñ$Ó&ÐIÀ'ÐIr   c                ó†  € \        R4      '       g   \        R4      h\        P                  ! RV R24      p\	        4       ;_uu_ 4       p\        W P                  4       R7       RRR4       \        XP                  P                  R4      R,          P                  RR	4      4      R
,          pV#   + '       g   i     LT; i)aU  
Runs the passed python one liner (just the code) and returns how much max cpu memory was used to run the
program.

Args:
    one_liner_str (`string`):
        a python one liner code that gets passed to `python -c`

Returns:
    max cpu memory bytes used to run the program. This value is likely to vary slightly from run to run.

Requirements:
    this helper needs `/usr/bin/time` to be installed (`apt install time`)

Example:

```
one_liner_str = 'from transformers import AutoModel; AutoModel.from_pretrained("google-t5/t5-large")'
max_rss = self.python_one_liner_max_rss(one_liner_str)
```
r‰  z:/usr/bin/time is required, install with `apt install time`z/usr/bin/time -f %M python -c 'Ú')r¦  Nr  r  rÁ  i   éþÿÿÿ)
r‡  rÌ   ÚshlexÚsplitrú  Úexecute_subprocess_asyncr¨  r×   rÿ  Úreplace)r   Úone_liner_strr†  ÚcsÚmax_rsss   &&   rÓ   Úpython_one_liner_max_rssÚ%TestCasePlus.python_one_liner_max_rss   sŒ   € ô. ˜/×*Ò*ÜÐYÓZÐZä�kŠkÐ;¸M¸?È!ÐLÓMˆÜ�\Œ\˜RÜ$ S¯l©l«nÕ=÷ ô �b—f‘f—l‘l 4Ó(¨Õ,×4Ñ4°ZÀÓDÓEÈÕLˆØˆ÷	 �\ús   Á	B0Â0C 	c                ór  € V P                    F  p\        P                  ! VR R7       K  	  . V n         \        4       '       du   \        P
                  ! 4        \        P
                  ! 4        \        \        P                  P                  4       4       F  pRV9   g   K  \        P                  V K  	  R# R# )Tr¬  Ú
ACCELERATEN)rm  r„  r±  r'   r‹   Ú_reset_staterŒ   r»  rÊ   rË   Úkeys)r   r¤  Úks   &  rÓ   ÚtearDownÚTestCasePlus.tearDownÁ  s}   € à×*Ô*ˆDÜ�MŠM˜$¨d×3ñ +à!#ˆÔÜ"×$Ò$Ü×)Ò)Ô+Ü×%Ò%Ô'ô œ"Ÿ*™*Ÿ/™/Ó+Ö,�Ø 1Ö$ÜŸ
™
 1šó -ñ %r   )rv  rt  rw  rr  ro  ru  rm  )NNNF)rô  r  r  r  r  ry  Úpropertyr|  r  r‚  r†  r«  rŒ  r�  r’  r•  r˜  r›  rž  r¨  r·  rÃ  rÊ  r  r  r   s   @rÓ   rh  rh  µ  s  ø‡ € ñLò\4ð( ñ$ó ð$ð ñ)ó ð)ð ñ#ó ð#ð ñ(ó ð(ð ñó ðð ñ$ó ð$ð ñ"ó ð"ð ñ'ó ð'ð ñ#ó ð#ð ñ(ó ð(ð ñó ðð ñ"ó ð"òô$DJòL÷B&ð &r   rh  c                 ó^   € \         P                  P                  \        P                  V 4      # )zÂ
this is a convenience wrapper, that allows this ::

@mockenv(RUN_SLOW=True, USE_TF=False) def test_something():
    run_slow = os.getenv("RUN_SLOW", False) use_tf = os.getenv("USE_TF", False)

)r   r   r¼  rÊ   rË   )r  s   ,rÓ   ÚmockenvrÎ  Ð  s   € ô �:‰:�?‰?œ2Ÿ:™: vÓ.Ð.r   c               /  ó¬  a"  € \         P                  oT;'       g    / pT ;'       g    . p \        VP                  4       4      \        V 4      ,          \        SP                  4       4      ,          pV Uu/ uF  q3SV,          bK  	  pp\	        V3R lV 4       4      p SP                  V4       V  Uu. uF  pSP                  VR4      NK  	   pRx € SP                  V4       V Uu. uF  pSP                  V4      NK  	   pR# u upi u upi u upi   SP                  T4       T Uu. uF  pSP                  T4      NK  	   pi u upi ; i5i)a5  
Temporarily updates the `os.environ` dictionary in-place. Similar to mockenv

The `os.environ` dictionary is updated in-place so that the modification is sure to work in all situations.

Args:
  remove: Environment variables to remove.
  update: Dictionary of environment variables and values to add/update.
c              3   ó8   <"  € T F  qS9  g   K  Vx € K  	  R # 5ir  rF  )Ú.0rÉ  r¦  s   & €rÓ   Ú	<genexpr>Ú"mockenv_context.<locals>.<genexpr>ð  s   øé € Ð?© 1¸3±,ŸQšQ«ùs   ƒ�
N)rÊ   rË   ÚsetrÈ  Ú	frozensetÚupdateÚpop)re  rÖ  ÚstompedrÉ  Úupdate_afterÚremove_afterr¦  s   *,    @rÓ   Úmockenv_contextrÛ  Ü  s  øé € ô �*‰*€CØ�\ˆ\�r€FØ�\ˆ\�r€Fô �6—;‘;“=Ó!¤C¨£KÕ/´3°s·x±x³z³?ÕB€Gá'.Ó/¡w !�s˜1•v’I¡w€LÐ/äÔ?©Ó?Ó?€Lð+Ø�
‰
�6ÔÙ#)Ó*¡6˜aˆ�‰��DÖ	¡6Ñ*Ûà�
‰
�<Ô Ù)Ó*™\˜ˆ�‰�Ž™\Ó*ùò 0ùò 	+ùò 	+øð 	�
‰
�<Ô Ù)Ó*™\˜ˆ�‰�Ž™\Ò*ùÒ*üs_   ƒ%E©AEÁ7D
Â	EÂ!D Â6DÃD ÃEÃ,DÄ	EÄD ÄEÄEÄ/EÅ	EÅEc                ó`   € RpV\         9  d!   V P                  VRRRR7       ^\         V&   R# R# )zæ
This function is to be called from `conftest.py` via `pytest_addoption` wrapper that has to be defined there.

It allows loading both `conftest.py` files at once without causing a failure due to adding the same `pytest`
option.

z--make-reportsÚstoreFzSgenerate report files. The value of this option is used as a prefix to report names)ÚactionrÐ   ÚhelpN)Úpytest_opt_registeredÚ	addoption)ÚparserÚoptions   & rÓ   Úpytest_addoption_sharedrä  	  sC   € ð €FØÔ*Ô*Ø×ÑØØØØfð	 	ô 	
ð )*Ô˜fÓ%ñ +r   c                óð  € ^ RI Hp \        V4      '       g   RpV P                  pVP	                  4       pVP
                  P                  pV P                  pRV 2p\        V4      P                  RRR7       R" Uu/ uF  pW‡ RV R2bK  	  p	p. p
V P                  P                  4        F1  pV F(  p\        VR4      '       g   K  V
P                  V4       K*  	  K3  	  V
'       dÔ   V
P                  R RR7       \        V	R,          R4      ;_uu_ 4       pRpVP!                  R4       \#        V
4       Fy  w  rüVP$                  V8  d*   VP!                  \        V
4      V,
           RV R24        M>VP!                  VP$                  R RVP&                  R RVP(                   R24       K{  	  RRR4       R pRVP
                  n        \        V	R,          R4      ;_uu_ 4       pV! W=4      V n        V P-                  4        RRR4       \        V	R	,          R4      ;_uu_ 4       pV! W=4      V n        V! V 4       RRR4       R VP
                  n        \        V	R
,          R4      ;_uu_ 4       pV! W=4      V n        V P-                  4        RRR4       \        V	R,          R4      ;_uu_ 4       pV! W=4      V n        V P/                  4        RRR4       \        V	R,          R4      ;_uu_ 4       pV! W=4      V n        V P1                  4        V P1                  4        RRR4       R!V n        \        V	R,          R4      ;_uu_ 4       pV! W=4      V n        V P3                  4        RRR4       \        V	R,          R4      ;_uu_ 4       pV! W=4      V n        V P5                  4        RRR4       W@n        W`n        WSP
                  n        R# u upi   + '       g   i     EL/; i  + '       g   i     ELî; i  + '       g   i     ELÉ; i  + '       g   i     EL‹; i  + '       g   i     EL^; i  + '       g   i     EL!; i  + '       g   i     Lì; i  + '       g   i     L¾; i)#ai  
Generate multiple reports at the end of test suite run - each report goes into a dedicated file in the current
directory. The report files are prefixed with the test suite name.

This function emulates --duration and -rA pytest arguments.

This function is to be called from `conftest.py` via `pytest_terminal_summary` wrapper that has to be defined
there.

Args:
- tr: `terminalreporter` passed from `conftest.py`
- id: unique id like `tests` or `examples` that will be incorporated into the final reports filenames - this is
  needed as some jobs have multiple runs of pytest, so we can't have them overwrite each other.

NB: this functions taps into a private _pytest API and while unlikely, it could break should pytest do internal
changes - also it calls default internal methods of terminalreporter which can be hijacked by various `pytest-`
plugins and interfere.

)Úcreate_terminal_writerr¡  zreports/Tr®  Ú	durationsÚerrorsÚfailures_longÚfailures_shortÚfailures_lineÚstatsÚsummary_shortÚwarningsrQ  z.txtÚdurationc                 ó   € V P                   # r  )rï  ©Úxs   &rÓ   r  Ú.pytest_terminal_summary_main.<locals>.<lambda>L	  s   €  §¢r   )rÏ   ÚreverseÚwgš™™™™™©?zslowest durations
z durations < z secs were omittedz02.2fzs z<8Ú r  Nc           	      ó‚  € V P                  R 4      pV'       g   R# V P                  RR4       V F‹  pV P                  V4      pV P                  RVRRR7       \        P                  ! RRVP
                  ^ \        P                  \        P                  ,          4      pV P                  P                  V4       K�  	  R# )	ÚfailedNÚ=zFAILURES SHORT STACKrz  T)ÚredÚboldz.*_ _ _ (_ ){10,}_ _ rÁ  )
Ú
getreportsÚ	write_sepÚ_getfailureheadlinerÂ  rÃ  ÚlongreprtextrÄ  ÚDOTALLÚ_twÚline)ÚtrÚreportsÚrepr  Úlongreprs   &    rÓ   Úsummary_failures_shortÚ<pytest_terminal_summary_main.<locals>.summary_failures_shortV	  s“   € à—-‘- Ó)ˆßÙØ
�‰�SÐ0Ô1ÛˆCØ×(Ñ(¨Ó-ˆCØ�L‰L˜˜c t°$ˆLÔ7ä—v’vÐ6¸¸C×<LÑ<LÈaÔQS×Q]ÑQ]Ô`b×`iÑ`iÕQiÓjˆHØ�F‰F�K‰K˜Ö!ó r   Úautor  ÚwPpsxXEf)	rç  rè  ré  rê  rë  Úpassesrì  rí  rî  )Ú_pytest.configræ  Úlenrß  Úget_terminal_writerrã  ÚtbstyleÚreportcharsr   r²  rì  ÚvaluesrÞ  r¤  ÚsortÚopenr  Ú	enumeraterï  ÚwhenÚnodeidr  Úsummary_failuresÚsummary_errorsÚsummary_warningsÚshort_test_summaryÚsummary_stats)r  Úidræ  rß  Úorig_writerÚorig_tbstyleÚorig_reportcharsr  rÉ  Úreport_filesÚdlistÚreplistr  ÚfÚdurations_minÚir  s   &&               rÓ   Úpytest_terminal_summary_mainr&  	  s—  € õ( 6äˆr�7Š7Øˆà�Y‰Y€FØ×,Ñ,Ó.€KØ—=‘=×(Ñ(€LØ—~‘~Ðà�R�Dˆ/€CÜˆƒI‡O�O˜D¨4€OÔ0ñ

óñ

ˆAð 	
ˆU�!�A�3�dÐÒñ

ð ð ð$ €EØ—8‘8—?‘?Ö$ˆÛˆCÜ�s˜J×'Ô'Ø—‘˜SÖ!ó ñ %÷ Ø�
‰
Ñ+°Tˆ
Ô:Ü�,˜{Õ+¨S×1Ô1°QØ ˆMØ�G‰GÐ)Ô*Ü# EÖ*‘�Ø—<‘< -Ô/Ø—G‘Gœs 5›z¨A�~Ð.¨m¸M¸?ÐJ\Ð]Ô^ÙØ—‘˜3Ÿ<™<¨Ð.¨b°·±¸"°¸Q¸s¿z¹z¸lÈ"ÐMÖNñ	 +÷ 2ò"ð( #€F‡M�MÔÜ	ˆl˜?Õ+¨S×	1Ô	1°QÙ'¨Ó2ˆŒØ
×ÑÔ÷ 
2ô
 
ˆlÐ+Õ,¨c×	2Ô	2°aÙ'¨Ó2ˆŒÙ˜rÔ"÷ 
3ð #€F‡M�MÔÜ	ˆl˜?Õ+¨S×	1Ô	1°QÙ'¨Ó2ˆŒØ
×ÑÔ÷ 
2ô 
ˆl˜8Õ$ c×	*Ô	*¨aÙ'¨Ó2ˆŒØ
×ÑÔ÷ 
+ô 
ˆl˜:Õ&¨×	,Ô	,°Ù'¨Ó2ˆŒØ
×ÑÔØ
×ÑÔ÷ 
-ð
  €B„Nô 
ˆl˜?Õ+¨S×	1Ô	1°QÙ'¨Ó2ˆŒØ
×ÑÔ÷ 
2ô 
ˆl˜7Õ# S×	)Ô	)¨QÙ'¨Ó2ˆŒØ
×ÑÔ÷ 
*ð
 „FØ%„NØ(‡M�MÖùòE÷2 2×1Ð1ú÷< 
2×	1Ð	1ú÷
 
3×	2Ð	2ú÷
 
2×	1Ð	1ú÷ 
+×	*Ð	*ú÷ 
-×	,Ð	,ú÷ 
2×	1ú÷ 
*×	)úsg   Á=OÄBOÇ+O.È,PÉ6PÊ7P*Ë8.P>ÍQÎQ%ÏO+	Ï.O?	ÐP	ÐP'	Ð*P;	Ð>Q	ÑQ"	Ñ%Q5	c                   ó&   a € ] tR tRt o R tRtV tR# )Ú
_RunOutputiŸ	  c                ó*   € Wn         W n        W0n        R # r  )Ú
returncoder  r  )r   r*  r  r  s   &&&&rÓ   r  Ú_RunOutput.__init__ 	  s   € Ø$ŒØŒØŽr   )r*  r  r  N)rô  r  r  r  r  r  r  r   s   @rÓ   r(  r(  Ÿ	  s   ø‡ € ÷ð r   r(  c              ƒ   óh   "  €  V P                  4       G Rj  x€L
 pV'       d   V! V4       K+  R#  L5i©TN)Úreadline)ÚstreamÚcallbackr  s   && rÓ   Ú_read_streamr1  ¦	  s)   é € Ø
Ø—_‘_Ó&×&ˆßÙ�TŽNáñ	 'ùs   ‚2—0˜2¤2c                ó$   € V ^8„  d   QhR\         /# ©r8  r¯  ©r(  )r<  s   "rÓ   r=  r=  ¯	  s   € ÷ &0ñ &0Ôblñ &0r   c              ƒ   ó†  aaaa	"  € V'       d   \        R RP                  V 4      4       \        P                  ! V ^ ,          .V R,          O5RVR\        P                  P
                  R\        P                  P
                  RV/ G Rj  x€L
 p. o. oRV3R llo	\        P                  ! \        P                  ! \        VP                  VV	3R	 l4      4      \        P                  ! \        VP                  VV	3R
 l4      4      .VR7      G Rj  x€L
  \        VP                  4       G Rj  x€L
 SS4      #  L¯ L) L5i)z

Running: rö  ºrÈ  NNÚstdinr  r  r¦  Nc                 ó–   <€ V P                  R 4      P                  4       p VP                  V 4       S'       g   \        W0VR7       R# R# )úutf-8)ÚfileN)ÚdecodeÚrstripr¤  Úprint)r  ÚsinkÚpipeÚlabelÚquiets   &&&&€rÓ   ÚteeÚ_stream_subprocess.<locals>.teeÇ	  s8   ø€ Ø�{‰{˜7Ó#×*Ñ*Ó,ˆØ�‰�DÔßÜ�% D×)ñ r   c                 ó8   <€ S! V S\         P                  R R7      # )zstdout:©r@  )r  r  )ÚlrË  rB  s   &€€rÓ   r  Ú$_stream_subprocess.<locals>.<lambda>Ð	  ó   ø€ ÁÀQÈÌSÏZÉZÐ_hÕAir   c                 ó8   <€ S! V S\         P                  R R7      # )zstderr:rE  )r  r  )rF  rÿ  rB  s   &€€rÓ   r  rG  Ñ	  rH  r   ©Útimeout)rÁ  )r=  r¨  ÚasyncioÚcreate_subprocess_execÚ
subprocessÚPIPEÚwaitÚcreate_taskr1  r  r  r(  )
r†  r¦  r7  rK  rA  ÚechoÚprÿ  rË  rB  s
   &&&&f& @@@rÓ   Ú_stream_subprocessrT  ¯	  s  ûé € ßÜˆm˜SŸX™X c›]Ô+ä×,Ò,ØˆA�ðà	ˆR�òð ðô ×!Ñ!×&Ñ&ð	ô
 ×!Ñ!×&Ñ&ðð ñ÷ 	€Að" €CØ
€C÷*ô �,Š,ä×Ò¤¨Q¯X©XÕ7iÓ jÓkÜ×Ò¤¨Q¯X©XÕ7iÓ jÓkð	
ð ô÷ ð ô ˜AŸF™F›H—n c¨3Ó/Ð/ñE	ñ6ñ %ùs7   †BEÂD;ÂBEÄD=ÄEÄ0D?Ä1EÄ=EÄ?Ec                ó$   € V ^8„  d   QhR\         /# r3  r4  )r<  s   "rÓ   r=  r=  Ø	  s   € ÷ ñ Ô`jñ r   c                 ó†  € \         P                  ! 4       pVP                  \        WW#WER 7      4      pRP	                  V 4      pVP
                  ^ 8”  d:   RP	                  VP                  4      p	\        RV RVP
                   RV	 24      hVP                  '       g"   VP                  '       g   \        RV R24      hV# ))r¦  r7  rK  rA  rR  rö  r  rº  z' failed with returncode z,

The combined stderr from workers follows:
z' produced no output.)	rL  Úget_event_loopÚrun_until_completerT  r¨  r*  r  ÚRuntimeErrorr  )
r†  r¦  r7  rK  rA  rR  ÚloopÚresultÚcmd_strr  s
   &&&&&&    rÓ   r¾  r¾  Ø	  s»   € Ü×!Ò!Ó#€DØ×$Ñ$Ü˜3¨uÈUÔ^ó€Fð �h‰h�s‹m€GØ×Ñ˜1ÔØ—‘˜6Ÿ=™=Ó)ˆÜØ�ˆyÐ1°&×2CÑ2CÐ1Dð E:Ø:@¸ðCó
ð 	
ð �=�=ˆ= §§ Ü˜Q˜w˜iÐ'<Ð=Ó>Ð>à€Mr   c                 ó¨   € \         P                  P                  RR4      p \        P                  ! RRV ^ \        P
                  4      p \        V 4      # )z¢
Returns an int value of worker's numerical id under `pytest-xdist`'s concurrent workers `pytest -n N` regime, or 0
if `-n 1` or `pytest-xdist` isn't being used.
ÚPYTEST_XDIST_WORKERÚgw0z^gwrÁ  )rÊ   rË   r¥  rÂ  rÃ  rÄ  r×   )Úworkers    rÓ   Úpytest_xdist_worker_idra  î	  s=   € ô
 �Z‰Z�^‰^Ð1°5Ó9€FÜ�VŠV�F˜B ¨¬2¯<©<Ó8€FÜˆv‹;Ðr   c                 óô   € ^ RI p V P                  V P                  V P                  4      ;_uu_ 4       pVP                  R4       VP	                  4       ^,          uuRRR4       #   + '       g   i     R# ; i)a	  
Returns a free port number that can be fed to `torch.distributed.launch`'s `--master_port` argument.

Binds to port 0 to let the OS assign an available port, avoiding collisions from hardcoded ports
and TCP TIME_WAIT issues between sequential subprocess launches.
N)rÁ  r   )ÚsocketÚAF_INETÚSOCK_STREAMÚbindÚgetsockname)rc  Úss     rÓ   Úget_torch_dist_unique_portri  ø	  sL   € ó à	�‰�v—~‘~ v×'9Ñ'9×	:Ô	:¸aØ	�‰ˆwŒØ�}‰}‹˜qÕ!÷ 
;×	:×	:Ó	:ús   ³(A&Á&A7	c           	     ó  a€ ^ RI p\        V \        4      '       d   V  Uu. uF  p\        VS4      NK  	  up# \        V \        4      '       d3   \        ;QJ d    . V3R lV  4       F  NK  	  5# ! V3R lV  4       4      # \        WP
                  4      '       d   \        V P                  4       4      # \        V \        4      '       d:   V P                  4        UUu/ uF  w  rE\        VS4      \        VS4      bK  	  upp# \        V \        \        VP                  34      '       g   V f   V # \        4       '       d;   \        V \        P                  4      '       d   \        V P                  4       S4      # \        V \        4      '       d   \!        V S4      # \        WP"                  VP$                  VP&                  34      '       d   \        V P)                  4       S4      # \+        R\-        V 4       24      hu upi u uppi )z€
Simplifies an object by rounding float numbers, and downcasting tensors/numpy arrays to get simple equality test
within tests.
Nc              3   ó<   <"  € T F  p\        VS4      x € K  	  R # 5ir  )Únested_simplify)rÑ  ÚitemÚdecimalss   & €rÓ   rÒ  Ú"nested_simplify.<locals>.<genexpr>
  s   øé € ÐEÁ¸”_ T¨8×4Ð4Ãùs   ƒzNot supported: )Únumpyrð  r»  rl  ÚtupleÚndarrayÚtolistr	   Úitemsr;  r×   Úint64ru   r¬  ÚTensorrþ  ÚroundÚint32Úfloat32Úfloat16rm  rv  ró  )Úobjrn  Únprm  rÉ  Úvs   &f    rÓ   rl  rl  
  s|  ø€ ó
 ä�#”t×ÒÙ<?Ó@¹C°D”  hÖ/¹CÑ@Ð@Ü�#”u×ÒßŒuÔEÁÓE�uÐEˆuÔEÁÓEÓEÐEÜ	�CŸ™×	$Ò	$Ü˜sŸz™z›|Ó,Ð,Ü	�Cœ×	!Ò	!ØWZ×W`ÑW`ÔWbÔcÑWbÉtÈq”  8Ó,¬o¸aÀÓ.JÒJÑWbÒcÐcÜ	�Cœ#œs B§H¡HÐ-×	.Ò	.°#²+Øˆ
Ü	×	Ò	¤*¨S´%·,±,×"?Ò"?Ü˜sŸz™z›|¨XÓ6Ð6Ü	�Cœ×	Ò	Ü�S˜(Ó#Ð#Ü	�CŸ(™( B§J¡J°·
±
Ð;×	<Ò	<Ü˜sŸx™x›z¨8Ó4Ð4ä˜/¬$¨s«)¨Ð5Ó6Ð6ùò! Aùó ds    G?Ã"Hc                 óü  € \        V 4      ;_uu_ 4       pVP                  4       p\        V4      ^8X  d   V^ ,          R8X  g   Q hMš\        V4      ^8¼  g   Q hV^ ,          P                  4       R8X  g   Q hV^R  FC  p\        V^,          4      \        V^,          P	                  4       4      ,
          pV^8X  d   KC  Q h	  VR,          P                  4       R8X  g   Q hRRR4       R#   + '       g   i     R# ; i)rÈ  ú{}Ú{Ú}Nr¾  )r  Ú	readlinesr  ÚstripÚlstrip)Ú	file_pathr#  Úlinesr  Úleft_indents   &    rÓ   Ú"check_json_file_has_correct_formatrˆ  !
  sÇ   € Ü	ˆi�Œ˜AØ—‘“ˆÜˆu‹:˜Œ?à˜•8˜tÔ#Ð#Ñ#ô �u“: ”?Ð"�?à˜•8—>‘>Ó# sÔ*Ð*Ð*Ø˜a ›�Ü! %¨¥(›m¬c°%¸µ(·/±/Ó2CÓ.DÕD�Ø" aÖ'Ð'Ð'ñ $ð ˜•9—?‘?Ó$¨Ô+Ð+Ð+÷ 
��Šús   ”B%C*Â>"C*Ã*C;	c                 ó`   € \        V \        P                  P                  4      '       d   V # W 3# r  )rð  ÚcollectionsÚabcr   rñ  s   &rÓ   Ú	to_2tuplerŒ  2
  s%   € Ü�!”[—_‘_×-Ñ-×.Ò.ØˆØˆ6€Mr   c                   ó   € ] tR tRtRtR# )ÚSubprocessCallExceptioni9
  rF  N)rô  r  r  r  r  rF  r   rÓ   rŽ  rŽ  9
  s   † Ûr   rŽ  c                ó:   € V ^8„  d   QhR\         \        ,          /# )r8  Úcommand)r»  r;  )r<  s   "rÓ   r=  r=  =
  s   € ÷ ñ œœc�ñ r   c                óZ  €  \         P                  ! V \         P                  R7      pV'       d&   \        VR4      '       d   VP	                  R4      pV# R#   \         P
                   d?   p\        RRP                  T 4       RTP                  P	                  4        24      ThRp?ii ; i)z¡
Runs `command` with `subprocess.check_output` and will potentially return the `stdout`. Will also properly capture
if an error occurred while running `command`
)r  r;  r9  z	Command `rö  z$` failed with the following error:

N)	rN  Úcheck_outputÚSTDOUTrÞ  r;  ÚCalledProcessErrorrŽ  r¨  Úoutput)r�  Úreturn_stdoutr•  r	  s   &&  rÓ   Úrun_commandr—  =
  s›   € ð
	Ü×(Ò(¨¼×9JÑ9JÔKˆßÜ�v˜x×(Ò(ØŸ™ wÓ/�ØˆMñ øô ×(Ñ(ô Ü%Ø˜Ÿ™ Ó)Ð*Ð*PÐQR×QYÑQY×Q`ÑQ`ÓQbÐPcÐdó
àð	ûðús   ‚-A °$A ÁB*Á,9B%Â%B*c                   ój   a € ] tR tRt o RtR tV 3R lR ltV 3R lR lt]V 3R lR	 l4       t	R
t
V tR# )ÚRequestCounteriN
  an  
Helper class that will count all requests made online.

Might not be robust if urllib3 changes its logging format but should be good enough for us.

Usage:
```py
with RequestCounter() as counter:
    _ = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert")
assert counter["GET"] == 0
assert counter["HEAD"] == 1
assert counter.total_calls == 1
```
c                óp  a € \        \        4      S n        \        P                  ! 4       S n        . S n        V 3R  lp^ RIp\        P                  ! VP                  P                  RV! VP                  P                  P                  4      R7      S n        S P                  P                  4       S n        S # )c                 ó   <a € V V3R  lpV# )c                  óp   <€ SP                   P                  \        P                  ! 4       4       S! V / VB # r  )Ú_extra_infor¤  Ú	threadingÚ	get_ident)r  r  Úfuncr   s   *,€€rÓ   ÚwrapÚHRequestCounter.__enter__.<locals>.patched_with_thread_info.<locals>.wrapd
  s0   ø€ Ø× Ñ ×'Ñ'¬	×(;Ò(;Ó(=Ô>Ù˜TÐ, VÑ,Ð,r   rF  )r   r¡  r   s   f €rÓ   Úpatched_with_thread_infoÚ:RequestCounter.__enter__.<locals>.patched_with_thread_infoc
  s   ù€ ö-ð ˆKr   NÚdebug)Úside_effect)r   r×   Ú_counterrž  rŸ  Ú
_thread_idr�  Úurllib3r   ÚobjectÚconnectionpoolÚlogr¥  ÚpatcherÚstartr   )r   r£  r©  s   f  rÓ   r
  ÚRequestCounter.__enter__^
  sˆ   ø€ Ü#¤CÓ(ˆŒÜ#×-Ò-Ó/ˆŒØˆÔõ	ó 	ä—|’|Ø×"Ñ"×&Ñ&¨Ñ=UÐV]×VlÑVl×VpÑVp×VvÑVvÓ=wô
ˆŒð —L‘L×&Ñ&Ó(ˆŒ	Øˆr   c                ó   <€ V ^8„  d   QhRR/# ©r8  r¯  NrF  )r<  r!  s   "€rÓ   r=  ÚRequestCounter.__annotate__r
  s   ø€ ÷ ñ ¨4ñ r   c                ó"  € \        V P                  P                  4      \        V P                  4      8X  g   Q h\	        V P                  V P                  P                  4       F�  w  r4W0P
                  8w  d   K  VP                  R,          R8X  d   K1  VP                  ^ ,          VP                  R,          ,          pR F+  pWe9   g   K  V P                  V;;,          ^,          uu&    K‹  	  K�  	  V P                  P                  4        R# )r8  i3  r6  Nr»  )	ÚHEADÚGETÚPOSTÚPUTÚDELETEÚCONNECTÚOPTIONSÚTRACEÚPATCH)
r  r   Úcall_args_listr�  Úzipr¨  r  r§  r­  Ústop)r   r  r  Ú	thread_idÚcallr¬  Úmethods   &*,    rÓ   r  ÚRequestCounter.__exit__r
  sÁ   € Ü�4—9‘9×+Ñ+Ó,´°D×4DÑ4DÓ0EÔEÐEÐEÜ" 4×#3Ñ#3°T·Y±Y×5MÑ5MÖN‰OˆIØŸO™OÔ+Ùà�y‰y˜�} Ô#ÙØ—)‘)˜A•, §¡¨2¥Õ.ˆCÛj�Ø–=Ø—M‘M &×)¨QÕ.Ó)Úó kñ  Oð 	�‰×ÑÖr   c                ó&   <€ V ^8„  d   QhRS[ RS[/# )r8  rÏ   r¯  ©r;  r×   )r<  r!  s   "€rÓ   r=  r²  �
  s   ø€ ÷ "ñ "™sð "¡sñ "r   c                ó(   € V P                   V,          # r  )r§  )r   rÏ   s   &&rÓ   Ú__getitem__ÚRequestCounter.__getitem__�
  s   € Ø�}‰}˜SÕ!Ð!r   c                ó    <€ V ^8„  d   QhRS[ /# r3  r¸  )r<  r!  s   "€rÓ   r=  r²  …
  s   ø€ ÷ +ñ +™Sñ +r   c                óH   € \        V P                  P                  4       4      # r  )Úsumr§  r  r	  s   &rÓ   Útotal_callsÚRequestCounter.total_calls„
  s   € ä�4—=‘=×'Ñ'Ó)Ó*Ð*r   )r§  r�  r¨  r   r­  N)rô  r  r  r  r  r
  r  rÇ  rÌ  rÌ  r  r  r   s   @rÓ   r™  r™  N
  s7   ø‡ € ñò÷(ð ÷"ð "ð ÷+ó ö+r   r™  c                óX   € V ^8„  d   QhR\         R\        R,          R\        R,          /# )r8  Úmax_attemptsÚwait_before_retryNÚdescription)r×   rþ  r;  )r<  s   "rÓ   r=  r=  ‰
  s,   € ÷ &ñ &œ3ð &´u¸tµ|ð &ÔY\Ð_cÕYcñ &r   c                ó   a a€ V V3R lpV# )aw  
To decorate flaky tests. They will be retried on failures.

Please note that our push tests use `pytest-rerunfailures`, which prompts the CI to rerun certain types of
failed tests. More specifically, if the test exception contains any substring in `FLAKY_TEST_FAILURE_PATTERNS`
(in `.circleci/create_circleci_config.py`), it will be rerun. If you find a recurrent pattern of failures,
expand `FLAKY_TEST_FAILURE_PATTERNS` in our CI configuration instead of using `is_flaky`.

Args:
    max_attempts (`int`, *optional*, defaults to 5):
        The maximum number of attempts to retry the flaky test.
    wait_before_retry (`float`, *optional*):
        If provided, will wait that number of seconds before retrying the test.
    description (`str`, *optional*):
        A string to describe the situation (what / where / why is flaky, link to GH issue/PR comments, errors,
        etc.)
c                 óŠ   <a € \         P                  ! S 4      VV V3R  l4       p\        P                  ! \        R4      ! V4      # )c            
      óî   <€ ^pVS8  d
    S! V / VB # S! V / VB #   \          dN   p\        P                  RT RT RS R24       Se   \        P                  ! S4       T^,          p Rp?Kk  Rp?ii ; i)rÈ  zTest failed with z at try rQ  ré  N)rv  r6  ÚerrorÚtimeÚsleep)r  r  Úretry_countrÿ  rÏ  Útest_func_refrÐ  s   *,  €€€rÓ   r  Ú,is_flaky.<locals>.decorator.<locals>.wrapper�
  sŠ   ø€ àˆKà Ô,ð%Ù(¨$Ð9°&Ñ9Ð9ñ ! $Ð1¨&Ñ1Ð1øô !ô %Ü—L‘LÐ#4°S°E¸À+ÀÈaÐP\È~Ð]^Ð!_Ô`Ø(Ò4ÜŸ
š
Ð#4Ô5Ø 1Õ$–Kûð	%ús   Œ œA4§AA/Á/A4ztest is flaky)r  r   ræ   rü   Ú_run_flaky_tests)rÙ  r  rÏ  rÐ  s   f €€rÓ   rD  Úis_flaky.<locals>.decoratorœ
  s9   ù€ Ü	�Š˜Ó	'ö	2ó 
(ð	2ô ×"Ò"Ô#3°_ÔEÀgÓNÐNr   rF  )rÏ  rÐ  rÑ  rD  s   ff& rÓ   Úis_flakyrÝ  ‰
  s   ù€ ö&Oð& Ðr   c                ó>   € V ^8„  d   QhR\         R\        R,          /# )r8  rÏ  rÐ  N©r×   rþ  )r<  s   "rÓ   r=  r=  ²
  s   € ÷ ñ œCð ¼À½ñ r   c                ó\   € ^RI Hp T! T T;'       g    ^ VRJ\        P                  3R7      # )a	  
To decorate tests that download from the Hub. They can fail due to a
variety of network issues such as timeouts, connection resets, etc.

Uses exponential backoff starting from `wait_before_retry`.

Args:
    max_attempts (`int`, *optional*, defaults to 5):
        The maximum number of attempts to retry the flaky test.
    wait_before_retry (`float`, *optional*, defaults to 2):
        If provided, the initial delay in seconds before the first retry.
        Subsequent retries use exponential backoff with jitter.
)ÚretryN)Úmax_retriesÚinitial_delayÚjitterÚ
exceptions)Úutils.genericrá  ÚhttpxÚ	HTTPError)rÏ  rÐ  rá  s   && rÓ   Ú	hub_retryré  ²
  s4   € õ %áØ Ø'×,Ð,¨1Ø ¨Ð,Ü—O‘OÐ%ô	ð r   c                óp   € \        4       '       d&   ^ RIpVP                  P                  ^4      ! V 4      # V # )aŠ  
Decorator marking a test with order(1). When pytest-order plugin is installed, tests marked with this decorator
are guaranteed to run first.

This is especially useful in some test settings like on a Gaudi instance where a Gaudi device can only be used by a
single process at a time. So we make sure all tests that run in a subprocess are launched first, to avoid device
allocation conflicts.
N)rb   rç   rè   Úorderrë   s   & rÓ   Ú	run_firstrì  Ê
  s0   € ô !×"Ò"Ûà�{‰{× Ñ  Ô# IÓ.Ð.àÐr   c                óh  € Vf*   \        \        P                  P                  RR4      4      pRp\        P
                  ! V4      pVP                  ^4      pVP                  ^4      pVP                  W#R7       VP                  WWs3R7      pVP                  4         VP                  VR7      p	VP                  4        VP                  VR7       X	R,          e   V P                  V	R,           4       R# R#   \         d,   p
TP                  4        T P                  T
4        Rp
?
LkRp
?
ii ; i)a–  
To run a test in a subprocess. In particular, this can avoid (GPU) memory issue.

Args:
    test_case (`unittest.TestCase`):
        The test that will run `target_func`.
    target_func (`Callable`):
        The function implementing the actual testing logic.
    inputs (`dict`, *optional*, defaults to `None`):
        The inputs that will be passed to `target_func` through an (input) queue.
    timeout (`int`, *optional*, defaults to `None`):
        The timeout (in seconds) that will be passed to the input and output queues. If not specified, the env.
        variable `PYTEST_TIMEOUT` will be checked. If still `None`, its value will be set to `600`.
NÚPYTEST_TIMEOUTÚ600ÚspawnrJ  )Útargetr  rÕ  )r×   rÊ   rË   r¥  ÚmultiprocessingÚget_contextÚQueueÚJoinableQueueÚputÚProcessr®  Ú	task_donerv  Ú	terminateÚfailr¨  )rì   Útarget_funcÚinputsrK  Ústart_methohdÚctxÚinput_queueÚoutput_queueÚprocessÚresultsr	  s   &&&&       rÓ   Úrun_test_in_subprocessr  Ü
  s  € ð ‚Ü”b—j‘j—n‘nÐ%5°uÓ=Ó>ˆà€MÜ
×
%Ò
% mÓ
4€Cà—)‘)˜A“,€KØ×$Ñ$ QÓ'€Lð ‡O�O�F€OÔ,à�k‰k ÀÐ3WˆkÓX€GØ‡M�M„OðØ×"Ñ"¨7Ð"Ó3ˆØ×ÑÔ ð ‡L�L˜€LÔ!àˆwÕÒ#Ø�‰˜' 'Õ*Ð+Ö-ñ $øô ô Ø×ÑÔØ�‰�q×Ñûðús   Â"C; Ã;D1Ä!D,Ä,D1c                óR   a a€ ^ RI o\        P                  ! S 4      V V3R l4       pV# )zã
To decorate a test to run in a subprocess using the `subprocess` module. This could avoid potential GPU memory
issues (GPU OOM or a test that causes many subsequential failing with `CUDA error: device-side assert triggered`).
Nc                  óÈ  <€ \         P                  ! R R4      R8X  d   S! V / VB  R# RP                  \         P                  P	                  R4      P                  R4      RR 4      p \        P                  ! \         P                  4      pRVR &   RVR&   RV9   dÎ   \        VR,          P                  P                  4      p\        V4       Fc  w  rVWaR,          P                  9   g   K  VP                  R4      R	,          pRP                  SP                  R
,           .V,           4      WE&   Ke  	  \        P                   RR.V,           pV Uu. uF  qfR8w  g   K  VNK  	  ppM\        P                   RRV .p\        P                   ! WCRRR7       R# u upi   \        P"                   Ed+   pTP$                  P'                  4       pTP                  R4      p	RT	^ ,          9   dÉ   Rp
T	R	,           F¦  pTP)                  R4      '       d8   T\+        R4      R p
RP                  T
P                  R4      R	,          4      p
KQ  TP)                  R4      '       d!   TP-                  R4      '       d
   RT9   d    M"\+        T
4      ^ 8”  g   Kš  T
RT 2,          p
K¨  	  RT
,           p
T
.T	,           p	RP                  T	4      pSP/                  TRR7      hRp?ii ; i)Ú_INSIDE_SUB_PROCESSNÚ1rö  ÚPYTEST_CURRENT_TESTÚtrueÚCIÚpytestconfigú::r6  Ú__file__z-mrç   z--no-summaryT)r¦  ÚcheckÚcapture_outputr  z= test session starts =rÁ  zFAILED ú - rù  z failed in z(subprocess) F)Úpytracer¾  )rÊ   Úgetenvr¨  rË   r¥  r½  r£  Údeepcopyr»  Úinvocation_paramsr  r  Ú__globals__r  Ú
executablerN  Úrunr”  r  r;  r  r  r§  rú  )r  r  Útestr¦  r�  Úidxrò  r	  Úexception_messager†  Útextr  r   rç   s   *,          €€rÓ   r  Ú*run_test_using_subprocess.<locals>.wrapper  s~  ø€ ä�9Š9Ð*¨DÓ1°SÔ8Ù�$Ð!˜&Ô!à—8‘8œBŸJ™JŸN™NÐ+@ÓA×GÑGÈÓLÈSÈbÐQÓRˆDð(DÜ—m’m¤B§J¡JÓ/�Ø-0�Ð)Ñ*ð #��D‘	ð " VÔ+Ü" 6¨.Õ#9×#KÑ#K×#PÑ#PÓQ�GÜ"+¨GÖ"4™˜Ø ~Õ 6× ;Ñ ;Ö;Ø#'§:¡:¨dÓ#3°BÕ#7˜DØ+/¯9©9¸×9IÑ9IÈ*Õ9UÐ8VÐ5XÐ[_Õ5_Ó+`˜G›Lñ #5ô #&§.¡.Ð!1°D¸(ÐCÀgÕM�GÙ*1ÓI©' Q¸.Ñ5HŸq˜q©'�GÐI�Gô #&§.¡.Ð!1°D¸(ÀtÀfÐN�Gä—’˜w°tÈD×Qùò Jøô ×0Ñ0õ DØ$%§H¡H§O¡OÓ$5Ð!Ø)×/Ñ/°Ó5�ð -°°aµÔ8Ø�DØ % b§	 	˜ØŸ?™?¨9×5Ò5Ø#'¬¨I«Ð(8Ð#9˜DØ#%§7¡7¨4¯:©:°eÓ+<¸RÕ+@Ó#AšDØ!Ÿ_™_¨S×1Ò1°d·m±mÀC×6HÒ6HÈ]Ð^bÔMbÙ!Ü  ›Y¨ž]Ø  b¨¨ KÕ/šDñ !*ð +¨TÕ1�DØ!˜F U�N�EØ$(§I¡I¨eÓ$4Ð!Ø—k‘kÐ"3¸U�kÓCÐCûð%DúsL   Á)A?F! Ã-A(F! ÅFÅ"FÅ(2F! ÆF! Æ!K!Æ7B+KÉ#KÉ:KÊAKËK!)rç   r  r   )r   r  rç   s   f @rÓ   Úrun_test_using_subprocessr    s-   ù€ ó
 ä‡_‚_�TÓõ-Dó ð-Dð^ €Nr   c                ó~  € Rp\         P                  ! W \         P                  R7      pRp\        V4       Fh  w  rVRV9   d"   RV9  d   \         P                  ! RRV4      W5&   RV9   g
   R	V9   g   K=  \         P
                  ! R
V4      '       g   K\  V'       g   Kf  Rp M	  RpV'       g   RP                  V4      pV# )aš  Prepare a docstring or a `.md` file to be run by doctest.

The argument `string` would be the whole file content if it is a `.md` file. For a python file, it would be one of
its docstring. In each case, it may contain multiple python code examples. If `skip_cuda_tests` is `True` and a
cuda stuff is detective (with a heuristic), this method will return an empty string so no doctest will be run for
`string`.
z&(```(?:python|py)\s*\n\s*>>> )(.*?```))ÚflagsFzload_dataset(z# doctest: +IGNORE_RESULTz(>>> .*load_dataset\(.*)z\1 # doctest: +IGNORE_RESULTz>>>z...zcuda|to\(0\)|device=0TrÁ  )rÂ  r½  r   r  rÃ  Úsearchr¨  )ÚstringÚskip_cuda_testsÚcodeblock_patternÚ
codeblocksÚis_cuda_foundr%  Ú	codeblockÚmodified_strings   &&      rÓ   Úpreprocess_stringr(  K  s©   € ð BÐÜ—’Ð+¼2¿9¹9ÔE€JØ€MÜ! *Ö-‰ˆØ˜iÔ'Ð,GÈyÔ,XÜŸFšFÐ#>Ð@_ÐajÓkˆJ‰Mà�iÔ 5¨IÖ#5Ü—	’	Ð2°I×>Ô>ß‘à ˆMÙñ .ð €OßØŸ'™' *Ó-ˆàÐr   c                   óà   a a€ ] tR tRt oRt]P                  ! R]P                  ]P                  ,          4      t	]
P                  P                  RR4      R8H  tR
V 3R lltV3R ltR	tVtV ;t# )ÚHfDocTestParserih  aª  
Overwrites the DocTestParser from doctest to properly parse the codeblocks that are formatted with black. This
means that there are no extra lines at the end of our snippets. The `# doctest: +IGNORE_RESULT` marker is also
added anywhere a `load_dataset` call is made as a print would otherwise fail the corresponding line.

Tests involving cuda are skipped base on a naive pattern that should be updated if it is not enough.
aó  
        # Source consists of a PS1 line followed by zero or more PS2 lines.
        (?P<source>
            (?:^(?P<indent> [ ]*) >>>    .*)    # PS1 line
            (?:\n           [ ]*  \.\.\. .*)*)  # PS2 lines
        \n?
        # Want consists of any non-blank lines that do not start with PS1.
        (?P<want> (?:(?![ ]*$)    # Not a blank line
             (?![ ]*>>>)          # Not a line starting with PS1
             # !!!!!!!!!!! HF Specific !!!!!!!!!!!
             (?:(?!```).)*        # Match any character except '`' until a '```' is found (this is specific to HF because black removes the last line)
             # !!!!!!!!!!! HF Specific !!!!!!!!!!!
             (?:\n|$)  # Match a new line or end of string
          )*)
        ÚSKIP_CUDA_DOCTESTÚ0r  c                óL   <€ \        WP                  4      p\        SV `  W4      # )z‡
Overwrites the `parse` method to incorporate a skip for CUDA tests, and remove logs and dataset prints before
calling `super().parse`
)r(  r"  r&  rê  )r   r!  rT  r(  s   &&&€rÓ   rê  ÚHfDocTestParser.parse�  s$   ø€ ô
 # 6×+?Ñ+?Ó@ˆÜ‰w‰}˜VÓ*Ð*r   c                ó&   <€ V ^8„  d   Qh/ S[ ;R&   # )r8  r"  )Úbool)r<  r!  s   "€rÓ   r=  ÚHfDocTestParser.__annotate__h  s   ø‡ ‚ ñD ÑKòE r   rF  )z<string>)rô  r  r  r  r  rÂ  ÚcompilerÄ  ÚVERBOSEÚ_EXAMPLE_RErÊ   rË   r¥  r"  rê  Ú__annotate_func__r  r  r,  r-  s   @@rÓ   r*  r*  h  sZ   ù‡ € ñð —*’*ð ð �\‰\˜BŸJ™JÕ&ó€Kð& ŸJ™JŸN™NÐ+>ÀÓDÈÑK€O÷+÷K … r   r*  c                   ó6   a € ] tR tRt o RtV 3R lR ltRtV tR# )ÚHfDoctestModulei–  zw
Overwrites the `DoctestModule` of the pytest package to make sure the HFDocTestParser is used when discovering
tests.
c                ó0   <€ V ^8„  d   QhRS[ S[,          /# r3  )r   r—   )r<  r!  s   "€rÓ   r=  ÚHfDoctestModule.__annotate__œ  s   ø€ ÷ C_ñ C_™¡+Õ.ñ C_r   c              #  ó¢  "  €  ! R  R\         P                  4      pV P                  P                  R8X  da   V P                  P
                  P                  V P                  V P                  P                  R4      V P                  P                  R7      pMF \        V P                  V P                  P                  V P                  P                  R4      R7      pV! \        4       R7      p\        V 4      p\        R	V\!        4       \#        V P                  4      R
7      pVP%                  XVP&                  4       F;  pVP(                  '       g   K  \*        P,                  ! WP                  WVR7      x € K=  	  R#   \         dB    T P                  P                  R4      '       d   \        RT P                  ,          4        Líh i ; i5i)c                   óN   a a€ ] tR tRt oRtV 3R ltV3R lV 3R lltRtVtV ;t	# )Ú7HfDoctestModule.collect.<locals>.MockAwareDocTestFinderi�  z£A hackish doctest finder that overrides stdlib internals to fix a stdlib bug.

https://github.com/pytest-dev/pytest/issues/3456 https://bugs.python.org/issue25532
c                óº   <€ \        V\        4      '       d   \        VRV4      p\        VR4      '       d   \        P
                  ! V4      p\        SV `  VV4      # )zóDoctest code does not take into account `@property`, this
is a hackish way to fix it. https://bugs.python.org/issue17446

Wrapped Doctests will need to be unwrapped so the correct line number is returned. This will be
reported upstream. #8796
ÚfgetÚ__wrapped__)rð  rÌ  r  rÞ  r¢  Úunwrapr&  Ú_find_lineno)r   r{  Úsource_linesr(  s   &&&€rÓ   rA  ÚDHfDoctestModule.collect.<locals>.MockAwareDocTestFinder._find_lineno£  sU   ø€ ô ˜c¤8×,Ò,Ü! # v¨sÓ3�Cä˜3 ×.Ò.ä!Ÿ.š.¨Ó-�Cô ‘wÑ+ØØ óð r   c                ó   <€ V ^8„  d   QhRR/# r±  rF  )r<  r!  s   "€rÓ   r=  ÚDHfDoctestModule.collect.<locals>.MockAwareDocTestFinder.__annotate__·  s   ø€ ÷ ñ ÐTXñ r   c                ó°   <€ \        V4      '       d   R # \        4       ;_uu_ 4        \        SV `  WW4WVV4       R R R 4       R #   + '       g   i     R # ; ir  )r’   r“   r&  Ú_find)	r   r¡  r{  rT  r÷  rB  ÚglobsÚseenr(  s	   &&&&&&&&€rÓ   rG  Ú=HfDoctestModule.collect.<locals>.MockAwareDocTestFinder._find·  s<   ø€ Ü˜c—?’?ÙÜ-×/Õ/ä‘G‘MØ D°,Àtô÷ 0×/×/Ò/ús   §AÁA	rF  )
rô  r  r  r  r  rA  rG  r  r  r,  r-  s   @@rÓ   ÚMockAwareDocTestFinderr<  �  s   ù‡ € ñõ
÷(÷ ó r   rK  zconftest.pyÚ
importmode)Úrootpath)ÚrootÚmodeÚdoctest_ignore_import_errorszunable to import module %r)râ  F)ÚverboseÚoptionflagsÚcheckerÚcontinue_on_failure)rT  ÚrunnerÚdtestN)ÚdoctestÚDocTestFinderr¤  rT  rß  ÚpluginmanagerÚ_importconftestÚ	getoptionrM  r–   rê   r  r•   r*  r”   r‘   r�   r�   rÊ  rô  rk  r—   Úfrom_parent)r   rK  r÷  ÚfinderrR  rU  r  s   &      rÓ   ÚcollectÚHfDoctestModule.collectœ  sT  é € ô!	¤W×%:Ñ%:ô !	ðF �9‰9�>‰>˜]Ô*Ø—[‘[×.Ñ.×>Ñ>Ø—	‘	Ø—‘×%Ñ% lÓ3ØŸ™×-Ñ-ð ?ó ‰Fð
Ü$Ø—I‘IØŸ™×-Ñ-ØŸ™×.Ñ.¨|Ó<ô�ñ (¬Ó/@ÔAˆä% dÓ+ˆÜØØ#Ü “NÜ 8¸¿¹Ó Eô	
ˆð —K‘K ¨¯©Ö8ˆDØ�}�}Š}Ü!×-Ò-¨d¿¹È6Ô^Ô^ó 9øô! ô Ø—;‘;×'Ñ'Ð(F×GÒGÜÐ5¸¿	¹	ÕAÖBàð	üs8   ‚BGÂAF  ÃA4GÅ*GÆ +GÆ,GÇGÇ
GÇGrF  N)rô  r  r  r  r  r^  r  r  r   s   @rÓ   r7  r7  –  s   ø‡ € ñ÷
C_ö C_r   r7  c                óR   € V ^8„  d   QhR\         R\        \         \        3,          /# )r8  ÚdeviceÚdispatch_table)r;  r¼  r   )r<  s   "rÓ   r=  r=  â  s#   € ÷ ñ ¤cð ¼4ÄÄXÀÕ;Nñ r   c                 ó´   € W9  d1   \        VR ,          4      '       g
   VR ,          # VR ,          ! V/ VB # W,          p\        V4      '       g   V# V! V/ VB # rÚ   )r  )ra  rb  r  r  Úfns   &&*, rÓ   Ú_device_agnostic_dispatchre  â  s`   € ØÔ#Ü˜ yÕ1×2Ò2Ø! )Õ,Ð,à˜iÖ(¨$Ð9°&Ñ9Ð9à	Õ	€Bô �B�<Š<Øˆ	áˆtÐ�vÑÐr   rÐ   c                  ó   € ^ # ©r   rF  rF  r   rÓ   r  r    s   € ‘qr   c                  ó   € ^# )rÈ  rF  rF  r   rÓ   r  r    s   € ™1r   c                  ó   € ^ # rg  rF  rF  r   rÓ   r  r  %  s   € ©qr   Úxlac                ó0   € V ^8„  d   QhR\         R\        /# )r8  ra  ÚseedrÅ  )r<  s   "rÓ   r=  r=  Q  s   € ÷ Hñ H¤ð H¬3ñ Hr   c                 ó$   € \        V \        V4      # r  )re  ÚBACKEND_MANUAL_SEED)ra  rl  s   &&rÓ   Úbackend_manual_seedro  Q  s   € Ü$ VÔ-@À$ÓGÐGr   c                ó$   € V ^8„  d   QhR\         /# ©r8  ra  r:  )r<  s   "rÓ   r=  r=  U  ó   € ÷ Bñ B¤ñ Br   c                 ó"   € \        V \        4      # r  )re  ÚBACKEND_EMPTY_CACHE©ra  s   &rÓ   Úbackend_empty_cacherv  U  ó   € Ü$ VÔ-@ÓAÐAr   c                ó$   € V ^8„  d   QhR\         /# rq  r:  )r<  s   "rÓ   r=  r=  Y  s   € ÷ Cñ C¤ñ Cr   c                 ó"   € \        V \        4      # r  )re  ÚBACKEND_DEVICE_COUNTru  s   &rÓ   r³  r³  Y  s   € Ü$ VÔ-AÓBÐBr   c                ó$   € V ^8„  d   QhR\         /# rq  r:  )r<  s   "rÓ   r=  r=  ]  s   € ÷ Qñ Q¬sñ Qr   c                 ó"   € \        V \        4      # r  )re  Ú"BACKEND_RESET_MAX_MEMORY_ALLOCATEDru  s   &rÓ   Ú"backend_reset_max_memory_allocatedr~  ]  s   € Ü$ VÔ-OÓPÐPr   c                ó$   € V ^8„  d   QhR\         /# rq  r:  )r<  s   "rÓ   r=  r=  a  s   € ÷ Nñ N¬Cñ Nr   c                 ó"   € \        V \        4      # r  )re  ÚBACKEND_RESET_PEAK_MEMORY_STATSru  s   &rÓ   Úbackend_reset_peak_memory_statsr‚  a  s   € Ü$ VÔ-LÓMÐMr   c                ó$   € V ^8„  d   QhR\         /# rq  r:  )r<  s   "rÓ   r=  r=  e  s   € ÷ Kñ K¬ñ Kr   c                 ó"   € \        V \        4      # r  )re  ÚBACKEND_MAX_MEMORY_ALLOCATEDru  s   &rÓ   Úbackend_max_memory_allocatedr†  e  s   € Ü$ VÔ-IÓJÐJr   c                ó$   € V ^8„  d   QhR\         /# rq  r:  )r<  s   "rÓ   r=  r=  i  s   € ÷ Gñ G¤Sñ Gr   c                 ó"   € \        V \        4      # r  )re  ÚBACKEND_MEMORY_ALLOCATEDru  s   &rÓ   Úbackend_memory_allocatedrŠ  i  s   € Ü$ VÔ-EÓFÐFr   c                ó$   € V ^8„  d   QhR\         /# rq  r:  )r<  s   "rÓ   r=  r=  m  rr  r   c                 ó"   € \        V \        4      # r  )re  ÚBACKEND_SYNCHRONIZEru  s   &rÓ   Úbackend_synchronizerŽ  m  rw  r   c                ó$   € V ^8„  d   QhR\         /# rq  r:  )r<  s   "rÓ   r=  r=  q  s   € ÷ Oñ O¬Sñ Or   c                 ó"   € \        V \        4      # r  )re  Ú BACKEND_TORCH_ACCELERATOR_MODULEru  s   &rÓ   Ú backend_torch_accelerator_moduler’  q  s   € Ü$ VÔ-MÓNÐNr   ÚTRANSFORMERS_TEST_DEVICE_SPECzISpecified path to device spec file is not a file or not found. Received 'ú.pyz;Provided device spec file was not a Python file! Received 'z.Device spec file did not contain `DEVICE_NAME`zBMismatch between environment variable `TRANSFORMERS_TEST_DEVICE` 'z' and device found in spec 'z'
zNEither unset `TRANSFORMERS_TEST_DEVICE` or ensure it matches device spec name.c                óR   € V ^8„  d   QhR\         \        \        3,          R\        /# )r8  Údevice_fn_dictÚattribute_name)r¼  r;  r   )r<  s   "rÓ   r=  r=  —  s$   € ÷ 
	ñ 
	´T¼#¼x¸-Õ5Hð 
	ÔZ]ñ 
	r   c                 ó¦   €  \        \        V4      pW \        &   R#   \         d*   pR T 9  d   \        RT R\         R24      Th Rp?R# Rp?ii ; i)rÐ   r«  z` not found in 'z)' and no default fallback function found.N)r  Údevice_spec_moduler´  ÚAttributeErrorÚdevice_spec_path)r–  r—  Úspec_fnr	  s   &&  rÓ   Úupdate_mapping_from_specr�  —  s`   € ð	ä!Ô"4°nÓE�Ø/6œ|Ó,øÜ!ô à NÔ2Ü(Ø˜NÐ+Ð+;Ô<LÐ;MÐMvÐwóàðõ 3ûðús   ‚ œA§AÁAÚMANUAL_SEED_FNÚEMPTY_CACHE_FNÚDEVICE_COUNT_FNc                 ó   € . p. p\        V4       Uu0 uF  qDP                  kK  	  pp\        V  Uu. uF  qfV9   g   K  VNK  	  up4      p\        V4       FG  pVP                  \        J g   K  VP                  V 9  g   K,  VP                  VP                  4       KI  	  V  F  pW…9  g   K  VP                  V4       K  	  V'       g	   V'       dr   R .p	V'       d   V	P                  RV 24       V'       d   V	P                  RV 24       V'       d   V	P                  RV 24       \        RP                  V	4      4      hR# u upi u upi )z(Pipeline output does not match Hub spec!zMatching keys: z*Missing required keys in pipeline output: z2Keys in pipeline output that are not in Hub spec: r  N)r   rT  ÚsortedrÐ   r   r¤  rÍ   r¨  )
r•  Úhub_specÚmissing_keysÚunexpected_keysÚfieldÚall_field_namesrÏ   Úmatching_keysÚ
output_keyrÕ  s
   &&        rÓ   Ú#compare_pipeline_output_to_hub_specrª  ©  s  € Ø€LØ€OÜ/5°hÔ/?Ó@Ñ/? e—z”zÑ/?€OÐ@Ü©6ÓL©6 C¸OÑ5KŸC˜C©6ÑLÓM€Mô ˜Ö!ˆØ�=‰=œGÕ#¨¯
©
¸&Ö(@Ø×Ñ §
¡
Ö+ñ "ó
 ˆ
ØÖ,Ø×"Ñ" :Ö.ñ ÷ —Ø;Ð<ˆßØ�L‰L˜?¨=¨/Ð:Ô;ßØ�L‰LÐEÀlÀ^ÐTÔUßØ�L‰LÐMÈoÐM^Ð_Ô`Ü�t—y‘y Ó'Ó(Ð(ñ 'ùò AùÚLs   ’E±E¾Ec                ó$   € V ^8„  d   QhR\         /# rq  r:  )r<  s   "rÓ   r=  r=  Å  s   € ÷ ñ ”Cñ r   c                 ó’   € V'       d   \         P                  ! 4        \        V 4       \        P                  P                  4        R # r  )Úgcr^  rv  r¬  ÚcompilerÚreset)ra  Ú
gc_collects   &&rÓ   Úcleanupr±  Ä  s&   € çÜ
�
Š
ŒÜ˜ÔÜ	‡N�N×ÑÖr   c                ó$   € V ^8„  d   QhR\         /# r3  )ÚDeviceProperties)r<  s   "rÓ   r=  r=  Ó  s   € ÷ &ñ &Ô/ñ &r   c                 óÖ  € \         '       g   \        '       dU   ^ RIp V P                  P	                  4       '       d1   V P                  P                  4       w  r\        '       d   RW3# RW3# \        '       d\   ^ RIp V P                  P	                  4       '       d8   V P                  P                  4       R,          pRpW4,          ^ ,	          pRVR3# \        '       d   R# \        RR3# )z$
Get environment device properties.
NÚrocmr­  Úarchitecturel       ürÆ   )rÇ   NN)
ÚIS_CUDA_SYSTEMÚIS_ROCM_SYSTEMr¬  r­  r  r   ÚIS_XPU_SYSTEMrÆ   ÚIS_NPU_SYSTEMr´  )r¬  r"  r#  ÚarchÚgen_maskÚgens         rÓ   r  r  Ò  sº   € ÷
 ƒ~Ÿ›Ûà�:‰:×"Ñ"×$Ò$Ø Ÿ:™:×;Ñ;Ó=‰LˆEß‹~Ø Ð-Ð-à Ð-Ð-ßƒ}Ûà�9‰9×!Ñ!×#Ò#à—9‘9×2Ñ2Ó4°^ÕDˆDØ)ˆHØ•? rÕ)ˆCØ˜3 Ð%Ð%ßƒ}à"Ð"Ü˜$ Ð%Ð%r   c                ó>   € V ^8„  d   QhR\         R,          R\        /# )r8  Ú
propertiesNr¯  )ÚPackedDevicePropertiesr³  )r<  s   "rÓ   r=  r=  ï  s!   € ÷ %ñ %Ü&¨Õ-ð%äñ%r   c                óz   € V f   \        4       # V w  rVf   RRrCM\        V\        4      '       d   TRrCMVw  r4WV3# )z…
Unpack a `PackedDeviceProperties` tuple into consistently formatted `DeviceProperties` tuple. If properties is None, it is fetched.
N)r  rð  r×   )r¿  Údevice_typeÚmajor_minorr"  r#  s   &    rÓ   Úunpack_device_propertiesrÄ  ï  sN   € ð ÒÜ$Ó&Ð&Ø)Ñ€KØÒØ˜T‰uÜ	�K¤×	%Ò	%Ø" D‰uà"‰ˆØ˜uÐ$Ð$r   c                   ó˜   a € ] tR tRt o V 3R lR ltV 3R lR lt]V 3R lR l4       t]V 3R lR	 l4       tRV 3R lR llt	R t
RtV tR
# )ÚExpectationsi  c                ó    <€ V ^8„  d   QhRS[ /# r3  )r   )r<  r!  s   "€rÓ   r=  ÚExpectations.__annotate__  s   ø€ ÷ >ñ >¡ñ >r   c                ó4   € V P                  \        4       4      # )a%  
Find best matching expectation based on environment device properties. We look at device_type, major and minor
versions of the drivers. Expectations are stored as a dictionary with keys of the form
(device_type, (major, minor)). If the major and minor versions are not provided, we use None.
)Úfind_expectationr  r	  s   &rÓ   Úget_expectationÚExpectations.get_expectation  s   € ð ×$Ñ$Ô%:Ó%<Ó=Ð=r   c                óF   <€ V ^8„  d   QhRS[ S[S[S[3,          ,          /# r3  )r»  rq  r³  r   )r<  r!  s   "€rÓ   r=  rÈ  
  s'   ø€ ÷ Pñ P™$™uÑ%5±sÐ%:Õ;Õ<ñ Pr   c                ó€   € V P                   P                  4        UUu. uF  w  r\        V4      V3NK  	  upp# u uppi r  )Údatart  rÄ  )r   rÉ  r}  s   &  rÓ   ÚunpackedÚExpectations.unpacked
  s4   € Ø=A¿Y¹Y¿_¹_Ô=NÔOÑ=N±T°QÔ)¨!Ó,¨aÓ0Ñ=NÒOÐOùÓOs   ž:c                ó&   <€ V ^8„  d   QhRS[ RS[/# )r8  Úexpectation_keyr¯  )rÀ  r0  )r<  r!  s   "€rÓ   r=  rÈ    s   ø€ ÷ 7ñ 7Ñ$:ð 7¹tñ 7r   c                ój   € \         ;QJ d    R V  4       F  '       d   K   R# 	  R# ! R V  4       4      # )aê  
This function returns True if the expectation_key is the Default expectation (None, None).
When an Expectation dict contains a Default value, it is generally because the test existed before Expectations.
When we modify a test to use Expectations for a specific hardware, we don't want to affect the tests on other
hardwares. Thus we set the previous value as the Default expectation with key (None, None) and add a value for
the specific hardware with key (hardware_type, (major, minor)).
c              3   ó(   "  € T F  qR J x € K
  	  R # 5ir  rF  )rÑ  rS  s   & rÓ   rÒ  Ú*Expectations.is_default.<locals>.<genexpr>  s   é € Ð6¡o ˜•9£oùs   ‚FT)r„  )rÓ  s   &rÓ   Ú
is_defaultÚExpectations.is_default  s-   € ÷ ‹sÑ6¡oÓ6�sŒsÐ6ŠsÐ6ˆsÑ6¡oÓ6Ó6Ð6r   c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[/# )r8  r¿  Úotherr¯  )r³  rþ  )r<  r!  s   "€rÓ   r=  rÈ    s$   ø€ ÷ ñ Ñ*ð Ñ3Cð Éñ r   c                óì   € V w  r#pVw  rVp^ pVe7   W%8X  d1   V^,          pVe#   W68X  d   V^,          pVe   WG8X  d
   V^,          pMVR9   d
   VR9   d   Rp\         P                  V4      '       d   RpV# )a¾  
Returns score indicating how similar two instances of the `Properties` tuple are.
Rules are as follows:
    * Matching `type` adds one point, semi-matching `type` adds 0.1 point (e.g. cuda and rocm).
    * If types match, matching `major` adds another point, and then matching `minor` adds another.
    * The Default expectation (None, None) is worth 0.5 point, which is better than semi-matching. More on this
    in the `is_default` function.
gš™™™™™¹?g      à?)r­  rµ  )rÆ  r×  )	r¿  rÚ  rÂ  r"  r#  Úother_device_typeÚother_majorÚother_minorÚscores	   &&       rÓ   rß  ÚExpectations.score  s�   € ð %/Ñ!ˆ˜EØ6;Ñ3Ð¨àˆàÒ" {Ô'GØ�Q�JˆEØÒ  UÔ%9Ø˜•
�ØÒ$¨Ô)=Ø˜Q•J�EøàÐ,Ô,Ð1BÐFVÔ1VØˆEô ×"Ñ" 5×)Ò)ØˆEàˆr   Nc                ó&   <€ V ^8„  d   QhRS[ RS[/# )r8  r¿  r¯  )r³  r   )r<  r!  s   "€rÓ   r=  rÈ  7  s   ø€ ÷ ñ Ñ+;ð ÑUXñ r   c                óœ   a€ \        V P                  4       V3R lR7      w  r#\        P                  SV4      ^ 8X  d   \	        RS 24      hV# )zì
Find best matching expectation based on provided device properties. We score each expectation, and to
distinguish between expectations with the same score, we use the major and minor version numbers, prioritizing
most recent versions.
c                 óÎ   <€ \         P                  SV ^ ,          4      V ^ ,          ^,          e   V ^ ,          ^,          MRV ^ ,          ^,          e   V ^ ,          ^,          3# R3# )r   r¾  )rÆ  rß  )rò  r¿  s   &€rÓ   r  Ú/Expectations.find_expectation.<locals>.<lambda>?  sX   ø€ Ü×"Ñ" :¨q°­tÓ4Ø˜Q�4 �7Ò.��!•�Q–°BØ˜Q�4 �7Ò.��!•�Q•ñð 57ñr   )rÏ   z"No matching expectation found for )ÚmaxrÐ  rÆ  rß  rÌ   )r   r¿  Ú
result_keyr[  s   &f  rÓ   rÊ  ÚExpectations.find_expectation7  sO   ø€ ô  #Ø�M‰M‹Oôô 
Ñˆô ×Ñ˜j¨*Ó5¸Ô:ÜÐAÀ*ÀÐNÓOÐOàˆr   c                ó   € V P                    # r  )rÏ  r	  s   &rÓ   r  ÚExpectations.__repr__K  s   € Ø—)‘)�Ðr   rF  ))NNN)rô  r  r  r  rË  rÐ  Ústaticmethodr×  rß  rÊ  r  r  r  r   s   @rÓ   rÆ  rÆ    sW   ø‡ € ÷>ð >÷Pð Pð ÷7ó ð7ð ÷ó ð÷<ò ÷(ð r   rÆ  c                 óº   a€ \         P                  P                  RR4      p V P                  4       R9   p V '       d   ^ RIpVP
                  oV3R lpW!n        R# R# )av  
Patch `torch.compile` to always use `fullgraph=True`.

This is useful when some `torch.compile` tests are running with `fullgraph=False` and we want to be able to run
them with `fullgraph=True` in some occasion (without introducing new tests) to make sure there is no graph break.

After PR #40137, `CompileConfig.fullgraph` is `False` by default, this patch is necessary.
ÚTORCH_COMPILE_FORCE_FULLGRAPHrÁ  Nc                  ó   <€ R VR&   S! V / VB # )TÚ	fullgraphrF  )r  r  Úorig_methods   *,€rÓ   ÚpatchedÚ0patch_torch_compile_force_graph.<locals>.patcheda  s   ø€ à"&ˆF�;ÑÙ Ð/¨Ñ/Ð/r   )Úyesr	  ÚonÚtÚyr  )rÊ   rË   r¥  rÉ  r¬  r2  )Úforce_fullgraphr¬  rð  rï  s      @rÓ   Úpatch_torch_compile_force_graphr÷  O  sN   ø€ ô —j‘j—n‘nÐ%DÀbÓI€OØ%×+Ñ+Ó-Ð1UÑU€OçÛà—m‘mˆõ	0ð
  Žñ r   c                 ó8  € \         P                  P                  RR4      P                  R4      ^ ,          p V P                  R4      w  rp\        P
                  ! 4       pYreRRRr˜p\        V4       F¨  p
VP                  V
P                  4      '       g   K&  RV
P                  P                  9   g   KC  \        V
P                  P                  R,          V4      '       g   Kr  T
pV
P                  P                  R,          pV
P                  p\        Wƒ4      p	 M	  Ve   VP                  pRp. pRp\        V4       Fµ  p
VP                  V
P                  4      '       dL   RV
P                  P                  9   d1   \        V
P                  P                  R,          V4      '       d   RpM+V
P                  P                  P                   R	8X  d   T
pRp MV'       g   K¤  VP#                  V
4       K·  	  Rp\        V4       FP  p\$        P&                  ! VVP                  VP                  P(                  VP                  P*                  4      pTpKR  	  XpVP                  P                  R
,          p\,        P.                  ! 4       pRp\        V4       F"  p
VP0                  V
P2                  9   g   K   T
pK$  	  \         P4                  P7                  VP                  4      pVP                  pXp^ RIHp \=        V4      ;_uu_ 4       pVP?                  4       pV! V4      pRPA                  VPC                  V^,
          4      PD                  4      pRRR4       \=        V4      ;_uu_ 4       pVP?                  4       pV! V4      pRPA                  VPC                  V^,
          4      PD                  4      pRRR4       RV  RR RV RV RX 2
pV RR RV RV RX 2	pV VVVV	VVVVVVV3#   + '       g   i     L¤; i  + '       g   i     LR; i)zt
Collect some information about the current test.

For example, test full name, line number, stack, traceback, etc.
r  rÁ  rö  r  Nr   FTrð  rï  )ÚSourcer  ztest:

ú

z

test context: r¢  z

caller context: úP--------------------------------------------------------------------------------)#rÊ   rË   r¥  r½  r¢  r£  Úreversedr  ÚfunctionÚframeÚf_localsrÞ  Úfilenamer  ÚlinenoÚf_codeÚco_namer¤  ÚtypesÚTracebackTypeÚf_lastiÚf_linenoÚ	tracebackÚextract_stackrô  r  r¤  ÚrelpathÚ_pytest._code.sourcerù  r  Úreadr¨  Úgetstatementr†  ) Úfull_test_nameÚ	test_fileÚ
test_classÚ	test_nameÚstack_from_inspectÚactual_test_fileÚ_actual_test_classÚ
test_frameÚtest_objÚtest_methodrþ  Úline_numberÚframe_of_patched_objÚcaptured_framesÚ
to_captureÚtb_nextÚ
frame_infor]  Útest_tracebackÚorigin_method_being_patchedr£  Úcaller_frameÚcaller_pathÚcaller_linenoÚtest_linenorù  Úfprh  ÚsourceÚtest_code_contextÚcaller_code_contextÚ	test_infos                                    rÓ   Ú_get_test_infor)  i  s²  € ô —Z‘Z—^‘^Ð$9¸2Ó>×DÑDÀSÓIÈ!ÕL€NØ'5×';Ñ';¸DÓ'AÑ$€I˜9ô !Ÿš›Ðð ,5Ð(Ø(,¨d°D˜+€JÜÐ,Ö-ˆð
 × Ñ  §¡×0Ô0Ø˜%Ÿ+™+×.Ñ.Ö.Ü˜Ÿ™×,Ñ,¨VÕ4°i×@Ô@ð ˆJà—{‘{×+Ñ+¨FÕ3ˆHð  %Ÿ~™~Ðä! (Ó6ˆKÙñ% .ð( ÒØ ×'Ñ'ˆð  Ðà€OØ€Jô Ð,Ö-ˆà× Ñ  §¡×0Ò0Ø˜%Ÿ+™+×.Ñ.Ô.Ü˜Ÿ™×,Ñ,¨VÕ4°i×@Ò@à‰Jà�[‰[×Ñ×'Ñ'¨9Ô4Ø#(Ð ØˆJÙß‰:Ø×"Ñ" 5Ö)ñ .ð €GÜ˜Ö/ˆ
Ü× Ò  ¨*×*:Ñ*:¸J×<LÑ<L×<TÑ<TÐV`×VfÑVf×VoÑVoÓpˆØŠñ 0ð €Nà"6×"<Ñ"<×"EÑ"EÀmÕ"TÐô ×#Ò#Ó%€Eà€Lä˜%–ˆØ&×/Ñ/°5·:±:Ö=Ø ŠLñ !ô —'‘'—/‘/ ,×"7Ñ"7Ó8€KØ ×'Ñ'€Mà€Kõ ,ä	Ð×	Ô	 2Ø�G‰G‹IˆÙ˜“ˆØ ŸI™I f×&9Ñ&9¸+È½/Ó&J×&PÑ&PÓQÐ÷ 
 ô 
ˆk×	Ô	˜bØ�G‰G‹IˆÙ˜“ˆØ"Ÿi™i¨×(;Ñ(;¸MÈAÕ<MÓ(N×(TÑ(TÓUÐ÷ 
ð
 ˜NÐ+¨4°¨zÐ9KÐL\ÐK]Ð]^Ð_jÐ^kÐkoð  qBð  pCð  D€IØ�+˜T ( Ð+?À¸}ÈAÈmÈ_Ð\`ÐatÐ`uÐv€Ið 	ØØØØØØØØØØØðð ÷ 
 ×	ú÷ 
×	ús   ÌA
O6Í5A
P	Ï6P	Ð	P	c                óÚ  € R p\        V 4      \        V P                  4       4      ,
          pV P                  RV,          R4      p  \        P                  ! V RR7      p\        VP                  \        P                  4      '       g   Q hVP                  pV'       dŸ   R. R/ RR	R
R	/pVP                   F#  pV! V4      pVR,          P                  V4       K%  	  VP                   FO  pVP                  f   V! VP                  4      VR
&   K(  V! VP                  4      pWuR,          VP                  &   KQ  	  V#  R	#   \        \        3 d   p	\        RT	 24        R	p	?	R	# R	p	?	ii ; i)zÔ
Analyze the positional and keyword arguments in a call expression.

This will extract the expressions of the positional and kwyword arguments, and associate them to the positions and
the keyword argument names.
c                ó\  € \        V \        P                  4      '       d   V P                  # \        V \        P                  4      '       d   \        P
                  ! V 4      # \        V \        P                  4      '       d   \        V P                  4      # \        P
                  ! V 4      # )z,Extract the name/expression from an AST node)	rð  ÚastÚNamer  Ú	AttributeÚunparseÚConstantÚreprrÑ   )Únodes   &rÓ   Úget_argument_nameÚ._get_call_arguments.<locals>.get_argument_nameæ  sk   € ä�dœCŸH™H×%Ò%Ø—7‘7ˆNÜ˜œcŸm™m×,Ò,Ü—;’;˜tÓ$Ð$Ü˜œcŸl™l×+Ò+Ü˜Ÿ
™
Ó#Ð#ä—;’;˜tÓ$Ð$r   rö  rÁ  Úeval)rO  Úpositional_argsÚkeyword_argsÚstarargsNr  zError parsing: )r  r„  r¿  r,  rê  rð  ÚbodyÚCallr  r¤  ÚkeywordsÚargrÑ   ÚSyntaxErrorrš  r=  )
Úcode_contextr3  ÚindentÚtreeÚ	call_noder[  r<  Úarg_nameÚkeywordr	  s
   &         rÓ   Ú_get_call_argumentsrD  Þ  sN  € ò	%ô �Ó¤ \×%8Ñ%8Ó%:Ó!;Õ;€FØ×'Ñ'¨¨f­°bÓ9€Lð!%ä�yŠy˜¨FÔ3ˆä˜$Ÿ)™)¤S§X¡X×.Ò.Ð.Ð.Ø—I‘Iˆ	çà! 2Ø Ø˜DØ˜$ð	ˆFð !—~”~�Ù,¨SÓ1�ØÐ(Õ)×0Ñ0°Ö:ñ &ð
 %×-Ô-�Ø—;‘;Ò&á'8¸¿¹Ó'G�F˜8Ó$ñ  1°·±Ó?�HØ:B˜>Õ*¨7¯;©;Ó7ñ .ð ˆMð/ ñ8 øô œÐ(ô %Ü� ˜sÐ#×$Ð$áûð%ús    ÁAE  ÂBE  Å E*ÅE%Å%E*c                ó   € V  RV 2p\         P                  P                  \         P                  P	                  RR4      R4      p\        VR4      ;_uu_ 4       pVP                  V RR R24       RRR4       V#   + '       g   i     T# ; i)zgCombine the information about the test and the call information to a patched function/method within it.rú  Ú#_PATCHED_TESTING_METHODS_OUTPUT_DIRrÁ  úcaptured_info.txtÚaNzx========================================================================================================================)rÊ   r¤  r¨  rË   r¥  r  r  )r(  ÚinforS  r$  s   &&  rÓ   Ú_prepare_debugging_inforJ    sz   € ð ˆ[˜˜T˜FÐ#€DÜ
�‰�‰”R—Z‘Z—^‘^Ð$IÈ2ÓNÐPcÓd€Aä	ˆa��Œ˜Ø
�‰�D�6˜˜i˜[¨Ð-Ô.÷ 
ð €K÷ 
Žð €Kús   ÁA<Á<B	c                ó  € . pRp\        V P                  R4      '       d   V P                  P                  pMb\        V P                  R4      '       dG   \        V P                  P                  R4      '       d!   V P                  P                  P                  p\        V R4      '       dú   V'       dò   V F:  pVw  pw  rxp	VP	                  R\        V4       R2RVP                  RR	R
^í/4       K<  	  \        V P                  R4      '       d&   V P                  P                  P                  4        Mp\        V P                  R4      '       dU   \        V P                  P                  R4      '       d/   V P                  P                  P                  P                  4        \        P                  p
V
\        V 4      n        V
! V .VO5/ VB  \        W P                  4      pVP                  P                  \!        V4      ,          pV^ ,          R,          pV^ ,          R,          pV Uu. uF  qÿR,          NK  	  ppRR R2P#                  V4      pV'       d‰   \        V4       RR R\%        V4       RR RV RR R\%        V4       RR RRP#                  R V 4       4       RR RR 2p\        V4      ! V4      pVP&                  Vn        VP(                  Vn        TpVP                  =VP+                  V4      hu upi )a  Used to report a test that has failures captured and handled by patched functions/methods (without re-raise).

The patched functions/methods refer to the `patched` defined in `_patch_with_call_info`, which is applied to
`torch.testing.assert_close` and `unittest.case.TestCase.assertEqual`.

The objective is to avoid a failure being silence after being processed.

If there is any failure that is not handled by the patched functions/methods, we add custom error message for them
along with the usual pytest failure report.
Nrè  r[  Ú_outcomeÚmessagerú  ró  r:  ztest_modeling_vit.pyr  Ú	exceptionr  rI  z
Handled Failures: (z handled):
z
Unhandled Failures: (z unhandled):
ú, c              3   óp   "  € T F,  qR ,           RVR,           VR,           RVR,           2x € K.  	  R# 5i)ró  ú: rM  r:  r¢  r  NrF  )rÑ  rI  s   & rÓ   rÒ  Ú$_patched_tearDown.<locals>.<genexpr>s  s7   é € Ð
oÑYnÐQU�6�lˆ^˜2˜d 9�oÐ.¨t°F­|¨n¸A¸dÀ6½l¸^ÕLÓYnùs   ‚46zž
Note: This failure occurred after other failures analyzed by the patched assertion methods.
To see the full details, temporarily disable assertion patching.
zP================================================================================rû  )rÞ  rL  rè  r[  r¤  r;  rô  ÚclearÚ_patched_tearDownÚorig_tearDownró  rÊ  r  Ú_testMethodNameÚ__func__Úcaptured_failuresr  r¨  r  Ú	__cause__Ú__context__Úwith_traceback)r   r  r  Úregular_failures_inforè  Úerror_entryÚtest_instanceÚexc_typeÚexc_objÚexc_tbrU  r  rX  Úcaptured_exceptionsÚcaptured_tracebackrò  Úcapturued_infoÚcapturued_info_strÚenhanced_messageÚenhanced_exceptions   &*,                 rÓ   rT  rT  &  sè  € ð& Ðà€FÜˆt�}‰}˜h×'Ò'Ø—‘×%Ñ%‰Ü	�—‘ ×	)Ò	)¬g°d·m±m×6JÑ6JÈH×.UÒ.UØ—‘×%Ñ%×,Ñ,ˆäˆt�Z× Ò §VÛ!ˆKØ9DÑ6ˆMÑ6˜H¨và!×(Ñ(à¤# g£, ¨tÐ4Ø˜H×-Ñ-ØÐ2Ø˜Cð	öñ "ô �4—=‘= (×+Ò+Ø�M‰M× Ñ ×&Ñ&Õ(Ü�T—]‘] H×-Ò-´'¸$¿-¹-×:NÑ:NÐPX×2YÒ2YØ�M‰M× Ñ ×'Ñ'×-Ñ-Ô/ô &×3Ñ3€MØ'„DˆƒJÔñ �$Ð(˜Ò( Ò(ô ˜$× 4Ñ 4Ó5€KØ#×,Ñ,×>Ñ>¼rÀ+»ÕOÐð ,¨AÕ.¨{Õ;ÐØ*¨1Õ-¨kÕ:Ðá):Ó;Ñ): A˜—i�iÑ):€NÐ;Ø ˜z¨Ð.×3Ñ3°NÓCÐ÷ Ü #Ð$7Ó 8Ð9ð :à	€
ð Ü˜Ó'Ð(ð )Ø	€
ð ØÐ ð à	€
ð ÜÐ/Ó0Ð1ð 2Ø	€
ð Ø‡�Ñ
oÑYnÓ
oÓoÐ pð qà	€
ð ð 
€
ðÐô$ "Ð"5Ô6Ð7GÓHÐØ':×'DÑ'DÐÔ$Ø)<×)HÑ)HÐÔ&ð 1Ðð 	×ÑÐ.à
×
,Ñ
,Ð-?Ó
@Ð@ùòC <s   È0Lc                óp   aaa€ \        W4      o\        S4      '       g   R# VVV3R lp\        WV4       R# )z×
Patch a callerable `attr_name` of a module or class `module_or_class`.

This will allow us to collect the call information, e.g. the argument names and values, also the literal expressions
passed as the arguments.
Nc                  óÖ  <€ \         P                  P                  R R4      '       g	   S! V / VB #  S! V / VB  R#   \         Ed¢   pTp\	        4       w  pppppp	p
pppppT RR RSP
                   RSP                   2p\        T4      pS! SYTS4      p\        TT4      p\         P                  ! R4      R8X  d   TP                  T
4      hRRR	TR
T
RT/p\        TP                  RR4      f   / TP                  n        \        T4      TP                  P                  9  d#   . TP                  P                  \        T4      &   TP                  P                  \        T4      ,          P                  T4       \!        \#        T4      P$                  R4      '       g;   \#        T4      P$                  pT\&        n        \&        \#        T4      n         Rp?R#  Rp?R# Rp?ii ; i)r  rÁ  rú  z

patched method: ré  r
  r	  r[  rø  rN  r  rI  rX  NrU  rû  )rÊ   rË   r¥  ÚAssertionErrorr)  r  rô  rD  rJ  r  r[  r  rW  rX  r  r¤  rÞ  ró  rÊ  rT  rU  )r  r  r	  Úcaptured_exceptionr  r  r#  r  r  r  r  r&  r!  r"  r'  r(  Úcall_argument_expressionsrI  Úcaptured_failurerU  Ú_parse_call_info_funcrï  Útarget_argss   *,                  €€€rÓ   rð  Ú&_patch_with_call_info.<locals>.patched“  sà  ø€ ä�z‰z�~‰~Ð3°R×8Ò8Ù Ð/¨Ñ/Ð/ð;	<Ù˜Ð( Ô(øÜõ 9	<Ø!"Ðô Ó ñØØØØØØØØ!ØØØ#Øà$˜+ T¨(¨Ð3GÈ×H^ÑH^ÐG_Ð_`Ðal×auÑauÐ`vÐwˆIÜ(;Ð<OÓ(PÐ%ñ )¨°dÐD]Ð_jÓkˆDÜ*¨9°dÓ;ˆDô �yŠy˜‹ &Ô(Ø(×7Ñ7¸ÓGÐGð ˜(ØÐ/Ø˜^Ø˜ð	 Ðô �{×+Ñ+Ð-@À$ÓGÒOØ9;�×$Ñ$Ô6Ü�+‹ k×&:Ñ&:×&LÑ&LÔLØJL�×$Ñ$×6Ñ6´r¸+³ÑGØ× Ñ ×2Ñ2´2°k³?ÕC×JÑJÐK[Ô\ô œ4 ›>×2Ñ2°O×DÒDÜ $ X£× 7Ñ 7�Ø2?Ô!Ô/Ü*;”�X“×'Ò'õ Eûðm9	<ús   ±; »G(ÁFG#Ç#G()r  r  r  )Úmodule_or_classr  rn  ro  rð  rï  s   &&ff @rÓ   Ú_patch_with_call_inforr  ˆ  s0   ú€ ô ˜/Ó5€KÜ�K× Ò Ù÷@<ôD ˆO¨Ö0r   c           
     óª  € \         P                  ! V 4      pVP                  P                  4        UUu. uF  w  rgVP                  NK  	  ppp\        V4      \        VR,          4      ^,           8X  d   R.VR,          ,           VR&   \        V4       U	Uu/ uF  w  r–WibK	  	  p
p	p/ pV FU  pWÂ9   d   W,,          pVR,          V,          pM W¬,          pW,          pVR,          V,          p\        V4      pRVRV/W¼&   KW  	  RpV F6  pW¼,          R,          W¼,          R,          ppVR RV RV R	V R
2,          pK8  	  VRR pV# u uppi u upp	i )z^
Prepare a string containing the call info to `func`, e.g. argument names/values/expressions.
r6  r   r7  Úarg_exprÚarg_value_strrÁ  z

argument name: `z`
argument expression: `z`

argument value:

rú  Nrû  r»  )r¢  Ú	signatureÚ
parametersrt  rT  r  r  Ú_format_py_obj)r   r  r  rl  ro  rv  Ú
param_nameÚparamÚsignature_namesr  Úparam_position_mappingÚarg_inforB  Ú	arg_valuert  Úarg_posru  rI  s   &&&&&             rÓ   Ú_parse_call_infor€  Ø  s‡  € ô ×!Ò! $Ó'€IØ;D×;OÑ;O×;UÑ;UÔ;WÔXÑ;WÑ&7 j�u—z”zÑ;W€OÑXô ˆ4ƒy”CÐ1Ð2CÕDÓEÈÕIÔIð 9?°xÐB[Ð\mÕBnÕ7nÐ!Ð"3Ñ4äENÈÔE_Ô`ÑE_±/°#˜jšoÑE_ÐÑ`à€HÛˆØÔØÕ(ˆIØ0°Õ@ÀÕJ‰Hà,Õ6ˆGØ�ˆIØ0Ð1BÕCÀGÕLˆHä& yÓ1ˆØ(¨(°OÀ]ÐSˆÓñ  ð €DÛˆØ"*Õ"4°ZÕ"@À(ÕBTÐUdÕBe�-ˆØ�8�*Ð0°°
Ð:SÐT\ÐS]Ð]uð  wDð  vEð  EIð  Jõ  	JŠñ ð
 ��ˆ9€Dà€Kùó? Yùó as   ´E	ÂEc                 óÌ  € \         P                  P                  \         P                  P	                  RR4      R4      p \        V 4      P                  RR7       \        4       '       d"   ^ RIp\        VP                  R\        RR7       \        \        P                  P                  R	\        RR7       \        \        P                  P                  R
\        RR7       \        \        P                  P                  R\        RR7       \        \        P                  P                  R\        RR7       \        \        P                  P                  R\        RR7       \        \        P                  P                  R\        RR7       \        \        P                  P                  R\        RR7       \        \        P                  P                  R\        RR7       \        \        P                  P                  R\        RR7       \        \        P                  P                  R\        RR7       \        \        P                  P                  R\        RR7       R# )zî
Patch some methods (`torch.testing.assert_close`, `unittest.case.TestCase.assertEqual`, etc).

This will allow us to collect the call information, e.g. the argument names and values, also the literal expressions
passed as the arguments.
rF  rÁ  rG  T)r\  NÚassert_close)ro  ÚassertEqualÚassertListEqualÚassertTupleEqualÚassertSetEqualÚassertDictEqualÚassertInÚassertNotInÚ
assertLessÚassertLessEqualÚassertGreaterÚassertGreaterEqual)ÚactualÚexpected)ÚfirstÚsecond)Úlist1Úlist2)Útuple1Útuple2)Úset1r–  )Úd1Úd2)ÚmemberÚ	container)rH  Úb)rÊ   r¤  r¨  rË   r¥  r   Úunlinkru   r¬  rr  Útestingr€  ræ   ÚcaseÚTestCase)rS  r¬  s     rÓ   Ú%patch_testing_methods_to_collect_infor   ÿ  s„  € ô 	�‰�‰”R—Z‘Z—^‘^Ð$IÈ2ÓNÐPcÓd€AÜˆƒG‡N�N˜d€NÔ#ä×ÒÛä˜eŸm™m¨^Ô=MÐ[qÕräœ(Ÿ-™-×0Ñ0°-ÔAQÐ_rÕsÜœ(Ÿ-™-×0Ñ0Ð2CÔEUÐcuÕvÜÜ�‰×ÑÐ 2Ô4DÐRfõô œ(Ÿ-™-×0Ñ0Ð2BÔDTÐbrÕsÜœ(Ÿ-™-×0Ñ0Ð2CÔEUÐcoÕpÜœ(Ÿ-™-×0Ñ0°*Ô>NÐ\sÕtÜœ(Ÿ-™-×0Ñ0°-ÔAQÐ_vÕwÜœ(Ÿ-™-×0Ñ0°,Ô@PÐ^hÕiÜœ(Ÿ-™-×0Ñ0Ð2CÔEUÐcmÕnÜœ(Ÿ-™-×0Ñ0°/ÔCSÐakÕlÜœ(Ÿ-™-×0Ñ0Ð2FÔHXÐfp×qr   c          	      óV   € V ^8„  d   QhR\         R\        R\        R\        R,          /# )r8  ÚscriptÚnproc_per_nodeÚis_torchrunr¦  N)r;  r×   r0  r¼  )r<  s   "rÓ   r=  r=    s3   € ÷ Mñ M”Sð M¬#ð M¼Dð MÌdÐUYÍkñ Mr   c           
     ó  € \         P                  ! RRR7      ;_uu_ 4       pVP                  V 4       VP                  4        VP	                  ^ 4       V'       d-   RV R\        4        RVP                   2P                  4       pMRVP                  .p \        P                  ! VRVRRR	7      p RRR4       R#   \        P                   d   p\        R
TP                   24      hRp?ii ; i  + '       g   i     R# ; i)zmRun the `script` using `torchrun` command for multi-processing in a subprocess. Captures errors as necessary.zw+r”  )rO  Úsuffixztorchrun --nproc_per_node z --master_port rö  Úpython3T)r  r¦  r  r  z"The following error was captured: N)rR  ÚNamedTemporaryFiler  ÚflushÚseekri  rT  r½  rN  r  r”  rv  r  )r¢  r£  r¤  r¦  Útmpr†  rz  r	  s   &&&&    rÓ   Útorchrunr¬    sÝ   € ä	×	$Ò	$¨$°u×	=Õ	=ÀØ�	‰	�&ÔØ�	‰	ŒØ�‰�Œßà,¨^Ð,<¸OÔLfÓLhÐKiÐijÐkn×ksÑksÐjtÐuß‰e‹gñ ð ˜cŸh™hÐ'ˆCð	MÜ—’˜s°4¸SÀtÐSWÔX‰A÷ 
>Ñ	=øô ×,Ñ,ô 	MÜÐ@ÀÇÁÀ
ÐKÓLÐLûð	Mú÷ 
>×	=Ð	=ús*   ¡A5C2ÂB=Â=C/ÃC*Ã*C/Ã/C2Ã2D	c                óÒ  aa€ \        V \        P                  4      '       g   \        P                  ! V 4      p RpV P                  ^ 8X  d   \        P                  ! V .4      p RpV P                  ^8:  g   \        V P                  ^ R 4      ^08X  d´   V P                  4       P                  R4      p \        V 4      pVP                  RR4      P                  RR4      pRV9   d   VP                  RR4      pK  VP                  R	R
4      pRV9   d   VP                  RR
4      pK  V'       d   V^R pRS,          V,           pV# \        V 4      pSf   RV9   ;'       g    RV9   o\        P                  ! SR7       RS,          R,           pVRP                  VV3R lV  4       4      ,          pVRRS,          ,           R,           ,          p\        P                  ! RR7       V# )uJ   Format torch's tensor in a pretty way to be shown ðŸ‘€ in the test report.FTrã  ztensor(rÁ  Ú)z[ Ú[r  rö  z  Nze+ze-)Úsci_modez[
ú,
c              3   óN   <"  € T F  p\        VS^,           SR7      x € K  	  R# 5i)rÈ  )Úindent_levelr°  N)Ú_format_tensor)rÑ  rò  r³  r°  s   & €€rÓ   rÒ  Ú!_format_tensor.<locals>.<genexpr>o  s&   øé € ÐkÑijÐdeœN¨1¸<È!Õ;KÐV^×_Ñ_Óijùs   ƒ"%Ú]r¾  ú    )rð  r¬  rv  ÚtensorÚndimrÔ  ÚshapeÚdetachÚtor;  r¿  Úset_printoptionsr¨  )rô  r³  r°  Ú	is_scalarÚt_strs   &ff  rÓ   r´  r´  1  s¤  ù€ ô �aœŸ™×&Ò&Ü�LŠL˜‹Oˆð €IØ‡v�v�„{Ü�LŠL˜!˜ÓˆØˆ	ð 	‡v�v�„{”c˜!Ÿ'™' ! B˜-Ó(¨Q¨CÔ/à�H‰H‹J�M‰M˜%Ó ˆô �A“ˆð —‘˜i¨Ó,×4Ñ4°S¸"Ó=ˆð
 �eŒmØ—M‘M $¨Ó,ŠEð —‘˜d CÓ(ˆð �eŒmØ—M‘M $¨Ó,ŠE÷ Ø˜!˜B�KˆEà˜,Õ&¨Õ.ˆàˆô
 �A“ˆð ÒØ˜u‘}×5Ð5¨°©ˆHô 	×Ò¨Õ1à˜,Õ&¨Õ.ˆð 	�—‘ÕkÑijÓkÓkÕkˆØ�˜ <Õ/Õ/°#Õ5Õ5ˆä×Ò¨Õ-à€Lr   c                óª   € RV 9   pRV 9   pV'       d!   V'       d   V P                  RR4      p RV  R2# V'       d   RV  R2# V'       d   RV  R2# RV  R2# )a  Given a string `s`, return a python literal expression that give `s` when it is used in a python source code.

For example, if `s` is the string `abc`, the return value is `"abc"`.

We choice double quotes over single quote despite `str(s)` would give `'abc'` instead of `"abc"`.
rº  Ú"z\")r¿  )rh  Úhas_single_quoteÚhas_double_quotes   &  rÓ   Ú_quote_stringrÄ  w  sh   € ð ˜a‘xÐØ˜a‘xÐç×,à�I‰I�c˜5Ó!ˆØ�1�#�Qˆxˆß	Ø�1�#�Qˆxˆß	Ø�1�#�Qˆxˆà�1�#�Qˆxˆr   c           	     óð  a"a#€ Vf   / pM(\        V 4      WV3V9   d   V\        V 4      WV3,          # \        V P                  4      R8X  d   \        V 4      # V P                  P                  R8X  d"   \        V 4      pVP                  RR4      pTpEMÈV P                  P                  R9   d   \        V 4      pEM V P                  P                  R9   Ed…   RR	RR
RR/pWpP                  P                  ,          w  r‰. p
\        V \        4      '       dÀ   \        V P                  4       4       F¡  w  pw  rÍV\        V 4      ^,
          8H  p\        WÁ^,           RVR7      p\        TV^,           TTV'       g   VP                  4       R,           R,           MRR7      pV
P                  VP                  4        RVP                  4        24       K£  	  Mi\        V 4       FZ  w  ppV\        V 4      ^,
          8H  p\        TV^,           Y#V'       g   RMRR7      pV
P                  VP                  4       4       K\  	  . p. p\        V
4       EF(  w  ppVP                  V4       RVR,          9   pV\        V
4      ^,
          8g  pT;'       gW    \        R^V^,           ,          ,           4      \        RP                  VRR 4      4      ,           ^x\!        V4      ,
          8„  pTpV'       gV   \        R^V^,           ,          ,           4      \        RP                  V4      4      ,           ^x\!        V4      ,
          8„  pTp\#        V 4      \        Jd   \#        W,          4      M(\#        \%        V P'                  4       4      V,          4      \$        \(        \        39   d   RpRpRp\#        V 4      \        Jd   \#        W,          4      M(\#        \%        V P'                  4       4      V,          4      p\        V4      ^8”  dk   \#        V 4      \        Jd   \#        W^,
          ,          4      M/\#        \%        V P'                  4       4      V^,
          ,          4      pVV8g  pV'       d   RpVe   V\        J d   V\        J d   RpV\        J d   RpVR\        39   d   RpV'       g   EKf  \        V4      pV^8”  d“   RpV\        J dG   \        R^V^,           ,          ,           4      \        RP                  VRR 4      4      ,           ^w8„  pV'       d    VRR  F  pVP                  V.4       K  	  MVP                  VRR 4       VRR pV'       g   EK  VP                  V4       . pEK+  	  \        V4      ^ 8”  d…   RpX\        J dD   \        R^V^,           ,          ,           4      \        RP                  V4      4      ,           ^x8„  pV'       d   V F  pVP                  V.4       K  	  MVP                  V4       RV,           V R2pV Uu. uF1  pR^V^,           ,          ,           RP                  V4      ,           NK3  	  ppVRP                  V4      ,          pVRRV,           V	 2,          p\*        ;QJ d    R V 4       F  '       d   K   RM	  RM! R V 4       4      o#S#o"S"'       d™   RP                  V Uu. uF  pVP                  4       NK  	  up4      p V V  V	 2p VR8X  d   V# \        RV,           4      \        V4      ,           \        V 4      ,           ^x8*  o"V"V#3R lp!V!! V 4      '       d   RV,           V  2pXV\        V 4      WV3&   V# u upi u upi )zðFormat python objects of basic built-in type in a pretty way so we could copy-past them to code editor easily.

Currently, this support int, float, str, list, tuple, and dict.

It also works with `torch.Tensor` via calling `format_tesnor`.
Nz<class 'torch.Tensor'>r;  r  z\nr»  rq  r¼  z[]z()r  zone-line)r?  rO  r   rQ  Ú,rÁ  )r?  rO  r   Úprefixrö  rO  TFr±  c              3   ó,   "  € T F
  pR V9  x € K  	  R# 5i)r  NrF  ©rÑ  rò  s   & rÓ   rÒ  Ú!_format_py_obj.<locals>.<genexpr>#  s   é € Ð%M¹_¸ d°!¦m»_ùs   ‚c                 ó¶  <€ \        V 4      \        \        \        39   Ed8   . p\        V 4      \        J d(   VP	                  R  V P                  4        4       4       M2\        V 4      \        \        39   d   VP	                  R V  4       4       \        ;QJ d    R V 4       F  '       g   K   RM	  RM! R V 4       4      '       d6   \        V 4      ^8”  d   R# \        V 4      \        V ^ ,          4      Jd   R# S# \        \        V4      4      ^8”  d   R# V^ ,          \        \        39   d   S# V^ ,          \        J d   \        V 4      ^8X  d   S# S# R# )c              3   ó8   "  € T F  p\        V4      x € K  	  R # 5ir  ©ró  rÉ  s   & rÓ   rÒ  Ú<_format_py_obj.<locals>.use_one_line_repr.<locals>.<genexpr>:  s   é € Ð,K¹l¸¬T°!¯W¨W»lùó   ‚c              3   ó8   "  € T F  p\        V4      x € K  	  R # 5ir  rÍ  rÉ  s   & rÓ   rÒ  rÎ  <  s   é € Ð,B¹c¸¬T°!¯W¨W»cùrÏ  c              3   óH   "  € T F  q\         \        \        39   x € K  	  R # 5ir  ©r»  rq  r¼  rÉ  s   & rÓ   rÒ  rÎ  ?  s   é € ÐK¹]¸¤¤u¬dÐ 3Ö3»]ùs   ‚ "TF)ró  r»  rq  r¼  Úextendr  Úanyr  rÔ  r×   rþ  r;  )r{  Úelement_typesÚcould_use_one_lineÚno_new_line_in_elementss   & €€rÓ   Úuse_one_line_reprÚ)_format_py_obj.<locals>.use_one_line_repr4  s  ø€ ä˜“9¤¤u¬dÐ 3Õ3à$&�MÜ˜C“y¤DÓ(Ø%×,Ñ,Ñ,K¸c¿j¹j¼lÓ,KÕKÜ˜c›¤t¬U mÔ3Ø%×,Ñ,Ñ,B¹cÓ,BÔB÷ “sÑK¹]ÓK—s—s’sÑK¹]ÓK×KÒKä˜s›8 aœ<Ù#(ô   ›9¬D°°Qµ«LÓ8Ù#(ð  7Ð6ô œ3˜}Ó-Ó.°Ô2Ù$ð % QÕ'¬C´¨<Ô7à6Ð6Ø& qÕ)¬SÓ0Ü˜s›8 qœ=à#:Ð:ð $6Ð5ñ r   rß  rÒ  r¾  r·  )r  r;  r(  r´  rô  rÄ  r¿  rð  r¼  r  rt  r  rx  r„  r¤  r¨  r×   ró  r»  r  rq  r„  )$r{  r?  rO  r   rÇ  Úquoted_stringr•  ÚparenthesisÚp1Úp2Úelements_without_indentr  rÉ  r}  Úlast_elementÚokÚovrò  ÚoÚgroupsrÅ  Ú
x_expandedÚnot_last_elementÚshould_finalize_xÚshould_finalize_bufÚbuf_not_fit_into_one_lineÚ	prev_typeÚcurrent_typeÚtype_changedÚorig_buf_lenÚnot_fit_into_one_lineÚelement_stringsÚone_line_formrØ  rÖ  r×  s$   &&&&&                             @@rÓ   rx  rx  �  sº  ù€ ð ‚}Ø‰äˆs‹G�V 6Ð*¨eÔ3Øœ"˜S›' 6°Ð8Õ9Ð9ô ˆ3�=‰=ÓÐ5Ô5Ü˜cÓ"Ð"à	�‰×	Ñ	 5Ô	(Ü% cÓ*ˆà%×-Ñ-¨d°EÓ:ˆØŠà	�‰×	Ñ	Ð#3Ô	3ä�S“Šà	�‰×	Ñ	Ð#<Õ	<à�DØ�TØ�Dð
ˆð
 Ÿ]™]×3Ñ3Õ4‰ˆà"$ÐÜ�cœ4× Ò Ü(¨¯©«Ö5‘�‘V�aØ"¤c¨#£h°¥lÑ2�Ü# A°q­j¸zÐQVÔW�Ü#ØØ! A�:ØØß;G˜2Ÿ9™9›;¨Õ-°Ö3ÈRô�ð (×.Ñ.°"·)±)³+°¸bÀÇÁÃÀÐ/NÖOò  6ô $ Cž.‘��QØ"¤c¨#£h°¥lÑ2�Ü"Ø˜f q�j¨t×T`ÉÐfhô�ð (×.Ñ.¨q¯x©x«zÖ:ñ )ð ˆØˆÜÐ 7×8‰FˆC�Ø�J‰J�qŒMà  R¥™ˆJØ"¤cÐ*AÓ&BÀQÕ&FÑFÐà *÷ !,ð !,¬c°S¸AÀÈ!ÅÕ<LÕ5MÐ4NÓ.PÔSVØ—	‘	˜#˜b˜c˜(Ó#óTõ /à”cÐ*Ó+Õ+ñ/,Ðð
 #-Ð÷ 'Ü,/°3¸!¸vÈ½zÕ:JÕ3KÐ2LÓ,NÔQTÐUY×U^ÑU^Ð_bÓUcÓQdÕ,dÐgjÔmpØ$ónõ hñ -Ð)ð '@Ð#ô #' s£)´4Ó"7”�S•X”¼TÄ$ÀsÇzÁzÃ|ÓBTÐUXÕBYÓ=ZÔ`dÔfkÔmqÐ_rÔrØ$(Ð!Ø&*Ð#ð ˆIÜ-1°#«Y¼dÓ-Bœ4 ¥œ>ÌÌTÐRU×R\ÑR\ÓR^ÓM_Ð`cÕMdÓHeˆLÜ�3‹x˜!Œ|Ü26°s³)Ä4Ó2GœD ¨1¥W¥Ô.ÌTÔRVÐWZ×WaÑWaÓWcÓRdÐehÐklÕelÕRmÓMn�	Ø+¨yÑ8�ßØ*.Ð'ð Ò  Y´#Ó%5¸,Ì#Ó:MØ&+Ð#ð œsÓ"Ø$)Ð!à ¤s Ô+Ø*/Ð'ç"Ò"Ü" 3›x�à !Ô#Ø,0Ð)ð !¤CÓ'ä03°s¸aÀ6ÈAÅ:Õ>NÕ7OÐ6PÓ0RÔUXÐY]×YbÑYbÐcfÐgjÐhjÐckÓYlÓUmÕ0mÐpwÑ0wÐ-ç,Ø!$ S b£˜AØ"ŸM™M¨1¨#Ö.ò "*ð Ÿ™ c¨#¨2 hÔ/à˜b˜c˜(�Cç$Ò$Ø—M‘M #Ô&Ø“CñG 9ôL ˆs‹8�aŒ<Ø$(Ð!ØœsÓ"ä(+¨s°a¸6ÀA½:Õ6FÕ/GÐ.HÓ(JÌSÐQU×QZÑQZÐ[^ÓQ_ÓM`Õ(`ÐcfÑ(fÐ%ç$Û�AØ—M‘M 1 #Ö&ò ð —‘˜cÔ"à˜fÕ$Ð% b T¨Ð,ˆÙU[Ó\ÑU[Èc˜c Q¨&°1­*Õ%5Õ6Ð7¸4¿9¹9ÀS»>×IÐIÑU[ˆÐ\Ø�%—*‘*˜_Ó-Õ-ˆØ�B�w Õ'Ð(¨¨Ð-Õ-ˆ÷ #&£#Ñ%M¹_Ó%M§#§#¢#Ñ%M¹_Ó%MÓ"MÐà4Ð÷ Ø ŸI™I¹?Ó&K¹?°a q§x¡x¦z¹?Ñ&KÓLˆMØ!˜d = /°"°Ð6ˆMà�zÔ!Ø�ô "%¨°&Õ(8Ð'9Ó!;¼cÀ&»kÕ!IÌCÐP]ÓL^Õ!^ÐbeÑ!eÐö(ñV ! ×%Ò%Ø# fÕ,Ð-¨m¨_Ð=�à-3€EŒ2ˆc‹7�F &Ð
)Ñ*à€MùòM ]ùò 'Ls   Ø7].Û]3c                 óŠ   € \        V R 4      ;_uu_ 4       pVP                  V4       RRR4       R#   + '       g   i     R# ; i)rõ  N)r  r  )r:  Úcontentr#  s   && rÓ   Ú
write_filerò  g  s'   € Ü	ˆd�C�Œ˜AØ	�‰�Ô÷ 
��Šús	   •1±A	c                 ó”   € \        V R 4      ;_uu_ 4       p\        P                  ! V4      uuRRR4       #   + '       g   i     R# ; i)ÚrN)r  ÚjsonÚload)r:  Úfhs   & rÓ   Úread_json_filerø  l  s&   € Ü	ˆd�C�Œ˜BÜ�yŠy˜‹}÷ 
��‹ús	   •6¶A	c                   óV   € ] tR tRtRtRtRtRtRtRt	Rt
R	tR
tRtRtRtRtRtRtRtRtR# )ÚColorsiw  z0ANSI color codes for terminal output formatting.z[0mz[1mz[2mz[31mz[32mz[33mz[34mz[35mz[36mz[37mz[91mz[92mz[93mz[94mz[96mrF  N)rô  r  r  r  r  ÚRESETÚBOLDÚDIMÚREDÚGREENÚYELLOWÚBLUEÚMAGENTAÚCYANÚWHITEÚ
BRIGHT_REDÚBRIGHT_GREENÚBRIGHT_YELLOWÚBRIGHT_BLUEÚBRIGHT_CYANr  rF  r   rÓ   rú  rú  w  sT   † Ù:à€EØ€DØ
€Cð €CØ€EØ€FØ€DØ€GØ€DØ€Eð €JØ€LØ€MØ€KØ„Kr   rú  c                   ó„  a a€ ] tR tRt oRt]P                  ]P                  ]P                  ,           ]P                  ]P                  ]P                  ]P                  ]P                  ]P                  ]P                   ]P"                  ]P                  ,           /t0 RmtR	V3R lV 3R llltV3R lR ltRtVtV ;t# )
ÚColoredFormatteri�  z5Custom formatter that adds colors based on log level.c                óB   <€ V ^8„  d   QhRS[ R,          RS[ R,          /# )r8  ÚfmtNÚdatefmtr:  )r<  r!  s   "€rÓ   r=  ÚColoredFormatter.__annotate__�  s#   ø€ ÷ 'ñ '™C $�Jð '¹¸d½
ñ 'r   c                ó&   <€ \         SV `  W4       R # r  r%  )r   r  r  r(  s   &&&€rÓ   r  ÚColoredFormatter.__init__�  s   ø€ Ü‰Ñ˜Ö&r   c                ó:   <€ V ^8„  d   QhRS[ P                  RS[/# )r8  Úrecordr¯  )r   Ú	LogRecordr;  )r<  r!  s   "€rÓ   r=  r     s%   ø€ ÷ Tñ T™W×.Ñ.ð T±3ñ Tr   c           	     óÜ  € VP                   V P                  9   pV'       dn   V P                  WP                  4      pVP	                  4       p\
        P                   V R VP                    R VP                  R R V \
        P                   2	# V P                  P                  VP                  \
        P                  4      pVP                  pV VR \
        P                   2p\
        P                   V P                  WP                  4       \
        P                   2p\
        P                   VP                    \
        P                   2p	VP	                  4       pV R V	 R V R V 2# )r  Ú8)rT  ÚDIMMED_LOGGERSÚ
formatTimer  Ú
getMessagerú  rý  Ú	levelnamerû  ÚLEVEL_COLORSr¥  Úlevelnor  )
r   r  Ú	is_dimmedÚ	timestamprM  Úcolorr  Úcolored_levelnameÚcolored_timeÚcolored_names
   &&        rÓ   r<  ÚColoredFormatter.format   s<  € à—K‘K 4×#6Ñ#6Ñ6ˆ	çàŸ™¨·±Ó=ˆIØ×'Ñ'Ó)ˆGÜ—j‘j�\ ) ¨C°·±¨}¸CÀ×@PÑ@PÐQRÐ?SÐSVÐW^ÐV_Ô`f×`lÑ`lÐ_mÐnÐnð ×!Ñ!×%Ñ% f§n¡n´f·l±lÓCˆð ×$Ñ$ˆ	Ø$˜g i° ]´6·<±<°.ÐAÐô !Ÿ*™*˜ d§o¡o°f¿l¹lÓ&KÐ%LÌVÏ\É\ÈNÐ[ˆô !Ÿ+™+˜ v§{¡{ m´F·L±L°>ÐBˆð ×#Ñ#Ó%ˆà�˜s < .°Ð4EÐ3FÀcÈ'ÈÐSÐSr   rF  >   rç  r©  ÚhttpcoreÚrequestsr_  )rô  r  r  r  r  r   ÚDEBUGrú  rý  r  ÚINFOr  ÚWARNINGr  ÚERRORr  ÚCRITICALrü  r  r  r  r<  r  r  r,  r-  s   @@rÓ   r  r  �  s�   ù‡ € Ù?ð 	�‰�v—z‘z F§K¡KÕ/Ø�‰�f—l‘lØ�‰˜×-Ñ-Ø�‰�v×(Ñ(Ø×Ñ˜&Ÿ+™+¨×(9Ñ(9Õ9ð€Lò B€N÷'õ '÷T÷ Tð Tr   r  c                ó8   € V ^8„  d   QhR\         P                  /# r3  )r   ÚLogger)r<  s   "rÓ   r=  r=  À  s   € ÷ ñ œ'Ÿ.™.ñ r   c                 óþ  € \         P                  ! R4      p V P                  \         P                  4       V P                  '       g¯   \         P
                  ! \        P                  4      pVP                  \         P                  4       \        P                  P                  4       '       d   \        RR7      pM\         P                  ! RRR7      pVP                  V4       V P                  V4       RV n        V # )a  Initialize a test-specific logger with colored stderr handler and INFO level for tests.

Uses a named logger instead of root logger to avoid conflicts with pytest-xdist parallel execution.
Uses stderr instead of stdout to avoid deadlocks with pytest-xdist output capture.
ztransformers.training_testz%Y-%m-%d %H:%M:%S)r  z4%(asctime)s - %(name)s - %(levelname)s - %(message)sF)r   Ú	getLoggerÚsetLevelr'  Úhandlersr8  r  r  Úisattyr  Ú	FormatterÚsetFormatterr<  Ú	propagate)r6  ÚchÚ	formatters      rÓ   Úinit_test_loggerr7  À  s³   € ô ×ÒÐ;Ó<€FØ
‡O�O”G—L‘LÔ!ð �?�?ˆ?ä×"Ò"¤3§:¡:Ó.ˆØ
�‰”G—L‘LÔ!ô �:‰:×Ñ×ÒÜ(Ð1DÔE‰Iä×)Ò)ØFÐPcôˆIð 	�‰˜	Ô"Ø×Ñ˜"Ôà€FÔØ€Mr   c                óH   € V ^8„  d   QhR\         P                  R\        RR/# )r8  Úlogger_instancer  r¯  N)r   r,  r;  )r<  s   "rÓ   r=  r=  Þ  s%   € ÷ #ñ #œwŸ~™~ð #´Cð #¸Dñ #r   c                ól   € V\         9  d)   V P                  V4       \         P                  V4       R# R# )a"  Log a warning message only once per unique message.

Uses a global set to track messages that have already been logged
to prevent duplicate warning messages from cluttering the output.

Args:
    logger_instance: The logger instance to use for warning.
    msg: The warning message to log.
N)Ú_warn_once_loggedÚwarningÚadd)r9  r  s   &&rÓ   Ú	warn_oncer>  Þ  s.   € ð Ô#Ô#Ø×Ñ Ô$Ü×Ñ˜cÖ"ñ $r   ÚMemoryStatsc                   ó„   a € ] tR tRt o RtR tV 3R lR ltV 3R lR ltV 3R lR	 ltV 3R
 lR lt	V 3R lR lt
RtV tR# )ÚCPUMemoryMonitoriü  z1Monitor CPU memory usage for the current process.c                óL  € R V n         ^ V n        RV n        ^ V n        ^ V n        \        4       '       dq   ^ RIpVP                  \        P                  ! 4       4      V n        VP                  4       pVP                  V n        V P                  V P                  4      V n        R# R# )ÚCPUN)Údevice_nameÚ	_peak_rssÚ_processr	  Útotal_memory_gibr^   r  r÷  rÊ   Úgetpidr  r  Ú_to_gib)r   r  Úmem_infos   &  rÓ   r  ÚCPUMemoryMonitor.__init__ÿ  s€   € Ø ˆÔØˆŒØˆŒØˆÔØ !ˆÔä× Ò Ûà"ŸN™N¬2¯9ª9«;Ó7ˆDŒMØ×,Ñ,Ó.ˆHØ (§¡ˆDÔØ$(§L¡L°×1BÑ1BÓ$CˆDÖ!ñ !r   c                ó&   <€ V ^8„  d   QhRS[ RS[/# ©r8  Úmemory_in_bytesr¯  rß  )r<  r!  s   "€rÓ   r=  ÚCPUMemoryMonitor.__annotate__  s   ø€ ÷ 6ñ 6¡sð 6©uñ 6r   c                ó   € VR,          # )zConvert bytes to GiB.r   rF  ©r   rN  s   &&rÓ   rI  ÚCPUMemoryMonitor._to_gib  s   € àÐ"4Õ5Ð5r   c                ó&   <€ V ^8„  d   QhRS[ RS[/# rM  rß  )r<  r!  s   "€rÓ   r=  rO    s   ø€ ÷ ;ñ ;¡sð ;©uñ ;r   c                ó\   € V P                   ^ 8X  d   R# RV,          V P                   ,          # )z,Convert bytes to percentage of total memory.g        g      Y@)r	  rQ  s   &&rÓ   Ú_to_pctÚCPUMemoryMonitor._to_pct  s)   € à×Ñ Ô!ÙØ�Õ&¨×):Ñ):Õ:Ð:r   c                ó   <€ V ^8„  d   QhRR/# r±  rF  )r<  r!  s   "€rÓ   r=  rO    s   ø€ ÷ >ñ >˜dñ >r   c                ó¤   € V P                   eB   V P                   P                  4       P                  p\        V P                  V4      V n        R# R# )zUpdate peak memory tracking.N)rF  Úmemory_infoÚrssrå  rE  )r   Úcurrent_rsss   & rÓ   Ú_update_peakÚCPUMemoryMonitor._update_peak  s;   € à�=‰=Ò$ØŸ-™-×3Ñ3Ó5×9Ñ9ˆKÜ  §¡°Ó=ˆDŽNñ %r   c                ó    <€ V ^8„  d   QhRS[ /# r3  )r?  )r<  r!  s   "€rÓ   r=  rO    s   ø€ ÷ 
ñ 
™;ñ 
r   c                óB  € \        4       '       g   \        ^ ^ ^ ^ ^ ^ ^ 4      # ^ RIpV P                  4        V P                  P                  4       pVP                  4       p\        V P                  VP                  4      V P                  VP                  4      V P                  VP                  4      V P                  V P                  4      V P                  V P                  4      V P                  VP                  4      V P                  VP                  4      R7      # )zGet current memory statistics.N©Úrss_gibÚrss_pctÚvms_gibÚpeak_rss_gibÚpeak_rss_pctÚavailable_gibÚ	total_gib)r^   r?  r  r\  rF  rY  r  rI  rZ  rU  ÚvmsrE  Ú	availabler  )r   r  rJ  Úsys_mems   &   rÓ   Ú	get_statsÚCPUMemoryMonitor.get_stats  sÐ   € ä"×$Ò$Ü˜q ! Q¨¨1¨a°Ó3Ð3ãà×ÑÔà—=‘=×,Ñ,Ó.ˆØ×'Ñ'Ó)ˆäØ—L‘L §¡Ó.Ø—L‘L §¡Ó.Ø—L‘L §¡Ó.ØŸ™ d§n¡nÓ5ØŸ™ d§n¡nÓ5ØŸ,™, w×'8Ñ'8Ó9Ø—l‘l 7§=¡=Ó1ô
ð 	
r   c                ó   <€ V ^8„  d   QhRR/# r±  rF  )r<  r!  s   "€rÓ   r=  rO  4  s   ø€ ÷ =ñ = $ñ =r   c                óx   € V P                   e,   V P                   P                  4       P                  V n        R# R# )zReset peak memory tracking.N)rF  rY  rZ  rE  r	  s   &rÓ   Úreset_peak_statsÚ!CPUMemoryMonitor.reset_peak_stats4  s+   € à�=‰=Ò$Ø!Ÿ]™]×6Ñ6Ó8×<Ñ<ˆDŽNñ %r   )rE  rF  rD  r	  rG  N)rô  r  r  r  r  r  rI  rU  r\  rk  ro  r  r  r   s   @rÓ   rA  rA  ü  s@   ø‡ € Ù;òD÷6ð 6÷;ð ;÷>ð >÷
ð 
÷,=ö =r   rA  c                óR   € V ^8„  d   QhR\         P                  R,          R\        /# )r8  r9  Nr¯  )r   r,  rA  )r<  s   "rÓ   r=  r=  :  s$   € ÷ ñ ¬g¯n©n¸tÕ.Cð ÔO_ñ r   c                ó¨   € \        4       pV eD   \        4       '       d#   V P                  RVP                  R R24       V# V P	                  R4       V# )z¹Build and initialize a CPU memory monitor.

Args:
    logger_instance: Optional logger to log initialization info. If None, no logging is done.

Returns:
    CPUMemoryMonitor instance.
z CPU memory monitor initialized: z.2fz
 GiB totalz0psutil not available, memory monitoring disabled)rA  r^   rI  rG  r<  )r9  Úmonitors   & rÓ   Úbuild_cpu_memory_monitorrt  :  s[   € ô Ó €GØÒ"Ü× Ò Ø× Ñ Ð#CÀG×D\ÑD\Ð]`ÐCaÐakÐ!lÔmð €Nð ×#Ñ#Ð$VÔWØ€Nr   c                ó$   € V ^8„  d   QhR\         /# )r8  Úfolderr:  )r<  s   "rÓ   r=  r=  L  s   € ÷ 5ñ 5¬Cñ 5r   c           
     ó  € \         P                  ! V 4       EFÂ  p\         P                  P                  W4      pVP	                  R4      '       d\   VP                  RR4      P                  RR4      p\        V4      p\         P                  ! V4       \        P                  ! WC4       K•  V\        8X  g   K¢  \         P                  P                  V \        4      p\        V4      ;_uu_ 4       p\        P                  ! VP                  4       4      pRRR4       \         P                  ! V4       RXP!                  4       9   dI   VR,          p/ pVP#                  4        F)  w  ršV
P                  RR4      P                  RR4      W‰&   K+  	  XVR&   \        VR4      ;_uu_ 4       pVP%                  \        P&                  ! V^R7      4       RRR4       EKÅ  	  R#   + '       g   i     LÓ; i  + '       g   i     EKî  ; i)	z–Convert all safetensors files into torch bin files, to mimic saving with torch (since we still support loading
bin files, but not saving them anymore)z.safetensorsz.binrõ  Úpytorch_modelNÚ
weight_maprõ  )r?  )rÊ   Úlistdirr¤  r¨  r§  r¿  rÃ   re  r¬  Úsaver$   r&   r  rõ  Úloadsr  rÈ  rt  r  Údumps)rv  r:  r¤  Únew_pathÚ
state_dictr#  Úindexry  Únew_weight_maprÉ  r}  s   &          rÓ   Úconvert_all_safetensors_to_binsr‚  L  sb  € ô —
’
˜6×"ˆÜ�w‰w�|‰|˜FÓ)ˆØ�=‰=˜×(Ò(Ø—|‘| N°FÓ;×CÑCÀGÈ_Ó]ˆHÜ" 4›ˆJÜ�IŠI�dŒOÜ�JŠJ�zÖ,àÔ,Ö,Ü—w‘w—|‘| FÔ,>Ó?ˆHÜ�d—”˜qÜŸ
š
 1§6¡6£8Ó,�÷ ä�IŠI�dŒOØ˜uŸz™z›|Ô+Ø" <Õ0�
Ø!#�Ø&×,Ñ,Ö.‘D�AØ()¯	©	°.À&Ó(I×(QÑ(QÐRYÐ[jÓ(k�NÓ%ñ /à"0ˆE�,ÑÜ�h ×$Ô$¨Ø—‘œŸ
š
 5°Ô3Ô4÷ %Ò$ó' #÷ —ú÷ %×$Ñ$ús   Ã0%G Æ)(G3Ç G0Ç3Hc               #  ó’   a"  €  \         P                  oV3R lp V \         n        Rx € S\         n        R#   S\         n        i ; i5i)z«Since we don't support saving with torch `.bin` files anymore, but still support loading them, we use this context
to easily create the bin files and try to load them backc                 ó6   <€ S! W.VO5/ VB  \        V4       R # r  )r‚  )r   Úsave_directoryr  r  Úoriginal_saves   &&*,€rÓ   Únew_saveÚ2force_serialization_as_bin_files.<locals>.new_saven  s   ø€ Ù˜$Ð@°Ò@¸Ò@Ü+¨NÖ;r   N)rÅ   Úsave_pretrained)r‡  r†  s    @rÓ   Ú force_serialization_as_bin_filesrŠ  f  s8   øé € ð8ä'×7Ñ7ˆõ	<ð +3ŒÔ'ãà*7ŒÖ'ø¨-ŒÕ'üs   ƒA…%7 ªA·AÁAc                óV   € V ^8„  d   Qh/ ^ \         9   d   \        \        ,          ;R&   # )r8  r;  )Ú__conditional_annotations__rÔ  r;  )r<  s   "rÓ   r=  r=     s    € ‡
�
÷\E $Ò #”3”s•8Ñ #ò]E r   )Fr  )z1.12.0)éP   )é   )NNNFF)NNé´   FT)rl  )é   NN)r�  r8  r_  r-  )r   N)r   rÁ  NrÁ  r`  (ú  rŒ  r,  rŠ  Ú
contextlibr£  rW  r  r­  rë  r¢  rõ  r   rò  rÊ   rÂ  r¼  r„  rN  r  rR  rž  rÖ  r  r  ræ   r   r   Úcollections.abcr   r   r   r   r	   r
   Údataclassesr   r   r   r   r7  r   Úpathlibr   Útypingr   r   r   Úunittest.mockr   rç  Úhuggingface_hubr   r   Ú	packagingr   ÚtransformersrD  r®  r   Úintegrationsr   r   r   r   r   r   r    Úintegrations.deepspeedr!   Úutilsr"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   rh   ri   rj   rk   rl   rm   rn   ro   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   r{   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   r…   r†   r‡   rˆ   r‰   rŠ   Úaccelerate.stater‹   rŒ   Úaccelerate.utils.importsr�   Ú_pytest.doctestrŽ   r�   r�   r‘   r’   r“   r”   Ú_pytest.outcomesr•   Ú_pytest.pathlibr–   rç   r—   rª  ÚSMALL_MODEL_IDENTIFIERÚDUMMY_UNKNOWN_IDENTIFIERÚDUMMY_DIFF_TOKENIZER_IDENTIFIERÚUSERÚENDPOINT_STAGINGÚTOKENÚ_COMMON_MODEL_NAMES_MAPÚ_VLM_COMMON_MODEL_NAMES_MAPÚ_TEXT_MODEL_TESTER_DEFAULTSr¬  Úsafetensors.torchrÃ   Úmodeling_utilsrÄ   rÅ   Úhipr¸  r­  r·  r  r¹  rº  Ú
get_loggerrô  r6  rÔ   rØ   rý   rÛ  r  rå   rï   ró   rö   rù   ré   rð   rô   r÷   rú   rÿ   r  r  r  r  r  r   r#  r%  r(  r*  r-  r/  r1  r4  r@  rG  rK  rN  rP  rS  rU  rX  r[  r]  r_  rc  rk  rp  r{  r}  r  r‚  r…  r‡  r‰  r‹  r�  r�  r’  r–  r˜  rš  rœ  rž  r   r¢  r¥  r§  r©  r°  rµ  r¼  r¾  rÀ  rÂ  rÄ  rÆ  rÉ  rË  rÏ  rÑ  rÖ  rÙ  rÛ  rÝ  rß  rË   ÚbackendÚimport_modulerz  ÚModuleNotFoundErrorr	  r´  r  rÌ   ra  rY  rå  rñ  ró  rö  rù  r  r
  r  r  r  r  r%  r'  r/  r1  r3  r5  r7  r9  r;  r=  r@  rB  rD  rF  rH  rK  rM  rO  rQ  rS  rU  rX  r[  r]  r_  ra  rc  rf  rh  rj  rl  rn  rp  rr  rt  rv  rx  rz  r|  r~  r€  r‚  r‡  rŠ  rŒ  rŽ  r‘  r“  r•  r—  r™  r›  r�  rŸ  r¬  r¸  r¿  rÆ  rÏ  rã  rø  rú  r#  r0  r4  rI  rK  rf  rŸ  rh  rÎ  rÛ  rà  rä  r&  rL  r(  r1  rT  r¾  ra  ri  rl  rˆ  rŒ  rv  rŽ  r—  r™  rÝ  ré  rì  r  r  r(  ÚDocTestParserr*  r7  re  Úmanual_seedrn  Úempty_cachert  r®  rz  Úreset_max_memory_allocatedr}  Úmax_memory_allocatedr…  Úreset_peak_memory_statsr�  Úmemory_allocatedr‰  Úsynchronizer�  r‘  rÔ  râ  rÇ   rÆ   ro  rv  r³  r~  r‚  r†  rŠ  rŽ  r’  r›  Úis_filer¤  r½  ÚrealpathÚdevice_spec_dirr¤  r€  Úimport_namer™  ÚDEVICE_NAMErD  rš  r  r�  rª  r±  rq  r;  r×   r³  rÀ  r  rÄ  rÆ  r÷  r)  rD  rJ  rT  rr  r€  r   r¬  r´  rÄ  rx  rò  rø  rú  r2  r  rÔ  r;  r7  r>  Ú
namedtupler?  rA  rt  r‚  rŠ  r=  )rŒ  s   @rÓ   Ú<module>rÀ     sW  øð÷ ‚
Û Û Û Û Û Û 	Û Û Û Û Û Û 	Û 	Û Û Û Û 
Û Û Û Û Û Û ß -ß LÕ LÝ %ß 'ß "Ý Ý ß %Ý Ý ã ß 4Ý å 8÷ Þ à€G÷÷ ñ õ ;÷j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ j÷ jõ jñZ ×Òß?Ý9ñ ×Ò÷÷ ñ õ &Ý+Þ"à€FØ€Kð 6Ð Ø3Ð Ø"AÐ ð %€Ø2Ð ð 	0€ð
 �HØ�}ØÐ 6Ø#Ð%@Ø Ð":ðÐ ð �HØ˜Ø˜>Ø"Ð$>ð	Ð ðØ�"ðà�!ðð �4ðð �dð	ð
 �$ðð �"ðð �2ðð ˜ðð ˜1ðð ˜1ðð ˜ðð �&ðð ˜sðð �Aðð �Aðð  �Að!ð" �qð#ð$ ˜QØ˜RØ% rØ˜$Ø˜aØ˜1Ø�1ñ1Ð ñ8 ×ÒÛÝ+çKà—]‘]×&Ò&¨dÐ2€NØ—]‘]×'Ò'¨tÐ3€NÙ˜EŸM™M¨5°$Ó7¸tÐC€MÙ˜E 5¨$Ó/°tÐ;�Mà€NØ€NØ€MØ€Mà	×	(Ó	(¨Ó	2€õõ 
ñ & j¸%Ô@€Ù& {¸DÔAÐ Ù,Ð-DÈeÔTÐ Ù"Ð#;ÀUÔK€Ù)Ð*>ÈÔMÐ Ù&Ð'8À%ÔHÐ Ù)Ð*>ÈÔMÐ Ù0Ð1LÐVZÔ[Ð ò<ò"=ò :ò=ò Dò Kò?òò	ò_ò^ò_ò_òeòUò_òeòVòcòUð 6L÷ ð '9÷ 
ð 0@÷ ÷ð òYòYóWó]óUóUóYóYööóuó&gójójóó,
ó
óUócóaóaógóaóWóWóaóYócóóYóWómóö
ó	eóvó	kó	ó^óóaóaó
gó\ó`ó\ó
gó
gñ ×Óãà" b§j¢jÔ0Ø—*’*Ð8Õ9‰ð	Ø×'Ó'©Ó0‰Að " R§Z¢ZÔ/Ø—z’zÐ"<Õ=‰Ù˜6Ô!¨%¯*ª*×*AÒ*A×*CÒ*CÚØ+©L¨>ð  :Bð  Cóð ñ ˜5Ô Ñ)?×)AÒ)AÚØ+©L¨>ð  :Að  Bóð ñ ˜5Ô Ñ)?×)AÒ)AÚØ+©L¨>ð  :Að  Bóð ñ ˜5Ô Ñ)?×)AÒ)AÚØ+©L¨>ð  :Að  Bóð ñ ˜5Ô Ñ)?×)AÒ)AÚØ+©L¨>ð  :Að  Bóð ð	à—“™\Ó*ŠAð
 
�Š×	 Ò	 ×	"Ò	"ØŠÙ	×	!Ò	!ØŠÙ	×	!Ò	!ØŠÙ	×	!Ò	!ØŠÙ	×	!Ò	!ØŠàŠà�Ló[ó
	óoó
Xó
V÷

ñ 
÷ñ òRÀr÷ Rñ Ró óóó
hóóó ócó
Yó
]ó
YóXó[ó[óWó[ó_óUóUóUóUóQóYóeó[óXó_óSó`óióqóaóWóócó]ó[óaócóWó[ófóeó]ócó)ófó[óó[óYó]ó]óYófóió	öö.÷
%ð 
%ô86ôMôAô*3÷*bô böV3‘Jõ 3ö3‘Jõ 3÷()ô ()ðV ×Ñò7ó ñ7÷(Vô Vð@ ×Ñöó ñö(X&�8×$Ò$õ X&ôv/ð ×Ñò+ó ñ+ðB Ñ ô*ô&B)õP ÷ô ô÷&0ó &0÷Ró ô,ô"÷7ô6,ô"ö	™iõ 	÷ó ÷"8+ô 8+÷v&ó &÷Ró ô0÷$(.ôV7ðtôö:++�g×+Ò+õ ++ö\I_�fõ I_÷Xð ñ  ×Óð 	�—
’
×&Ò&Øˆu× Ò Ù�5×$Ò$ðÑð 	�—
’
×&Ò&ØˆtÙ�4ðÑð 	�—
’
×'Ò'ØŠyÙ’9ðÑð 	�—
’
×5Ò5ØˆtÙ�4ð*Ñ&ð 	�—
’
×/Ò/ØˆqÙ�1ð$Ñ ð 	�—
’
×2Ò2ØˆtÙ�4ð'Ñ#ð 	�—
’
×+Ò+ØˆqÙ�1ð Ñð 	�—
’
×&Ò&ØˆtÙ�4ðÑð 	�—
’
ØˆtÙ�4ð(Ò$ñ % dÐ+ÑÙ$ dÐ+ÑÙ%¢yÐ1ÑÙ*3°TÐ):Ñ&Ù'0°$Ð&7Ñ#Ù$-¨q >Ñ Ù )¨1˜~ÑÙ$ dÐ+ÑÙ(1°4Ð'8Ñ$ñ ×ÒØ!&§¢×!6Ò!6Ñ˜ÑØ"'§)¢)×"8Ò"8Ñ˜ÑØ.3¯iªiÑ$ UÑ+á×ÒØ!&§¢×!6Ò!6Ñ˜ÑØ!&§¢×!6Ò!6Ñ˜ÑØ"'§)¢)×"8Ò"8Ñ˜ÑØ.3¯iªiÑ$ UÑ+á×ÒØ!&§¢×!6Ò!6Ñ˜ÑØ!&§¢×!6Ò!6Ñ˜ÑØ"'§)¢)×"8Ò"8Ñ˜ÑØ.3¯iªiÑ$ UÑ+á×ÒØ!&§¢×!6Ò!6Ñ˜ÑØ!&§¢×!6Ò!6Ñ˜ÑØ"'§)¢)×"8Ò"8Ñ˜ÑØ05·	²	×0QÒ0QÑ& uÑ-Ø-2¯YªY×-NÒ-NÑ# EÑ*Ø*/¯)ª)×*HÒ*HÑ  Ñ'Ø&+§i¢i×&@Ò&@Ñ˜UÑ#Ø!&§¢×!6Ò!6Ñ˜ÑØ.3¯iªiÑ$ UÑ+ñ ×ÒØ!&§¢×!7Ò!7Ñ™ÑØ!&§¢×!7Ò!7Ñ™ÑØ"'§*¢*×"9Ò"9Ñ™Ñ÷Hð H÷Bð B÷Cð C÷Qð Q÷Nð N÷Kð K÷Gð G÷Bð B÷Oð Oñ ×Óñ '¨"¯*ª*Õ4ØŸ:š:Ñ&EÕFÑÙÑ$Ó%×-Ò-×/Ò/ÚÙ[Ñ\lÐ[mÐnóð ð  ŸWšWŸ]š]¨2¯7ª7×+;Ò+;Ñ<LÓ+MÓNÑ‰™Ø�Š�Š™Ô(ð	vÙ*Ð+JÑ-=×-CÒ-CÁEÓ-JÐK‰Kð '×4Ó4±[ÓAÑð	ZÙ,×8Ò8‰Kð &¨¯ªÔ3¹ÉÔ8SÙVÑWcÐVdñ  eAñ  BMð  ANñ  NQð  R‰CÙÑcÕc‰CÚ™S“/Ð!á"‰÷
	ð 
	ò 	!Ñ!4Ñ6FÔGÚ Ñ!4Ñ6FÔGÚ Ñ!5Ñ7HÔIô)ñ6 ÷ñ ó ññ ™˜t�¡S¨4¥Z±°tµÐ;Õ<Ñ á™s T�z¨4±#­:¹¹cÁ3¸h½Õ+GÐGÕHÑ ð ö&ó ñ&÷8%ó %ö$K�8Ñ2°CÐ7Õ8õ Kô\ ô4rôj9ôx	ô_AôDM1ô`$ôNr÷<Mó M÷(CôL÷,Wôtô
÷ô ö0+T�w×(Ò(õ +Tò\ "›eÑ Ó #÷ð ÷<#ð #ð  ×$Ó$Ùóó�÷;=ô ;=÷|ó ÷$5ð 5ð4 ò8ó ó8øñ}i #õ 	Ú%Ø@ÁÀ	ð J!Ù!" ð%óñ ðýð	ûñ@ õ 	ÚØgÑhtÐguÐvóáðýð	ûñxA õ 	vÚÑZÑ[kÐZlÐmÓnÑtuÐuýð	vûñ õ 	ZÚ Ñ!QÓRÑXYÐYýð	Zús|   ÓAA2 ×AB ùAB: ù4AC ÁA2	ABÁA;ABÁBABÁB	AB7ÁB!AB0ÁB0AB7ÁB:	ACÁCACÁCACÁC	AC9ÁC&AC2ÁC2AC9