






'''simple docstring'''

import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / "utils"))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
      from test_module.custom_tokenization_fast import CustomTokenizerFast




class     A    (      unittest.TestCase						):






 """simple docstring"""





 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Dict					    =							0
 @slow
 def   _UpperCAmelCase       (							self ):
       for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
             UpperCamelCase_				:   Tuple					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase )
             self.assertIsNotNone(__lowerCAmelCase )
             self.assertIsInstance(__lowerCAmelCase			,     (BertTokenizer, BertTokenizerFast) )
             self.assertGreater(len(__lowerCAmelCase )			,     0 )

       for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
             UpperCamelCase_				:   Union[str, Any]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase )
             self.assertIsNotNone(__lowerCAmelCase )
             self.assertIsInstance(__lowerCAmelCase			,     (GPTaTokenizer, GPTaTokenizerFast) )
             self.assertGreater(len(__lowerCAmelCase )			,     0 )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Dict					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase )
       self.assertIsInstance(__lowerCAmelCase			,     (BertTokenizer, BertTokenizerFast) )
       self.assertEqual(tokenizer.vocab_size			,     12 )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Union[str, Any]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase )
       self.assertIsInstance(__lowerCAmelCase			,     (RobertaTokenizer, RobertaTokenizerFast) )
       self.assertEqual(tokenizer.vocab_size			,     20 )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   int					    =							AutoConfig.from_pretrained(__lowerCAmelCase )
       self.assertIsInstance(__lowerCAmelCase			,     __lowerCAmelCase )
       # Check that tokenizer_type ≠ model_type
       UpperCamelCase_				:   Dict					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase			,     config=__lowerCAmelCase )
       self.assertIsInstance(__lowerCAmelCase			,     (BertTokenizer, BertTokenizerFast) )
       self.assertEqual(tokenizer.vocab_size			,     12 )
 def   _UpperCAmelCase       (							self ):
       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy("""./tests/fixtures/vocab.txt"""			,     os.path.join(__lowerCAmelCase			,     """vocab.txt""" ) )

             UpperCamelCase_				:   Optional[Any]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase			,     tokenizer_type="""bert"""			,     use_fast=__lowerCAmelCase )
             self.assertIsInstance(__lowerCAmelCase			,     __lowerCAmelCase )

       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy("""./tests/fixtures/vocab.json"""			,     os.path.join(__lowerCAmelCase			,     """vocab.json""" ) )
             shutil.copy("""./tests/fixtures/merges.txt"""			,     os.path.join(__lowerCAmelCase			,     """merges.txt""" ) )

             UpperCamelCase_				:   Optional[int]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase			,     tokenizer_type="""gpt2"""			,     use_fast=__lowerCAmelCase )
             self.assertIsInstance(__lowerCAmelCase			,     __lowerCAmelCase )
 @require_tokenizers
 def   _UpperCAmelCase       (							self ):
       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy("""./tests/fixtures/vocab.txt"""			,     os.path.join(__lowerCAmelCase			,     """vocab.txt""" ) )

             UpperCamelCase_				:   Optional[Any]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase			,     tokenizer_type="""bert""" )
             self.assertIsInstance(__lowerCAmelCase			,     __lowerCAmelCase )

       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy("""./tests/fixtures/vocab.json"""			,     os.path.join(__lowerCAmelCase			,     """vocab.json""" ) )
             shutil.copy("""./tests/fixtures/merges.txt"""			,     os.path.join(__lowerCAmelCase			,     """merges.txt""" ) )

             UpperCamelCase_				:   Union[str, Any]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase			,     tokenizer_type="""gpt2""" )
             self.assertIsInstance(__lowerCAmelCase			,     __lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       with pytest.raises(__lowerCAmelCase ):
             AutoTokenizer.from_pretrained("""./"""			,     tokenizer_type="""xxx""" )
 @require_tokenizers
 def   _UpperCAmelCase       (							self ):
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             UpperCamelCase_				:   List[str]					    =							tokenizer_class.from_pretrained("""wietsedv/bert-base-dutch-cased""" )
             self.assertIsInstance(__lowerCAmelCase			,     (BertTokenizer, BertTokenizerFast) )

             if isinstance(__lowerCAmelCase			,     __lowerCAmelCase ):
                   self.assertEqual(tokenizer.basic_tokenizer.do_lower_case			,     __lowerCAmelCase )
             else:
                   self.assertEqual(tokenizer.do_lower_case			,     __lowerCAmelCase )

             self.assertEqual(tokenizer.model_max_length			,     5_12 )
 @require_tokenizers
 def   _UpperCAmelCase       (							self ):
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             with self.assertRaisesRegex(
                 __lowerCAmelCase			,     """julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier"""			,     ):
                   UpperCamelCase_				:   List[Any]					    =							tokenizer_class.from_pretrained("""julien-c/herlolip-not-exists""" )
 def   _UpperCAmelCase       (							self ):
       # tests: https://github.com/huggingface/transformers/pull/13251
       # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
       # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
       UpperCamelCase_				:   Optional[int]					    =							TOKENIZER_MAPPING.values()
       UpperCamelCase_				:   Any					    =							[]

       for slow_tok, fast_tok in tokenizers:
             if slow_tok is not None:
                   tokenizer_names.append(slow_tok.__name__ )

             if fast_tok is not None:
                   tokenizer_names.append(fast_tok.__name__ )

       for tokenizer_name in tokenizer_names:
             # must find the right class
             tokenizer_class_from_name(__lowerCAmelCase )
 @require_tokenizers
 def   _UpperCAmelCase       (							self ):
       self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""			,     use_fast=__lowerCAmelCase )			,     __lowerCAmelCase )
       self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased""" )			,     __lowerCAmelCase )
 @require_tokenizers
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Dict					    =							AutoTokenizer.from_pretrained("""distilbert-base-uncased"""			,     do_lower_case=__lowerCAmelCase )
       UpperCamelCase_				:   Optional[Any]					    =							"""Hello, world. How are you?"""
       UpperCamelCase_				:   Union[str, Any]					    =							tokenizer.tokenize(__lowerCAmelCase )
       self.assertEqual("""[UNK]"""			,     tokens[0] )

       UpperCamelCase_				:   Optional[Any]					    =							AutoTokenizer.from_pretrained("""microsoft/mpnet-base"""			,     do_lower_case=__lowerCAmelCase )
       UpperCamelCase_				:   str					    =							tokenizer.tokenize(__lowerCAmelCase )
       self.assertEqual("""[UNK]"""			,     tokens[0] )
 @require_tokenizers
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Tuple					    =							AutoTokenizer.from_pretrained("""robot-test/dummy-tokenizer-fast-with-model-config""" )
       self.assertEqual(type(__lowerCAmelCase )			,     __lowerCAmelCase )
       self.assertEqual(tokenizer.model_max_length			,     5_12 )
       self.assertEqual(tokenizer.vocab_size			,     3_00_00 )
       self.assertEqual(tokenizer.unk_token			,     """[UNK]""" )
       self.assertEqual(tokenizer.padding_side			,     """right""" )
       self.assertEqual(tokenizer.truncation_side			,     """right""" )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[Any]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase )
       self.assertIsInstance(__lowerCAmelCase			,     (BertTokenizer, BertTokenizerFast) )
       with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(__lowerCAmelCase )
             UpperCamelCase_				:   Dict					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase )

       self.assertIsInstance(__lowerCAmelCase			,     tokenizer.__class__ )
       self.assertEqual(tokenizera.vocab_size			,     12 )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   str					    =							AutoTokenizer.from_pretrained("""ctrl""" )
       # There is no fast CTRL so this always gives us a slow tokenizer.
       self.assertIsInstance(__lowerCAmelCase			,     __lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       # Check we can load the tokenizer config of an online model.
       UpperCamelCase_				:   List[str]					    =							get_tokenizer_config("""bert-base-cased""" )
       UpperCamelCase_				:   List[Any]					    =							config.pop("""_commit_hash"""			,     __lowerCAmelCase )
       # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
       self.assertEqual(__lowerCAmelCase			,     {"""do_lower_case""": False} )

       # This model does not have a tokenizer_config so we get back an empty dict.
       UpperCamelCase_				:   Optional[Any]					    =							get_tokenizer_config(__lowerCAmelCase )
       self.assertDictEqual(__lowerCAmelCase			,     {} )

       # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
       UpperCamelCase_				:   List[Any]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase )
       with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(__lowerCAmelCase )
             UpperCamelCase_				:   Tuple					    =							get_tokenizer_config(__lowerCAmelCase )

       # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
       self.assertEqual(config["""tokenizer_class"""]			,     """BertTokenizer""" )
 def   _UpperCAmelCase       (							self ):
       try:
             AutoConfig.register("""custom"""			,     __lowerCAmelCase )

             AutoTokenizer.register(__lowerCAmelCase			,     slow_tokenizer_class=__lowerCAmelCase )
             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(__lowerCAmelCase ):
                   AutoTokenizer.register(__lowerCAmelCase			,     slow_tokenizer_class=__lowerCAmelCase )

             UpperCamelCase_				:   Dict					    =							CustomTokenizer.from_pretrained(__lowerCAmelCase )
             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer.save_pretrained(__lowerCAmelCase )

                   UpperCamelCase_				:   Optional[Any]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase )
                   self.assertIsInstance(__lowerCAmelCase			,     __lowerCAmelCase )

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                   del TOKENIZER_MAPPING._extra_content[CustomConfig]
 @require_tokenizers
 def   _UpperCAmelCase       (							self ):
       try:
             AutoConfig.register("""custom"""			,     __lowerCAmelCase )

             # Can register in two steps
             AutoTokenizer.register(__lowerCAmelCase			,     slow_tokenizer_class=__lowerCAmelCase )
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]			,     (CustomTokenizer, None) )
             AutoTokenizer.register(__lowerCAmelCase			,     fast_tokenizer_class=__lowerCAmelCase )
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]			,     (CustomTokenizer, CustomTokenizerFast) )

             del TOKENIZER_MAPPING._extra_content[CustomConfig]
             # Can register in one step
             AutoTokenizer.register(
                 __lowerCAmelCase			,     slow_tokenizer_class=__lowerCAmelCase			,     fast_tokenizer_class=__lowerCAmelCase )
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]			,     (CustomTokenizer, CustomTokenizerFast) )

             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(__lowerCAmelCase ):
                   AutoTokenizer.register(__lowerCAmelCase			,     fast_tokenizer_class=__lowerCAmelCase )

             # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
             # and that model does not have a tokenizer.json
             with tempfile.TemporaryDirectory() as tmp_dir:
                   UpperCamelCase_				:   List[Any]					    =							BertTokenizerFast.from_pretrained(__lowerCAmelCase )
                   bert_tokenizer.save_pretrained(__lowerCAmelCase )
                   UpperCamelCase_				:   List[Any]					    =							CustomTokenizerFast.from_pretrained(__lowerCAmelCase )

             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer.save_pretrained(__lowerCAmelCase )

                   UpperCamelCase_				:   Optional[Any]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase )
                   self.assertIsInstance(__lowerCAmelCase			,     __lowerCAmelCase )

                   UpperCamelCase_				:   Tuple					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase			,     use_fast=__lowerCAmelCase )
                   self.assertIsInstance(__lowerCAmelCase			,     __lowerCAmelCase )

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                   del TOKENIZER_MAPPING._extra_content[CustomConfig]
 def   _UpperCAmelCase       (							self ):
       # If remote code is not set, we will time out when asking whether to load the model.
       with self.assertRaises(__lowerCAmelCase ):
             UpperCamelCase_				:   Any					    =							AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer""" )
       # If remote code is disabled, we can't load this config.
       with self.assertRaises(__lowerCAmelCase ):
             UpperCamelCase_				:   int					    =							AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,     trust_remote_code=__lowerCAmelCase )

       UpperCamelCase_				:   str					    =							AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""			,     trust_remote_code=__lowerCAmelCase )
       self.assertTrue(tokenizer.special_attribute_present )
       # Test tokenizer can be reloaded.
       with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(__lowerCAmelCase )
             UpperCamelCase_				:   int					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase			,     trust_remote_code=__lowerCAmelCase )
       self.assertTrue(reloaded_tokenizer.special_attribute_present )

       if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizerFast""" )
             self.assertEqual(reloaded_tokenizer.__class__.__name__			,     """NewTokenizerFast""" )

             # Test we can also load the slow version
             UpperCamelCase_				:   List[str]					    =							AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,     trust_remote_code=__lowerCAmelCase			,     use_fast=__lowerCAmelCase )
             self.assertTrue(tokenizer.special_attribute_present )
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizer""" )
             # Test tokenizer can be reloaded.
             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer.save_pretrained(__lowerCAmelCase )
                   UpperCamelCase_				:   str					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase			,     trust_remote_code=__lowerCAmelCase			,     use_fast=__lowerCAmelCase )
             self.assertEqual(reloaded_tokenizer.__class__.__name__			,     """NewTokenizer""" )
             self.assertTrue(reloaded_tokenizer.special_attribute_present )
       else:
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizer""" )
             self.assertEqual(reloaded_tokenizer.__class__.__name__			,     """NewTokenizer""" )
 @require_tokenizers
 def   _UpperCAmelCase       (							self ):




       class     A    (      SCREAMING_SNAKE_CASE__						):






        """simple docstring"""





        __a			:						Tuple      =						False






       class     A    (      SCREAMING_SNAKE_CASE__						):






        """simple docstring"""





        __a			:						Any      =						NewTokenizer
        __a			:						str      =						False

       try:
             AutoConfig.register("""custom"""			,     __lowerCAmelCase )
             AutoTokenizer.register(__lowerCAmelCase			,     slow_tokenizer_class=__lowerCAmelCase )
             AutoTokenizer.register(__lowerCAmelCase			,     fast_tokenizer_class=__lowerCAmelCase )
             # If remote code is not set, the default is to use local
             UpperCamelCase_				:   List[str]					    =							AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer""" )
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizerFast""" )
             self.assertFalse(tokenizer.special_attribute_present )
             UpperCamelCase_				:   int					    =							AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""			,     use_fast=__lowerCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizer""" )
             self.assertFalse(tokenizer.special_attribute_present )

             # If remote code is disabled, we load the local one.
             UpperCamelCase_				:   Tuple					    =							AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,     trust_remote_code=__lowerCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizerFast""" )
             self.assertFalse(tokenizer.special_attribute_present )
             UpperCamelCase_				:   Union[str, Any]					    =							AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,     trust_remote_code=__lowerCAmelCase			,     use_fast=__lowerCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizer""" )
             self.assertFalse(tokenizer.special_attribute_present )

             # If remote is enabled, we load from the Hub
             UpperCamelCase_				:   List[Any]					    =							AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,     trust_remote_code=__lowerCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizerFast""" )
             self.assertTrue(tokenizer.special_attribute_present )
             UpperCamelCase_				:   Dict					    =							AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,     trust_remote_code=__lowerCAmelCase			,     use_fast=__lowerCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizer""" )
             self.assertTrue(tokenizer.special_attribute_present )

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                   del TOKENIZER_MAPPING._extra_content[CustomConfig]
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Any					    =							AutoTokenizer.from_pretrained(
           """hf-internal-testing/test_dynamic_tokenizer_legacy"""			,     trust_remote_code=__lowerCAmelCase )
       self.assertTrue(tokenizer.special_attribute_present )
       if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizerFast""" )

             # Test we can also load the slow version
             UpperCamelCase_				:   List[Any]					    =							AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer_legacy"""			,     trust_remote_code=__lowerCAmelCase			,     use_fast=__lowerCAmelCase )
             self.assertTrue(tokenizer.special_attribute_present )
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizer""" )
       else:
             self.assertEqual(tokenizer.__class__.__name__			,     """NewTokenizer""" )
 def   _UpperCAmelCase       (							self ):
       with self.assertRaisesRegex(
           __lowerCAmelCase			,     """bert-base is not a local folder and is not a valid model identifier""" ):
             UpperCamelCase_				:   List[Any]					    =							AutoTokenizer.from_pretrained("""bert-base""" )
 def   _UpperCAmelCase       (							self ):
       with self.assertRaisesRegex(
           __lowerCAmelCase			,     R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)""" ):
             UpperCamelCase_				:   Optional[int]					    =							AutoTokenizer.from_pretrained(__lowerCAmelCase			,     revision="""aaaaaa""" )





 def   _UpperCAmelCase       (							self ):
       # Make sure we have cached the tokenizer.
       UpperCamelCase_				:   int					    =							AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert""" )
       with RequestCounter() as counter:
             UpperCamelCase_				:   Optional[int]					    =							AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert""" )
             self.assertEqual(counter.get_request_count			,     0 )
             self.assertEqual(counter.head_request_count			,     1 )
             self.assertEqual(counter.other_request_count			,     0 )














'''simple docstring'''

import random



def 							snake_case					(     a_							: int    ,   a_							: float    ,   a_							: bool = False	)       ->				dict:





      """simple docstring"""

      UpperCamelCase_				:   dict					    =							{i: [] for i in range(a_	)}

      # if probability is greater or equal than 1, then generate a complete graph
      if probability >= 1:
            return complete_graph(a_	)
      # if probability is lower or equal than 0, then return a graph without edges
      if probability <= 0:
            return graph

      # for each couple of nodes, add an edge from u to v
      # if the number randomly generated is greater than probability probability
      for i in range(a_	):
            for j in range(i + 1    ,   a_	):
                  if random.random() < probability:
                        graph[i].append(a_	)
                        if not directed:
                              # if the graph is undirected, add an edge in from j to i, either
                              graph[j].append(a_	)
      return graph



def 							snake_case					(     a_							: int	)       ->				dict:





      """simple docstring"""

      return {
          i: [j for j in range(a_	) if i != j] for i in range(a_	)
      }


if __name__ == "__main__":
      import doctest

      doctest.testmod()






