
from typing import Dict, Optional

import numpy as np

import datasets


_lowerCamelCase	:    Union[str, Any]          =      """
IoU is the area of overlap between the predicted segmentation and the ground truth divided by the area of union
between the predicted segmentation and the ground truth. For binary (two classes) or multi-class segmentation,
the mean IoU of the image is calculated by taking the IoU of each class and averaging them.
"""

_lowerCamelCase	:    Optional[Any]          =      """
Args:
    predictions (`List[ndarray]`):
        List of predicted segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.
    references (`List[ndarray]`):
        List of ground truth segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.
    num_labels (`int`):
        Number of classes (categories).
    ignore_index (`int`):
        Index that will be ignored during evaluation.
    nan_to_num (`int`, *optional*):
        If specified, NaN values will be replaced by the number defined by the user.
    label_map (`dict`, *optional*):
        If specified, dictionary mapping old label indices to new label indices.
    reduce_labels (`bool`, *optional*, defaults to `False`):
        Whether or not to reduce all label values of segmentation maps by 1. Usually used for datasets where 0 is used for background,
        and background itself is not included in all classes of a dataset (e.g. ADE20k). The background label will be replaced by 255.

Returns:
    `Dict[str, float | ndarray]` comprising various elements:
    - *mean_iou* (`float`):
        Mean Intersection-over-Union (IoU averaged over all categories).
    - *mean_accuracy* (`float`):
        Mean accuracy (averaged over all categories).
    - *overall_accuracy* (`float`):
        Overall accuracy on all images.
    - *per_category_accuracy* (`ndarray` of shape `(num_labels,)`):
        Per category accuracy.
    - *per_category_iou* (`ndarray` of shape `(num_labels,)`):
        Per category IoU.

Examples:

    >>> import numpy as np

    >>> mean_iou = datasets.load_metric(\"mean_iou\")

    >>> # suppose one has 3 different segmentation maps predicted
    >>> predicted_1 = np.array([[1, 2], [3, 4], [5, 255]])
    >>> actual_1 = np.array([[0, 3], [5, 4], [6, 255]])

    >>> predicted_2 = np.array([[2, 7], [9, 2], [3, 6]])
    >>> actual_2 = np.array([[1, 7], [9, 2], [3, 6]])

    >>> predicted_3 = np.array([[2, 2, 3], [8, 2, 4], [3, 255, 2]])
    >>> actual_3 = np.array([[1, 2, 2], [8, 2, 1], [3, 255, 1]])

    >>> predicted = [predicted_1, predicted_2, predicted_3]
    >>> ground_truth = [actual_1, actual_2, actual_3]

    >>> results = mean_iou.compute(predictions=predicted, references=ground_truth, num_labels=10, ignore_index=255, reduce_labels=False)
    >>> print(results) # doctest: +NORMALIZE_WHITESPACE
    {'mean_iou': 0.47750000000000004, 'mean_accuracy': 0.5916666666666666, 'overall_accuracy': 0.5263157894736842, 'per_category_iou': array([0.   , 0.   , 0.375, 0.4  , 0.5  , 0.   , 0.5  , 1.   , 1.   , 1.   ]), 'per_category_accuracy': array([0.        , 0.        , 0.75      , 0.66666667, 1.        , 0.        , 0.5       , 1.        , 1.        , 1.        ])}
"""

_lowerCamelCase	:    Optional[Any]          =      """\
@software{MMSegmentation_Contributors_OpenMMLab_Semantic_Segmentation_2020,
author = {{MMSegmentation Contributors}},
license = {Apache-2.0},
month = {7},
title = {{OpenMMLab Semantic Segmentation Toolbox and Benchmark}},
url = {https://github.com/open-mmlab/mmsegmentation},
year = {2020}
}"""






