import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY
@is_pipeline_test
class  A_			(							unittest.TestCase			):
  _SCREAMING_SNAKE_CASE     					=      MODEL_FOR_MASKED_LM_MAPPING
  _SCREAMING_SNAKE_CASE     					=      TF_MODEL_FOR_MASKED_LM_MAPPING

  def 		_UpperCAmelCase (		self			:   int							):
   super().tearDown()
   # clean-up as much as possible GPU memory occupied by PyTorch
   gc.collect()
   if is_torch_available():
    import torch

    torch.cuda.empty_cache()

  @require_tf
  def 		_UpperCAmelCase (		self			:   Tuple							):
   __a							=	pipeline(task="fill-mask"  ,				model="sshleifer/tiny-distilroberta-base"  ,				top_k=2  ,				framework="tf"							)
   __a							=	unmasker("My name is <mask>"							)
   self.assertEqual(
       nested_simplify(_UpperCAmelCase  ,				decimals=6							)  ,				[
           {"sequence": "My name is grouped", "score": 2.1E-05, "token": 3_80_15, "token_str": " grouped"},
           {"sequence": "My name is accuser", "score": 2.1E-05, "token": 2_55_06, "token_str": " accuser"},
       ]  ,				)

   __a							=	unmasker("The largest city in France is <mask>"							)
   self.assertEqual(
       nested_simplify(_UpperCAmelCase  ,				decimals=6							)  ,				[
           {
               "sequence": "The largest city in France is grouped",
               "score": 2.1E-05,
               "token": 3_80_15,
               "token_str": " grouped",
           },
           {
               "sequence": "The largest city in France is accuser",
               "score": 2.1E-05,
               "token": 2_55_06,
               "token_str": " accuser",
           },
       ]  ,				)

   __a							=	unmasker("My name is <mask>"  ,				targets=[" Patrick", " Clara", " Teven"]  ,				top_k=3							)
   self.assertEqual(
       nested_simplify(_UpperCAmelCase  ,				decimals=6							)  ,				[
           {"sequence": "My name is Clara", "score": 2E-05, "token": 1_36_06, "token_str": " Clara"},
           {"sequence": "My name is Patrick", "score": 2E-05, "token": 34_99, "token_str": " Patrick"},
           {"sequence": "My name is Te", "score": 1.9E-05, "token": 29_41, "token_str": " Te"},
       ]  ,				)

  @require_torch
  def 		_UpperCAmelCase (		self			:   Dict							):
   __a							=	pipeline(task="fill-mask"  ,				model="sshleifer/tiny-distilroberta-base"  ,				top_k=2  ,				framework="pt"							)

   __a							=	unmasker("My name is <mask>"							)
   self.assertEqual(
       nested_simplify(_UpperCAmelCase  ,				decimals=6							)  ,				[
           {"sequence": "My name is Maul", "score": 2.2E-05, "token": 3_56_76, "token_str": " Maul"},
           {"sequence": "My name isELS", "score": 2.2E-05, "token": 1_64_16, "token_str": "ELS"},
       ]  ,				)

   __a							=	unmasker("The largest city in France is <mask>"							)
   self.assertEqual(
       nested_simplify(_UpperCAmelCase  ,				decimals=6							)  ,				[
           {
               "sequence": "The largest city in France is Maul",
               "score": 2.2E-05,
               "token": 3_56_76,
               "token_str": " Maul",
           },
           {"sequence": "The largest city in France isELS", "score": 2.2E-05, "token": 1_64_16, "token_str": "ELS"},
       ]  ,				)

   __a							=	unmasker("My name is <mask>"  ,				targets=[" Patrick", " Clara", " Teven"]  ,				top_k=3							)
   self.assertEqual(
       nested_simplify(_UpperCAmelCase  ,				decimals=6							)  ,				[
           {"sequence": "My name is Patrick", "score": 2.1E-05, "token": 34_99, "token_str": " Patrick"},
           {"sequence": "My name is Te", "score": 2E-05, "token": 29_41, "token_str": " Te"},
           {"sequence": "My name is Clara", "score": 2E-05, "token": 1_36_06, "token_str": " Clara"},
       ]  ,				)

   __a							=	unmasker("My name is <mask> <mask>"  ,				top_k=2							)

   self.assertEqual(
       nested_simplify(_UpperCAmelCase  ,				decimals=6							)  ,				[
           [
               {
                   "score": 2.2E-05,
                   "token": 3_56_76,
                   "token_str": " Maul",
                   "sequence": "<s>My name is Maul<mask></s>",
               },
               {"score": 2.2E-05, "token": 1_64_16, "token_str": "ELS", "sequence": "<s>My name isELS<mask></s>"},
           ],
           [
               {
                   "score": 2.2E-05,
                   "token": 3_56_76,
                   "token_str": " Maul",
                   "sequence": "<s>My name is<mask> Maul</s>",
               },
               {"score": 2.2E-05, "token": 1_64_16, "token_str": "ELS", "sequence": "<s>My name is<mask>ELS</s>"},
           ],
       ]  ,				)

  @require_torch_gpu
  def 		_UpperCAmelCase (		self			:   Any							):
   __a							=	pipeline("fill-mask"  ,				model="hf-internal-testing/tiny-random-distilbert"  ,				device=0  ,				framework="pt"							)

   # convert model to fp16
   pipe.model.half()

   __a							=	pipe("Paris is the [MASK] of France."							)
   # We actually don't care about the result, we just want to make sure
   # it works, meaning the float16 tensor got casted back to float32
   # for postprocessing.
   self.assertIsInstance(_UpperCAmelCase  ,				_UpperCAmelCase							)

  @slow
  @require_torch
  def 		_UpperCAmelCase (		self			:   Optional[Any]							):
   __a							=	pipeline(task="fill-mask"  ,				model="distilroberta-base"  ,				top_k=2  ,				framework="pt"							)
   self.run_large_test(_UpperCAmelCase							)

  @slow
  @require_tf
  def 		_UpperCAmelCase (		self			:   int							):
   __a							=	pipeline(task="fill-mask"  ,				model="distilroberta-base"  ,				top_k=2  ,				framework="tf"							)
   self.run_large_test(_UpperCAmelCase							)

  def 		_UpperCAmelCase (		self			:   int  ,				__SCREAMING_SNAKE_CASE			:   str							):
   __a							=	unmasker("My name is <mask>"							)
   self.assertEqual(
       nested_simplify(_UpperCAmelCase							)  ,				[
           {"sequence": "My name is John", "score": 0.0_08, "token": 6_10, "token_str": " John"},
           {"sequence": "My name is Chris", "score": 0.0_07, "token": 15_73, "token_str": " Chris"},
       ]  ,				)
   __a							=	unmasker("The largest city in France is <mask>"							)
   self.assertEqual(
       nested_simplify(_UpperCAmelCase							)  ,				[
           {
               "sequence": "The largest city in France is Paris",
               "score": 0.2_51,
               "token": 22_01,
               "token_str": " Paris",
           },
           {
               "sequence": "The largest city in France is Lyon",
               "score": 0.2_14,
               "token": 1_27_90,
               "token_str": " Lyon",
           },
       ]  ,				)

   __a							=	unmasker("My name is <mask>"  ,				targets=[" Patrick", " Clara", " Teven"]  ,				top_k=3							)
   self.assertEqual(
       nested_simplify(_UpperCAmelCase							)  ,				[
           {"sequence": "My name is Patrick", "score": 0.0_05, "token": 34_99, "token_str": " Patrick"},
           {"sequence": "My name is Clara", "score": 0.0_00, "token": 1_36_06, "token_str": " Clara"},
           {"sequence": "My name is Te", "score": 0.0_00, "token": 29_41, "token_str": " Te"},
       ]  ,				)

  @require_torch
  def 		_UpperCAmelCase (		self			:   List[Any]							):
   __a							=	pipeline(task="fill-mask"  ,				model="sshleifer/tiny-distilroberta-base"  ,				framework="pt"							)
   __a							=	None
   __a							=	None
   self.run_pipeline_test(_UpperCAmelCase  ,				[]							)

  @require_tf
  def 		_UpperCAmelCase (		self			:   Optional[Any]							):
   __a							=	pipeline(task="fill-mask"  ,				model="sshleifer/tiny-distilroberta-base"  ,				framework="tf"							)
   __a							=	None
   __a							=	None
   self.run_pipeline_test(_UpperCAmelCase  ,				[]							)

  def 		_UpperCAmelCase (		self			:   Union[str, Any]  ,				__SCREAMING_SNAKE_CASE			:   str  ,				__SCREAMING_SNAKE_CASE			:   str  ,				__SCREAMING_SNAKE_CASE			:   List[Any]							):
   if tokenizer is None or tokenizer.mask_token_id is None:
    self.skipTest("The provided tokenizer has no mask token, (probably reformer or wav2vec2)"							)

   __a							=	FillMaskPipeline(model=_UpperCAmelCase  ,				tokenizer=_UpperCAmelCase							)
   __a							=	[
       f"""This is another {tokenizer.mask_token} test""",
   ]
   return fill_masker, examples

  def 		_UpperCAmelCase (		self			:   Dict  ,				__SCREAMING_SNAKE_CASE			:   Union[str, Any]  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]							):
   __a							=	fill_masker.tokenizer
   __a							=	fill_masker.model

   __a							=	fill_masker(
       f"""This is a {tokenizer.mask_token}"""  ,				)
   self.assertEqual(
       _UpperCAmelCase  ,				[
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
       ]  ,				)

   __a							=	fill_masker([f"""This is a {tokenizer.mask_token}"""]							)
   self.assertEqual(
       _UpperCAmelCase  ,				[
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
       ]  ,				)

   __a							=	fill_masker([f"""This is a {tokenizer.mask_token}""", f"""Another {tokenizer.mask_token} great test."""]							)
   self.assertEqual(
       _UpperCAmelCase  ,				[
           [
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           ],
           [
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           ],
       ]  ,				)

   with self.assertRaises(_UpperCAmelCase							):
    fill_masker([None]							)
   # No mask_token is not supported
   with self.assertRaises(_UpperCAmelCase							):
    fill_masker("This is"							)

   self.run_test_top_k(_UpperCAmelCase  ,				_UpperCAmelCase							)
   self.run_test_targets(_UpperCAmelCase  ,				_UpperCAmelCase							)
   self.run_test_top_k_targets(_UpperCAmelCase  ,				_UpperCAmelCase							)
   self.fill_mask_with_duplicate_targets_and_top_k(_UpperCAmelCase  ,				_UpperCAmelCase							)
   self.fill_mask_with_multiple_masks(_UpperCAmelCase  ,				_UpperCAmelCase							)

  def 		_UpperCAmelCase (		self			:   Dict  ,				__SCREAMING_SNAKE_CASE			:   Dict  ,				__SCREAMING_SNAKE_CASE			:   Tuple							):
   __a							=	tokenizer.get_vocab()
   __a							=	sorted(vocab.keys()							)[:2]
   # Pipeline argument
   __a							=	FillMaskPipeline(model=_UpperCAmelCase  ,				tokenizer=_UpperCAmelCase  ,				targets=_UpperCAmelCase							)
   __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""							)
   self.assertEqual(
       _UpperCAmelCase  ,				[
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
       ]  ,				)
   __a							=	{vocab[el] for el in targets}
   self.assertEqual({el["token"] for el in outputs}  ,				_UpperCAmelCase							)
   __a							=	[tokenizer.decode([x]							) for x in target_ids]
   self.assertEqual({el["token_str"] for el in outputs}  ,				set(_UpperCAmelCase							)							)

   # Call argument
   __a							=	FillMaskPipeline(model=_UpperCAmelCase  ,				tokenizer=_UpperCAmelCase							)
   __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""  ,				targets=_UpperCAmelCase							)
   self.assertEqual(
       _UpperCAmelCase  ,				[
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
       ]  ,				)
   __a							=	{vocab[el] for el in targets}
   self.assertEqual({el["token"] for el in outputs}  ,				_UpperCAmelCase							)
   __a							=	[tokenizer.decode([x]							) for x in target_ids]
   self.assertEqual({el["token_str"] for el in outputs}  ,				set(_UpperCAmelCase							)							)

   # Score equivalence
   __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""  ,				targets=_UpperCAmelCase							)
   __a							=	[top_mask["token_str"] for top_mask in outputs]
   __a							=	[top_mask["score"] for top_mask in outputs]

   # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
   if set(_UpperCAmelCase							) == set(_UpperCAmelCase							):
    __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""  ,				targets=_UpperCAmelCase							)
    __a							=	[top_mask["score"] for top_mask in unmasked_targets]
    self.assertEqual(nested_simplify(_UpperCAmelCase							)  ,				nested_simplify(_UpperCAmelCase							)							)

   # Raises with invalid
   with self.assertRaises(_UpperCAmelCase							):
    __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""  ,				targets=[]							)
   # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
   if "" not in tokenizer.get_vocab():
    with self.assertRaises(_UpperCAmelCase							):
     __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""  ,				targets=[""]							)
    with self.assertRaises(_UpperCAmelCase							):
     __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""  ,				targets=""							)

  def 		_UpperCAmelCase (		self			:   Optional[Any]  ,				__SCREAMING_SNAKE_CASE			:   Optional[int]  ,				__SCREAMING_SNAKE_CASE			:   Optional[int]							):
   __a							=	FillMaskPipeline(model=_UpperCAmelCase  ,				tokenizer=_UpperCAmelCase  ,				top_k=2							)
   __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""							)
   self.assertEqual(
       _UpperCAmelCase  ,				[
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
       ]  ,				)

   __a							=	FillMaskPipeline(model=_UpperCAmelCase  ,				tokenizer=_UpperCAmelCase							)
   __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""  ,				top_k=2							)
   self.assertEqual(
       _UpperCAmelCase  ,				[
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
       ]  ,				)
   self.assertEqual(nested_simplify(_UpperCAmelCase							)  ,				nested_simplify(_UpperCAmelCase							)							)

  def 		_UpperCAmelCase (		self			:   List[Any]  ,				__SCREAMING_SNAKE_CASE			:   Any  ,				__SCREAMING_SNAKE_CASE			:   Any							):
   __a							=	tokenizer.get_vocab()
   __a							=	FillMaskPipeline(model=_UpperCAmelCase  ,				tokenizer=_UpperCAmelCase							)

   # top_k=2, ntargets=3
   __a							=	sorted(vocab.keys()							)[:3]
   __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""  ,				top_k=2  ,				targets=_UpperCAmelCase							)

   # If we use the most probably targets, and filter differently, we should still
   # have the same results
   __a							=	[el["token_str"] for el in sorted(_UpperCAmelCase  ,				key=lambda __SCREAMING_SNAKE_CASE							: x["score"]  ,				reverse=_UpperCAmelCase							)]
   # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
   if set(_UpperCAmelCase							).issubset(_UpperCAmelCase							):
    __a							=	fill_masker(f"""This is a {tokenizer.mask_token}"""  ,				top_k=3  ,				targets=_UpperCAmelCase							)
    # They should yield exactly the same result
    self.assertEqual(nested_simplify(_UpperCAmelCase							)  ,				nested_simplify(_UpperCAmelCase							)							)

  def 		_UpperCAmelCase (		self			:   Optional[Any]  ,				__SCREAMING_SNAKE_CASE			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   List[Any]							):
   __a							=	FillMaskPipeline(model=_UpperCAmelCase  ,				tokenizer=_UpperCAmelCase							)
   __a							=	tokenizer.get_vocab()
   # String duplicates + id duplicates
   __a							=	sorted(vocab.keys()							)[:3]
   __a							=	[targets[0], targets[1], targets[0], targets[2], targets[1]]
   __a							=	fill_masker(f"""My name is {tokenizer.mask_token}"""  ,				targets=_UpperCAmelCase  ,				top_k=10							)

   # The target list contains duplicates, so we can't output more
   # than them
   self.assertEqual(len(_UpperCAmelCase							)  ,				3							)

  def 		_UpperCAmelCase (		self			:   str  ,				__SCREAMING_SNAKE_CASE			:   Dict  ,				__SCREAMING_SNAKE_CASE			:   int							):
   __a							=	FillMaskPipeline(model=_UpperCAmelCase  ,				tokenizer=_UpperCAmelCase							)

   __a							=	fill_masker(
       f"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"""  ,				top_k=2							)
   self.assertEqual(
       _UpperCAmelCase  ,				[
           [
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           ],
           [
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           ],
           [
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
               {"sequence": ANY(_UpperCAmelCase							), "score": ANY(_UpperCAmelCase							), "token": ANY(_UpperCAmelCase							), "token_str": ANY(_UpperCAmelCase							)},
           ],
       ]  ,				)










