code: 
  
  
  
  
  
  '''simple docstring'''
  
  from collections import Counter
  import datasets
  import transformers
  from transformers.convert_slow_tokenizer import SLOW_TO_FAST_CONVERTERS
  
  from transformers.utils import logging
  
  logging.set_verbosity_info()
  
  lowercase_			       =				{
      name: (getattr(transformers, name), getattr(transformers, name + """Fast""")) for name in SLOW_TO_FAST_CONVERTERS
  }
  
  lowercase_			       =				datasets.load_dataset("""xnli""", split="""test+validation""")
  
  lowercase_			       =				0
  lowercase_			       =				0
  lowercase_			       =				0
  lowercase_			       =				0
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					Optional[Any]      , __lowerCamelCase				:					Tuple      , __lowerCamelCase				:					List[str]      , __lowerCamelCase				:					Tuple					)		->Dict:
      if spm_diff == list(reversed(__lowerCamelCase					)					):
          # AAA -> AA+A vs A+AA case.
          return True
      elif len(__lowerCamelCase					) == len(__lowerCamelCase					) and fast.decode(__lowerCamelCase					) == fast.decode(__lowerCamelCase					):
          # Second order OK
          # Barrich -> Barr + ich vs Bar + rich
          return True
      _SCREAMING_SNAKE_CASE             =    slow.encode(slow.decode(__lowerCamelCase					)					)
      _SCREAMING_SNAKE_CASE             =    fast.encode(fast.decode(__lowerCamelCase					)					)
      if spm_reencoded != spm_diff and spm_reencoded == tok_reencoded:
          # Type 3 error.
          # Snehagatha ->
          #       Sne, h, aga, th, a
          #       Sne, ha, gat, ha
          # Encoding the wrong with sp does not even recover what spm gave us
          # It fits tokenizer however...
          return True
      return False
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					Optional[int]      , __lowerCamelCase				:					List[Any]      , __lowerCamelCase				:					Optional[int]					)		->Union[str, Any]:
      _SCREAMING_SNAKE_CASE             =    fast.encode_plus(__lowerCamelCase					)[0]
      _SCREAMING_SNAKE_CASE             =    enc.offsets
      _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    offsets[idx], offsets[idx - 1]
      if curr is not None and line[curr[0] : curr[1]] == "\u200f":
          return True
      if prev is not None and line[prev[0] : prev[1]] == "\u200f":
          return True
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					Dict      , __lowerCamelCase				:					Dict      , __lowerCamelCase				:					List[Any]      , __lowerCamelCase				:					Optional[int]      , __lowerCamelCase				:					Optional[int]					)		->List[str]:
      # Encoding can be the same with same result AAA -> A + AA vs AA + A
      # We can check that we use at least exactly the same number of tokens.
      for i, (spm_id, tok_id) in enumerate(zip(__lowerCamelCase      , __lowerCamelCase					)					):
          if spm_id != tok_id:
              break
      _SCREAMING_SNAKE_CASE             =    i
      for i, (spm_id, tok_id) in enumerate(zip(reversed(__lowerCamelCase					)      , reversed(__lowerCamelCase					)					)					):
          if spm_id != tok_id:
              break
      _SCREAMING_SNAKE_CASE             =    len(__lowerCamelCase					) - i
  
      _SCREAMING_SNAKE_CASE             =    spm_ids[first:last]
      _SCREAMING_SNAKE_CASE             =    tok_ids[first:last]
  
      if check_diff(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					):
          return True
  
      if check_LTR_mark(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					):
          return True
  
      if last - first > 5:
          # We might have twice a single problem, attempt to subdivide the disjointed tokens into smaller problems
          _SCREAMING_SNAKE_CASE             =    Counter(spm_ids[first:last]					)
          _SCREAMING_SNAKE_CASE             =    Counter(tok_ids[first:last]					)
  
          _SCREAMING_SNAKE_CASE             =    {spm_ for (spm_, si) in spms.items() if toks.get(spm_      , 0					) == si}
          _SCREAMING_SNAKE_CASE             =    3
          for i in range(last - first - min_width					):
              if all(spm_ids[first + i + j] in removable_tokens for j in range(__lowerCamelCase					)					):
                  _SCREAMING_SNAKE_CASE             =    [
                      k
                      for k in range(last - first - min_width					)
                      if tok_ids[first + k : first + k + min_width] == spm_ids[first + i : first + i + min_width]
                  ]
                  for j in possible_matches:
                      if check_diff(spm_ids[first : first + i]      , tok_ids[first : first + j]      , __lowerCamelCase      , __lowerCamelCase					) and check_details(
                          __lowerCamelCase      , spm_ids[first + i : last]      , tok_ids[first + j : last]      , __lowerCamelCase      , __lowerCamelCase      , ):
                          return True
  
      print(F'Spm: {[fast.decode([spm_ids[i]]					) for i in range(__lowerCamelCase      , __lowerCamelCase					)]}'					)
      try:
          print(F'Tok: {[fast.decode([tok_ids[i]]					) for i in range(__lowerCamelCase      , __lowerCamelCase					)]}'					)
      except Exception:
          pass
  
      _SCREAMING_SNAKE_CASE             =    fast.decode(spm_ids[:first]					)
      _SCREAMING_SNAKE_CASE             =    fast.decode(spm_ids[last:]					)
      _SCREAMING_SNAKE_CASE             =    fast.decode(spm_ids[first:last]					)
      print()
      print(__lowerCamelCase					)
      return False
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					Tuple      , __lowerCamelCase				:					List[Any]      , __lowerCamelCase				:					Union[str, Any]					)		->str:
      global perfect
      global imperfect
      global wrong
      global total
  
      _SCREAMING_SNAKE_CASE             =    slow.encode(__lowerCamelCase					)
      _SCREAMING_SNAKE_CASE             =    fast.encode(__lowerCamelCase					)
  
      _SCREAMING_SNAKE_CASE             =    False
      total += 1
  
      if slow_ids != fast_ids:
          if check_details(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					):
              _SCREAMING_SNAKE_CASE             =    True
              imperfect += 1
          else:
              wrong += 1
      else:
          perfect += 1
  
      if total % 1_0000 == 0:
          print(F'({perfect} / {imperfect} / {wrong} ----- {perfect + imperfect + wrong})'					)
  
      if skip_assert:
          return
  
      assert (
          slow_ids == fast_ids
      ), F'line {text} : \n\n{slow_ids}\n{fast_ids}\n\n{slow.tokenize(__lowerCamelCase					)}\n{fast.tokenize(__lowerCamelCase					)}'
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					Dict      , __lowerCamelCase				:					Union[str, Any]					)		->int:
      global batch_total
      for i in range(len(__lowerCamelCase					)					):
          # premise, all languages
          for text in dataset[i]["premise"].values():
              test_string(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					)
  
          # hypothesis, all languages
          for text in dataset[i]["hypothesis"]["translation"]:
              test_string(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					)
  
  
  if __name__ == "__main__":
        for name, (slow_class, fast_class) in TOKENIZER_CLASSES.items():
              lowercase_			       =				list(slow_class.max_model_input_sizes.keys())
              for checkpoint in checkpoint_names:
                    lowercase_			       =				0
                    lowercase_			       =				0
                    lowercase_			       =				0
                    lowercase_			       =				0
  
                    print(f"""========================== Checking {name}: {checkpoint} ==========================""")
                    lowercase_			       =				slow_class.from_pretrained(checkpoint, force_download=True)
                    lowercase_			       =				fast_class.from_pretrained(checkpoint, force_download=True)
                    test_tokenizer(slow, fast)
                    print(f"""Accuracy {perfect * 100 / total:.2f}""")
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  def lowerCamelCase		(  __lowerCamelCase				:					float      , __lowerCamelCase				:					float      , __lowerCamelCase				:					float					)		->list[int]:
      if hue < 0 or hue > 360:
          raise Exception("""hue should be between 0 and 360"""					)
  
      if saturation < 0 or saturation > 1:
          raise Exception("""saturation should be between 0 and 1"""					)
  
      if value < 0 or value > 1:
          raise Exception("""value should be between 0 and 1"""					)
  
      _SCREAMING_SNAKE_CASE             =    value * saturation
      _SCREAMING_SNAKE_CASE             =    hue / 60
      _SCREAMING_SNAKE_CASE             =    chroma * (1 - abs(hue_section % 2 - 1					))
      _SCREAMING_SNAKE_CASE             =    value - chroma
  
      if hue_section >= 0 and hue_section <= 1:
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
      elif hue_section > 1 and hue_section <= 2:
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
      elif hue_section > 2 and hue_section <= 3:
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
      elif hue_section > 3 and hue_section <= 4:
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
      elif hue_section > 4 and hue_section <= 5:
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
      else:
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
  
      return [red, green, blue]
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int      , __lowerCamelCase				:					int      , __lowerCamelCase				:					int					)		->list[float]:
      if red < 0 or red > 255:
          raise Exception("""red should be between 0 and 255"""					)
  
      if green < 0 or green > 255:
          raise Exception("""green should be between 0 and 255"""					)
  
      if blue < 0 or blue > 255:
          raise Exception("""blue should be between 0 and 255"""					)
  
      _SCREAMING_SNAKE_CASE             =    red / 255
      _SCREAMING_SNAKE_CASE             =    green / 255
      _SCREAMING_SNAKE_CASE             =    blue / 255
      _SCREAMING_SNAKE_CASE             =    max(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					)
      _SCREAMING_SNAKE_CASE             =    value - min(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					)
      _SCREAMING_SNAKE_CASE             =    0 if value == 0 else chroma / value
  
      if chroma == 0:
          _SCREAMING_SNAKE_CASE             =    0.0
      elif value == float_red:
          _SCREAMING_SNAKE_CASE             =    60 * (0 + (float_green - float_blue) / chroma)
      elif value == float_green:
          _SCREAMING_SNAKE_CASE             =    60 * (2 + (float_blue - float_red) / chroma)
      else:
          _SCREAMING_SNAKE_CASE             =    60 * (4 + (float_red - float_green) / chroma)
  
      _SCREAMING_SNAKE_CASE             =    (hue + 360) % 360
  
      return [hue, saturation, value]
  
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					list[float]      , __lowerCamelCase				:					list[float]					)		->bool:
      _SCREAMING_SNAKE_CASE             =    abs(hsv_a[0] - hsv_a[0]					) < 0.2
      _SCREAMING_SNAKE_CASE             =    abs(hsv_a[1] - hsv_a[1]					) < 0.002
      _SCREAMING_SNAKE_CASE             =    abs(hsv_a[2] - hsv_a[2]					) < 0.002
  
      return check_hue and check_saturation and check_value
  
  
  
  