def 	a_		(	__lowercase       :     Tuple	, __lowercase       :     Union[str, Any]	, __lowercase       :     Optional[int]	, __lowercase       :     Dict	, __lowercase       :     Any = None	, __lowercase       :     Optional[Any] = False	, )			->  str:
			if label_map is not None:
						for old_id, new_id in label_map.items():
									_snake_case          =      new_id

    # turn into Numpy arrays
			_snake_case          =      np.array(__lowercase			)
			_snake_case          =      np.array(__lowercase			)

			if reduce_labels:
						_snake_case          =      255
						_snake_case          =      label - 1
						_snake_case          =      255

			_snake_case          =      label != ignore_index
			_snake_case          =      np.not_equal(__lowercase	, __lowercase			)
			_snake_case          =      pred_label[mask]
			_snake_case          =      np.array(__lowercase			)[mask]

			_snake_case          =      pred_label[pred_label == label]

			_snake_case          =      np.histogram(__lowercase	, bins=__lowercase	, range=(0, num_labels - 1)			)[0]
			_snake_case          =      np.histogram(__lowercase	, bins=__lowercase	, range=(0, num_labels - 1)			)[0]
			_snake_case          =      np.histogram(__lowercase	, bins=__lowercase	, range=(0, num_labels - 1)			)[0]

			_snake_case          =      area_pred_label + area_label - area_intersect

			return area_intersect, area_union, area_pred_label, area_label






def 	a_		(	__lowercase       :     List[str]	, __lowercase       :     int	, __lowercase       :     List[str]	, __lowercase       :     str	, __lowercase       :     Union[str, Any] = None	, __lowercase       :     Union[str, Any] = False	, )			->  Tuple:
			_snake_case          =      np.zeros((num_labels,)	, dtype=np.floataa			)
			_snake_case          =      np.zeros((num_labels,)	, dtype=np.floataa			)
			_snake_case          =      np.zeros((num_labels,)	, dtype=np.floataa			)
			_snake_case          =      np.zeros((num_labels,)	, dtype=np.floataa			)
			for result, gt_seg_map in zip(__lowercase	, __lowercase			):
						_snake_case     , _snake_case     , _snake_case     , _snake_case          =      intersect_and_union(
						    __lowercase	, __lowercase	, __lowercase	, __lowercase	, __lowercase	, __lowercase			)
						total_area_intersect += area_intersect
						total_area_union += area_union
						total_area_pred_label += area_pred_label
						total_area_label += area_label
			return total_area_intersect, total_area_union, total_area_pred_label, total_area_label