import re
from pathlib import Path
from unittest import TestCase

import pytest


@pytest.mark.integration
class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Dict:

     with open(_UpperCAmelCase		,		encoding='utf-8'			) as input_file:
        UpperCamelCase_						=  re.compile(R'(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)'			)
        UpperCamelCase_						=  input_file.read()
        UpperCamelCase_						=  regexp.search(_UpperCAmelCase			)

     return match




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Dict:

     with open(_UpperCAmelCase		,		encoding='utf-8'			) as input_file:
        UpperCamelCase_						=  re.compile(R'#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()'		,		re.DOTALL			)
        UpperCamelCase_						=  input_file.read()
        # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search`
        UpperCamelCase_						=  regexp.finditer(_UpperCAmelCase			)

     UpperCamelCase_						=  [match for match in matches if match is not None and match.group(1			) is not None]
     return matches[0] if matches else None




  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     UpperCamelCase_						=  Path('./datasets'			)
     UpperCamelCase_						=  list(dataset_paths.absolute().glob('**/*.py'			)			)

     for dataset in dataset_files:
        if self._no_encoding_on_file_open(str(_UpperCAmelCase			)			):
           raise AssertionError(f"""open(...) must use utf-8 encoding in {dataset}"""			)




  def  _UpperCAmelCase  (  self			)      ->			Optional[int]:
     UpperCamelCase_						=  Path('./datasets'			)
     UpperCamelCase_						=  list(dataset_paths.absolute().glob('**/*.py'			)			)

     for dataset in dataset_files:
        if self._no_print_statements(str(_UpperCAmelCase			)			):
           raise AssertionError(f"""print statement found in {dataset}. Use datasets.logger/logging instead."""			)





