





"""simple docstring"""


def 					lowercase__    (					lowercase_			)					->		List[Any]:




      """simple docstring"""

      _UpperCamelCase      :	int						=       [0] * len(lowercase_			)
      _UpperCamelCase      :	List[str]						=       []
      _UpperCamelCase      :	Union[str, Any]						=       []
      _UpperCamelCase      :	str						=       0

      for values in graph.values():
            for i in values:
                  indegree[i] += 1

      for i in range(len(lowercase_			)			):
            if indegree[i] == 0:
                  queue.append(lowercase_			)

      while queue:
            _UpperCamelCase      :	Any						=       queue.pop(0			)
            cnt += 1
            topo.append(lowercase_			)
            for x in graph[vertex]:
                  indegree[x] -= 1
                  if indegree[x] == 0:
                        queue.append(lowercase_			)

      if cnt != len(lowercase_			):
            print("Cycle exists"			)
      else:
            print(lowercase_			)


# Adjacency List of Graph
lowerCamelCase__				  =   {0: [1, 2], 1: [3], 2: [3], 3: [4, 5], 4: [], 5: []}

topological_sort(graph)







"""simple docstring"""


import json
import os
import unittest

from transformers.models.roc_bert.tokenization_roc_bert import (
    VOCAB_FILES_NAMES,
    RoCBertBasicTokenizer,
    RoCBertTokenizer,
    RoCBertWordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english



@require_tokenizers
class      __SCREAMING_SNAKE_CASE    (						_UpperCamelCase		,  unittest.TestCase   ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__							:Union[str, Any]	     =					RoCBertTokenizer
  SCREAMING_SNAKE_CASE__							:Dict	     =					None
  SCREAMING_SNAKE_CASE__							:List[Any]	     =					False
  SCREAMING_SNAKE_CASE__							:Union[str, Any]	     =					True
  SCREAMING_SNAKE_CASE__							:Union[str, Any]	     =					filter_non_english

  def    __SCREAMING_SNAKE_CASE				(		self   :       str	)		->				Dict:
        super().setUp()

        _UpperCamelCase      :	Any						=       ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "你", "好", "是", "谁", "a", "b", "c", "d"]
        _UpperCamelCase      :	List[str]						=       {}
        _UpperCamelCase      :	Tuple						=       {}
        for i, value in enumerate(__a	):
              _UpperCamelCase      :	List[str]						=       i
              _UpperCamelCase      :	Optional[Any]						=       i
        _UpperCamelCase      :	Dict						=       os.path.join(self.tmpdirname					,   VOCAB_FILES_NAMES["vocab_file"]	)
        _UpperCamelCase      :	Optional[Any]						=       os.path.join(self.tmpdirname					,   VOCAB_FILES_NAMES["word_shape_file"]	)
        _UpperCamelCase      :	Any						=       os.path.join(self.tmpdirname					,   VOCAB_FILES_NAMES["word_pronunciation_file"]	)
        with open(self.vocab_file					,   "w"					,   encoding="utf-8"	) as vocab_writer:
              vocab_writer.write("".join([x + "\n" for x in vocab_tokens]	)	)
        with open(self.word_shape_file					,   "w"					,   encoding="utf-8"	) as word_shape_writer:
              json.dump(__a					,   __a					,   ensure_ascii=__a	)
        with open(self.word_pronunciation_file					,   "w"					,   encoding="utf-8"	) as word_pronunciation_writer:
              json.dump(__a					,   __a					,   ensure_ascii=__a	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				Optional[int]:
        _UpperCamelCase      :	Tuple						=       self.tokenizer_class(self.vocab_file					,   self.word_shape_file					,   self.word_pronunciation_file	)

        _UpperCamelCase      :	int						=       tokenizer.tokenize("你好[SEP]你是谁"	)
        self.assertListEqual(__a					,   ["你", "好", "[SEP]", "你", "是", "谁"]	)
        self.assertListEqual(tokenizer.convert_tokens_to_ids(__a	)					,   [5, 6, 2, 5, 7, 8]	)
        self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(__a	)					,   [5, 6, 2, 5, 7, 8]	)
        self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(__a	)					,   [5, 6, 2, 5, 7, 8]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Dict	)		->				Dict:
        _UpperCamelCase      :	Dict						=       RoCBertBasicTokenizer()

        self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"	)					,   ["ah", "\u535A", "\u63A8", "zz"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[str]	)		->				Any:
        _UpperCamelCase      :	List[Any]						=       RoCBertBasicTokenizer(do_lower_case=__a	)

        self.assertListEqual(
            tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "	)					,   ["hello", "!", "how", "are", "you", "?"]	)
        self.assertListEqual(tokenizer.tokenize("H\u00E9llo"	)					,   ["hello"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[Any]	)		->				Tuple:
        _UpperCamelCase      :	Optional[Any]						=       RoCBertBasicTokenizer(do_lower_case=__a					,   strip_accents=__a	)

        self.assertListEqual(
            tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "	)					,   ["hällo", "!", "how", "are", "you", "?"]	)
        self.assertListEqual(tokenizer.tokenize("H\u00E9llo"	)					,   ["h\u00E9llo"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Dict	)		->				str:
        _UpperCamelCase      :	Dict						=       RoCBertBasicTokenizer(do_lower_case=__a					,   strip_accents=__a	)

        self.assertListEqual(
            tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "	)					,   ["hallo", "!", "how", "are", "you", "?"]	)
        self.assertListEqual(tokenizer.tokenize("H\u00E9llo"	)					,   ["hello"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Union[str, Any]	)		->				Union[str, Any]:
        _UpperCamelCase      :	List[str]						=       RoCBertBasicTokenizer(do_lower_case=__a	)

        self.assertListEqual(
            tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "	)					,   ["hallo", "!", "how", "are", "you", "?"]	)
        self.assertListEqual(tokenizer.tokenize("H\u00E9llo"	)					,   ["hello"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       str	)		->				Optional[int]:
        _UpperCamelCase      :	Tuple						=       RoCBertBasicTokenizer(do_lower_case=__a	)

        self.assertListEqual(
            tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "	)					,   ["HeLLo", "!", "how", "Are", "yoU", "?"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[str]	)		->				List[str]:
        _UpperCamelCase      :	Union[str, Any]						=       RoCBertBasicTokenizer(do_lower_case=__a					,   strip_accents=__a	)

        self.assertListEqual(
            tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "	)					,   ["HäLLo", "!", "how", "Are", "yoU", "?"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Tuple	)		->				List[Any]:
        _UpperCamelCase      :	Tuple						=       RoCBertBasicTokenizer(do_lower_case=__a					,   strip_accents=__a	)

        self.assertListEqual(
            tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "	)					,   ["HaLLo", "!", "how", "Are", "yoU", "?"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[Any]	)		->				int:
        _UpperCamelCase      :	int						=       RoCBertBasicTokenizer(do_lower_case=__a					,   never_split=["[UNK]"]	)

        self.assertListEqual(
            tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"	)					,   ["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[str]	)		->				Optional[Any]:
        _UpperCamelCase      :	Optional[int]						=       ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

        _UpperCamelCase      :	Any						=       {}
        for i, token in enumerate(__a	):
              _UpperCamelCase      :	str						=       i
        _UpperCamelCase      :	Optional[int]						=       RoCBertWordpieceTokenizer(vocab=__a					,   unk_token="[UNK]"	)

        self.assertListEqual(tokenizer.tokenize(""	)					,   []	)

        self.assertListEqual(tokenizer.tokenize("unwanted running"	)					,   ["un", "##want", "##ed", "runn", "##ing"]	)

        self.assertListEqual(tokenizer.tokenize("unwantedX running"	)					,   ["[UNK]", "runn", "##ing"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Dict	)		->				Optional[Any]:
        self.assertTrue(_is_whitespace(" "	)	)
        self.assertTrue(_is_whitespace("\t"	)	)
        self.assertTrue(_is_whitespace("\r"	)	)
        self.assertTrue(_is_whitespace("\n"	)	)
        self.assertTrue(_is_whitespace("\u00A0"	)	)

        self.assertFalse(_is_whitespace("A"	)	)
        self.assertFalse(_is_whitespace("-"	)	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Any	)		->				Dict:
        self.assertTrue(_is_control("\u0005"	)	)

        self.assertFalse(_is_control("A"	)	)
        self.assertFalse(_is_control(" "	)	)
        self.assertFalse(_is_control("\t"	)	)
        self.assertFalse(_is_control("\r"	)	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[int]	)		->				Optional[int]:
        self.assertTrue(_is_punctuation("-"	)	)
        self.assertTrue(_is_punctuation("$"	)	)
        self.assertTrue(_is_punctuation("`"	)	)
        self.assertTrue(_is_punctuation("."	)	)

        self.assertFalse(_is_punctuation("A"	)	)
        self.assertFalse(_is_punctuation(" "	)	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				List[Any]:
        _UpperCamelCase      :	Optional[Any]						=       self.get_tokenizer()

        # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
        self.assertListEqual([tokenizer.tokenize(__a	) for t in ["Test", "\xad", "test"]]					,   [["[UNK]"], [], ["[UNK]"]]	)

        if self.test_rust_tokenizer:
              _UpperCamelCase      :	Tuple						=       self.get_rust_tokenizer()
              self.assertListEqual(
                  [rust_tokenizer.tokenize(__a	) for t in ["Test", "\xad", "test"]]					,   [["[UNK]"], [], ["[UNK]"]]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Tuple	)		->				Optional[Any]:
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''	):
                    _UpperCamelCase      :	int						=       self.rust_tokenizer_class.from_pretrained(__a					,   **__a	)

                    _UpperCamelCase      :	Union[str, Any]						=       F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
                    _UpperCamelCase      :	Optional[Any]						=       tokenizer_r.encode_plus(
                        __a					,   return_attention_mask=__a					,   return_token_type_ids=__a					,   return_offsets_mapping=__a					,   add_special_tokens=__a					,   )

                    _UpperCamelCase      :	List[Any]						=       tokenizer_r.do_lower_case if hasattr(__a					,   "do_lower_case"	) else False
                    _UpperCamelCase      :	Dict						=       (
                        [
                            ((0, 0), tokenizer_r.cls_token),
                            ((0, 1), "A"),
                            ((1, 2), ","),
                            ((3, 5), "na"),
                            ((5, 6), "##ï"),
                            ((6, 8), "##ve"),
                            ((9, 15), tokenizer_r.mask_token),
                            ((16, 21), "Allen"),
                            ((21, 23), "##NL"),
                            ((23, 24), "##P"),
                            ((25, 33), "sentence"),
                            ((33, 34), "."),
                            ((0, 0), tokenizer_r.sep_token),
                        ]
                        if not do_lower_case
                        else [
                            ((0, 0), tokenizer_r.cls_token),
                            ((0, 1), "a"),
                            ((1, 2), ","),
                            ((3, 8), "naive"),
                            ((9, 15), tokenizer_r.mask_token),
                            ((16, 21), "allen"),
                            ((21, 23), "##nl"),
                            ((23, 24), "##p"),
                            ((25, 33), "sentence"),
                            ((33, 34), "."),
                            ((0, 0), tokenizer_r.sep_token),
                        ]
                    )

                    self.assertEqual(
                        [e[1] for e in expected_results]					,   tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]	)	)
                    self.assertEqual([e[0] for e in expected_results]					,   tokens["offset_mapping"]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				List[Any]:
        _UpperCamelCase      :	Optional[Any]						=       ["的", "人", "有"]
        _UpperCamelCase      :	int						=       "".join(__a	)
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''	):
                    _UpperCamelCase      :	int						=       True
                    _UpperCamelCase      :	Any						=       self.tokenizer_class.from_pretrained(__a					,   **__a	)
                    _UpperCamelCase      :	Optional[Any]						=       self.rust_tokenizer_class.from_pretrained(__a					,   **__a	)

                    _UpperCamelCase      :	int						=       tokenizer_p.encode(__a					,   add_special_tokens=__a	)
                    _UpperCamelCase      :	int						=       tokenizer_r.encode(__a					,   add_special_tokens=__a	)

                    _UpperCamelCase      :	List[Any]						=       tokenizer_r.convert_ids_to_tokens(__a	)
                    _UpperCamelCase      :	Union[str, Any]						=       tokenizer_p.convert_ids_to_tokens(__a	)

                    # it is expected that each Chinese character is not preceded by "##"
                    self.assertListEqual(__a					,   __a	)
                    self.assertListEqual(__a					,   __a	)

                    _UpperCamelCase      :	Any						=       False
                    _UpperCamelCase      :	Dict						=       self.rust_tokenizer_class.from_pretrained(__a					,   **__a	)
                    _UpperCamelCase      :	Any						=       self.tokenizer_class.from_pretrained(__a					,   **__a	)

                    _UpperCamelCase      :	Any						=       tokenizer_r.encode(__a					,   add_special_tokens=__a	)
                    _UpperCamelCase      :	Any						=       tokenizer_p.encode(__a					,   add_special_tokens=__a	)

                    _UpperCamelCase      :	Union[str, Any]						=       tokenizer_r.convert_ids_to_tokens(__a	)
                    _UpperCamelCase      :	Dict						=       tokenizer_p.convert_ids_to_tokens(__a	)

                    # it is expected that only the first Chinese character is not preceded by "##".
                    _UpperCamelCase      :	Any						=       [
                        F'''##{token}''' if idx != 0 else token for idx, token in enumerate(__a	)
                    ]
                    self.assertListEqual(__a					,   __a	)
                    self.assertListEqual(__a					,   __a	)

  @slow
  def    __SCREAMING_SNAKE_CASE				(		self   :       Union[str, Any]	)		->				Any:
        _UpperCamelCase      :	Dict						=       self.tokenizer_class(self.vocab_file					,   self.word_shape_file					,   self.word_pronunciation_file	)

        _UpperCamelCase      :	Optional[int]						=       tokenizer.encode("你好"					,   add_special_tokens=__a	)
        _UpperCamelCase      :	Dict						=       tokenizer.encode("你是谁"					,   add_special_tokens=__a	)

        _UpperCamelCase      :	Union[str, Any]						=       tokenizer.build_inputs_with_special_tokens(__a	)
        _UpperCamelCase      :	Tuple						=       tokenizer.build_inputs_with_special_tokens(__a					,   __a	)

        assert encoded_sentence == [1] + text + [2]
        assert encoded_pair == [1] + text + [2] + text_a + [2]


  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[Any]	)		->				int:
        _UpperCamelCase      :	Optional[Any]						=       self.get_tokenizers(do_lower_case=__a	)
        for tokenizer in tokenizers:
              with self.subTest(F'''{tokenizer.__class__.__name__}'''	):
                    _UpperCamelCase      :	int						=       "你好，你是谁"
                    _UpperCamelCase      :	Any						=       tokenizer.tokenize(__a	)
                    _UpperCamelCase      :	Optional[Any]						=       tokenizer.convert_tokens_to_ids(__a	)
                    _UpperCamelCase      :	List[str]						=       tokenizer.convert_tokens_to_shape_ids(__a	)
                    _UpperCamelCase      :	Any						=       tokenizer.convert_tokens_to_pronunciation_ids(__a	)
                    _UpperCamelCase      :	Optional[int]						=       tokenizer.prepare_for_model(
                        __a					,   __a					,   __a					,   add_special_tokens=__a	)

                    _UpperCamelCase      :	Tuple						=       tokenizer.encode_plus(__a					,   add_special_tokens=__a	)

                    self.assertEqual(__a					,   __a	)