def 	a_		(	__lowercase       :     Optional[int]	, __lowercase       :     str	, __lowercase       :     Dict	, __lowercase       :     Tuple	, __lowercase       :     Optional[Any] = None	, __lowercase       :     List[str] = None	, __lowercase       :     Optional[int] = False	, )			->  Optional[int]:
			_snake_case     , _snake_case     , _snake_case     , _snake_case          =      total_intersect_and_union(
			    __lowercase	, __lowercase	, __lowercase	, __lowercase	, __lowercase	, __lowercase			)

			# compute metrics
			_snake_case          =      {}

			_snake_case          =      total_area_intersect.sum() / total_area_label.sum()
			_snake_case          =      total_area_intersect / total_area_union
			_snake_case          =      total_area_intersect / total_area_label

			_snake_case          =      np.nanmean(__lowercase			)
			_snake_case          =      np.nanmean(__lowercase			)
			_snake_case          =      all_acc
			_snake_case          =      iou
			_snake_case          =      acc

			if nan_to_num is not None:
						_snake_case          =      {metric: np.nan_to_num(__lowercase	, nan=__lowercase			) for metric, metric_value in metrics.items()}

			return metrics




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,_KWARGS_DESCRIPTION )
class        SCREAMING_SNAKE_CASE__					(     datasets.Metric ):





	'''simple docstring'''



	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


				return datasets.MetricInfo(
				    description=_DESCRIPTION      ,  citation=_CITATION      ,  inputs_description=_KWARGS_DESCRIPTION      ,  features=datasets.Features(
				        # 1st Seq - height dim, 2nd - width dim
				        {
				            'predictions': datasets.Sequence(datasets.Sequence(datasets.Value('uint16'     )     )     ),
				            'references': datasets.Sequence(datasets.Sequence(datasets.Value('uint16'     )     )     ),
				        }     )      ,  reference_urls=[
				        'https://github.com/open-mmlab/mmsegmentation/blob/71c201b1813267d78764f306a297ca717827c4bf/mmseg/core/evaluation/metrics.py'
				    ]      ,  )





	def 			A							(  self     :   List[Any]      ,  lowercase     :   Any      ,  lowercase     :   str      ,  lowercase     :   Tuple      ,  lowercase     :   List[str]      ,  lowercase     :   Dict = None      ,  lowercase     :   List[Any] = None      ,  lowercase     :   int = False      ,  ):


				'''simple docstring'''


				_snake_case          =      mean_iou(
				    results=__SCREAMING_SNAKE_CASE      ,  gt_seg_maps=__SCREAMING_SNAKE_CASE      ,  num_labels=__SCREAMING_SNAKE_CASE      ,  ignore_index=__SCREAMING_SNAKE_CASE      ,  nan_to_num=__SCREAMING_SNAKE_CASE      ,  label_map=__SCREAMING_SNAKE_CASE      ,  reduce_labels=__SCREAMING_SNAKE_CASE      ,  )
				return iou_result

import itertools
import json
import os
import unittest

from transformers import AddedToken, RobertaTokenizer, RobertaTokenizerFast
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase							,unittest.TestCase ):





	'''simple docstring'''



	_UpperCAmelCase	:		Tuple          = RobertaTokenizer
	_UpperCAmelCase	:		Dict          = RobertaTokenizerFast
	_UpperCAmelCase	:		List[Any]          = True
	_UpperCAmelCase	:		Any          = {"cls_token": "<s>"}



	def 			A							(  self     :   Dict     ):


				'''simple docstring'''


				super().setUp()

				# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
				_snake_case          =      [
				    'l',
				    'o',
				    'w',
				    'e',
				    'r',
				    's',
				    't',
				    'i',
				    'd',
				    'n',
				    '\u0120',
				    '\u0120l',
				    '\u0120n',
				    '\u0120lo',
				    '\u0120low',
				    'er',
				    '\u0120lowest',
				    '\u0120newer',
				    '\u0120wider',
				    '<unk>',
				]
				_snake_case          =      dict(zip(lowercase      ,  range(len(lowercase     )     )     )     )
				_snake_case          =      ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
				_snake_case          =      {'unk_token': '<unk>'}

				_snake_case          =      os.path.join(self.tmpdirname      ,  VOCAB_FILES_NAMES['vocab_file']     )
				_snake_case          =      os.path.join(self.tmpdirname      ,  VOCAB_FILES_NAMES['merges_file']     )
				with open(self.vocab_file      ,  'w'      ,  encoding='utf-8'     ) as fp:
							fp.write(json.dumps(lowercase     ) + '\n'     )
				with open(self.merges_file      ,  'w'      ,  encoding='utf-8'     ) as fp:
							fp.write('\n'.join(lowercase     )     )



	def 			A							(  self     :   List[str]      ,  **lowercase     :   List[str]     ):


				'''simple docstring'''


				kwargs.update(self.special_tokens_map     )
				return self.tokenizer_class.from_pretrained(self.tmpdirname      ,  **lowercase     )



	def 			A							(  self     :   List[str]      ,  **lowercase     :   int     ):


				'''simple docstring'''


				kwargs.update(self.special_tokens_map     )
				return RobertaTokenizerFast.from_pretrained(self.tmpdirname      ,  **lowercase     )



	def 			A							(  self     :   Optional[Any]      ,  lowercase     :   List[str]     ):


				'''simple docstring'''


				_snake_case          =      'lower newer'
				_snake_case          =      'lower newer'
				return input_text, output_text



	def 			A							(  self     :   str     ):


				'''simple docstring'''


				_snake_case          =      self.tokenizer_class(self.vocab_file      ,  self.merges_file      ,  **self.special_tokens_map     )
				_snake_case          =      'lower newer'
				_snake_case          =      ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er']
				_snake_case          =      tokenizer.tokenize(lowercase     )  # , add_prefix_space=True)
				self.assertListEqual(lowercase      ,  lowercase     )

				_snake_case          =      tokens + [tokenizer.unk_token]
				_snake_case          =      [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
				self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase     )      ,  lowercase     )



	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				_snake_case          =      self.get_tokenizer()

				self.assertListEqual(tokenizer.encode('Hello world!'      ,  add_special_tokens=lowercase     )      ,  [0, 31_414, 232, 328, 2]     )
				self.assertListEqual(
				    tokenizer.encode('Hello world! cécé herlolip 418'      ,  add_special_tokens=lowercase     )      ,  [0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]      ,  )



	@slow
	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				_snake_case          =      self.tokenizer_class.from_pretrained('roberta-base'     )

				_snake_case          =      tokenizer.encode('sequence builders'      ,  add_special_tokens=lowercase     )
				_snake_case          =      tokenizer.encode('multi-sequence build'      ,  add_special_tokens=lowercase     )

				_snake_case          =      tokenizer.encode(
				    'sequence builders'      ,  add_special_tokens=lowercase      ,  add_prefix_space=lowercase     )
				_snake_case          =      tokenizer.encode(
				    'sequence builders'      ,  'multi-sequence build'      ,  add_special_tokens=lowercase      ,  add_prefix_space=lowercase     )

				_snake_case          =      tokenizer.build_inputs_with_special_tokens(lowercase     )
				_snake_case          =      tokenizer.build_inputs_with_special_tokens(lowercase      ,  lowercase     )

				assert encoded_sentence == encoded_text_from_decode
				assert encoded_pair == encoded_pair_from_decode



	def 			A							(  self     :   int     ):


				'''simple docstring'''


				_snake_case          =      self.get_tokenizer()

				_snake_case          =      'Encode this sequence.'
				_snake_case          =      tokenizer.byte_encoder[' '.encode('utf-8'     )[0]]

				# Testing encoder arguments
				_snake_case          =      tokenizer.encode(lowercase      ,  add_special_tokens=lowercase      ,  add_prefix_space=lowercase     )
				_snake_case          =      tokenizer.convert_ids_to_tokens(encoded[0]     )[0]
				self.assertNotEqual(lowercase      ,  lowercase     )

				_snake_case          =      tokenizer.encode(lowercase      ,  add_special_tokens=lowercase      ,  add_prefix_space=lowercase     )
				_snake_case          =      tokenizer.convert_ids_to_tokens(encoded[0]     )[0]
				self.assertEqual(lowercase      ,  lowercase     )

				tokenizer.add_special_tokens({'bos_token': '<s>'}     )
				_snake_case          =      tokenizer.encode(lowercase      ,  add_special_tokens=lowercase     )
				_snake_case          =      tokenizer.convert_ids_to_tokens(encoded[1]     )[0]
				self.assertNotEqual(lowercase      ,  lowercase     )

				# Testing spaces after special tokens
				_snake_case          =      '<mask>'
				tokenizer.add_special_tokens(
				    {'mask_token': AddedToken(lowercase      ,  lstrip=lowercase      ,  rstrip=lowercase     )}     )  # mask token has a left space
				_snake_case          =      tokenizer.convert_tokens_to_ids(lowercase     )

				_snake_case          =      'Encode <mask> sequence'
				_snake_case          =      'Encode <mask>sequence'

				_snake_case          =      tokenizer.encode(lowercase     )
				_snake_case          =      encoded.index(lowercase     )
				_snake_case          =      tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]     )[0]
				self.assertEqual(lowercase      ,  lowercase     )

				_snake_case          =      tokenizer.encode(lowercase     )
				_snake_case          =      encoded.index(lowercase     )
				_snake_case          =      tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]     )[0]
				self.assertNotEqual(lowercase      ,  lowercase     )



	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				pass



	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
							with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''     ):
										_snake_case          =      self.rust_tokenizer_class.from_pretrained(lowercase      ,  **lowercase     )
										_snake_case          =      self.tokenizer_class.from_pretrained(lowercase      ,  **lowercase     )
										_snake_case          =      'A, <mask> AllenNLP sentence.'
										_snake_case          =      tokenizer_r.encode_plus(lowercase      ,  add_special_tokens=lowercase      ,  return_token_type_ids=lowercase     )
										_snake_case          =      tokenizer_p.encode_plus(lowercase      ,  add_special_tokens=lowercase      ,  return_token_type_ids=lowercase     )

										# token_type_ids should put 0 everywhere
										self.assertEqual(sum(tokens_r['token_type_ids']     )      ,  sum(tokens_p['token_type_ids']     )     )

										# attention_mask should put 1 everywhere, so sum over length should be 1
										self.assertEqual(
										    sum(tokens_r['attention_mask']     ) / len(tokens_r['attention_mask']     )      ,  sum(tokens_p['attention_mask']     ) / len(tokens_p['attention_mask']     )      ,  )

										_snake_case          =      tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids']     )
										_snake_case          =      tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids']     )

										# Rust correctly handles the space before the mask while python doesnt
										self.assertSequenceEqual(tokens_p['input_ids']      ,  [0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2]     )
										self.assertSequenceEqual(tokens_r['input_ids']      ,  [0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2]     )

										self.assertSequenceEqual(
										    lowercase      ,  ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']     )
										self.assertSequenceEqual(
										    lowercase      ,  ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']     )



	def 			A							(  self     :   str     ):


				'''simple docstring'''


				for trim_offsets, add_prefix_space in itertools.product([True, False]      ,  repeat=2     ):
							_snake_case          =      self.rust_tokenizer_class.from_pretrained(
							    self.tmpdirname      ,  use_fast=lowercase      ,  add_prefix_space=lowercase      ,  trim_offsets=lowercase     )

							_snake_case          =      json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()     )
							_snake_case          =      json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()     )

							self.assertEqual(pre_tokenizer_state['add_prefix_space']      ,  lowercase     )

							self.assertEqual(post_processor_state['add_prefix_space']      ,  lowercase     )
							self.assertEqual(post_processor_state['trim_offsets']      ,  lowercase     )





	def 			A							(  self     :   Union[str, Any]     ):


				'''simple docstring'''


				for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
							with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''     ):
										_snake_case          =      'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
										_snake_case          =      f'''{text_of_1_token} {text_of_1_token}'''

										_snake_case          =      self.rust_tokenizer_class.from_pretrained(
										    lowercase      ,  use_fast=lowercase      ,  add_prefix_space=lowercase      ,  trim_offsets=lowercase     )
										_snake_case          =      tokenizer_r(lowercase      ,  return_offsets_mapping=lowercase      ,  add_special_tokens=lowercase     )
										self.assertEqual(encoding.offset_mapping[0]      ,  (0, len(lowercase     ))     )
										self.assertEqual(
										    encoding.offset_mapping[1]      ,  (len(lowercase     ) + 1, len(lowercase     ) + 1 + len(lowercase     ))      ,  )

										_snake_case          =      self.rust_tokenizer_class.from_pretrained(
										    lowercase      ,  use_fast=lowercase      ,  add_prefix_space=lowercase      ,  trim_offsets=lowercase     )
										_snake_case          =      tokenizer_r(lowercase      ,  return_offsets_mapping=lowercase      ,  add_special_tokens=lowercase     )
										self.assertEqual(encoding.offset_mapping[0]      ,  (0, len(lowercase     ))     )
										self.assertEqual(
										    encoding.offset_mapping[1]      ,  (len(lowercase     ) + 1, len(lowercase     ) + 1 + len(lowercase     ))      ,  )

										_snake_case          =      self.rust_tokenizer_class.from_pretrained(
										    lowercase      ,  use_fast=lowercase      ,  add_prefix_space=lowercase      ,  trim_offsets=lowercase     )
										_snake_case          =      tokenizer_r(lowercase      ,  return_offsets_mapping=lowercase      ,  add_special_tokens=lowercase     )
										self.assertEqual(encoding.offset_mapping[0]      ,  (0, len(lowercase     ))     )
										self.assertEqual(
										    encoding.offset_mapping[1]      ,  (len(lowercase     ), len(lowercase     ) + 1 + len(lowercase     ))      ,  )

										_snake_case          =      self.rust_tokenizer_class.from_pretrained(
										    lowercase      ,  use_fast=lowercase      ,  add_prefix_space=lowercase      ,  trim_offsets=lowercase     )
										_snake_case          =      tokenizer_r(lowercase      ,  return_offsets_mapping=lowercase      ,  add_special_tokens=lowercase     )
										self.assertEqual(encoding.offset_mapping[0]      ,  (0, len(lowercase     ))     )
										self.assertEqual(
										    encoding.offset_mapping[1]      ,  (len(lowercase     ), len(lowercase     ) + 1 + len(lowercase     ))      ,  )

										_snake_case          =      f''' {text}'''

										# tokenizer_r = self.rust_tokenizer_class.from_pretrained(
										#     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
										# )
										# encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
										# self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
										# self.assertEqual(
										#     encoding.offset_mapping[1],
										#     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
										# )

										_snake_case          =      self.rust_tokenizer_class.from_pretrained(
										    lowercase      ,  use_fast=lowercase      ,  add_prefix_space=lowercase      ,  trim_offsets=lowercase     )
										_snake_case          =      tokenizer_r(lowercase      ,  return_offsets_mapping=lowercase      ,  add_special_tokens=lowercase     )
										self.assertEqual(encoding.offset_mapping[0]      ,  (1, 1 + len(lowercase     ))     )
										self.assertEqual(
										    encoding.offset_mapping[1]      ,  (1 + len(lowercase     ) + 1, 1 + len(lowercase     ) + 1 + len(lowercase     ))      ,  )

										_snake_case          =      self.rust_tokenizer_class.from_pretrained(
										    lowercase      ,  use_fast=lowercase      ,  add_prefix_space=lowercase      ,  trim_offsets=lowercase     )
										_snake_case          =      tokenizer_r(lowercase      ,  return_offsets_mapping=lowercase      ,  add_special_tokens=lowercase     )
										self.assertEqual(encoding.offset_mapping[0]      ,  (0, 1 + len(lowercase     ))     )
										self.assertEqual(
										    encoding.offset_mapping[1]      ,  (1 + len(lowercase     ), 1 + len(lowercase     ) + 1 + len(lowercase     ))      ,  )

										_snake_case          =      self.rust_tokenizer_class.from_pretrained(
										    lowercase      ,  use_fast=lowercase      ,  add_prefix_space=lowercase      ,  trim_offsets=lowercase     )
										_snake_case          =      tokenizer_r(lowercase      ,  return_offsets_mapping=lowercase      ,  add_special_tokens=lowercase     )
										self.assertEqual(encoding.offset_mapping[0]      ,  (0, 1 + len(lowercase     ))     )
										self.assertEqual(
										    encoding.offset_mapping[1]      ,  (1 + len(lowercase     ), 1 + len(lowercase     ) + 1 + len(lowercase     ))      ,  )