code: 
  
  
  
  """simple docstring"""
  
  
  
  
  import unittest
  
  import numpy as np
  from datasets import load_dataset
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
  
  
  if is_torch_available():
   import torch
  
  if is_vision_available():
   from PIL import Image
  
   from transformers import SegformerImageProcessor
  
  
  
  
  
  
  class 			UpperCAmelCase_						(       unittest.TestCase		):
  
  
  
        def __init__(  self  :			List[Any]  ,			A  :			List[str]  ,			A  :			str=7  ,			A  :			List[Any]=3  ,			A  :			List[Any]=3_0  ,			A  :			List[Any]=4_0_0  ,			A  :			List[str]=True  ,			A  :			List[str]=None  ,			A  :			str=True  ,			A  :			Tuple=[0.5, 0.5, 0.5]  ,			A  :			Dict=[0.5, 0.5, 0.5]  ,			A  :			int=False  ,			):
             _UpperCAmelCase    :			Dict              =					size if size is not None else {"height": 3_0, "width": 3_0}
             _UpperCAmelCase    :			Tuple              =					parent
             _UpperCAmelCase    :			Dict              =					batch_size
             _UpperCAmelCase    :			List[str]              =					num_channels
             _UpperCAmelCase    :			str              =					min_resolution
             _UpperCAmelCase    :			Dict              =					max_resolution
             _UpperCAmelCase    :			Dict              =					do_resize
             _UpperCAmelCase    :			List[Any]              =					size
             _UpperCAmelCase    :			Tuple              =					do_normalize
             _UpperCAmelCase    :			str              =					image_mean
             _UpperCAmelCase    :			Optional[int]              =					image_std
             _UpperCAmelCase    :			Union[str, Any]              =					do_reduce_labels
  
  
  
        def 		snake_case_      (  self  :			Any		):
             return {
                 "do_resize": self.do_resize,
                 "size": self.size,
                 "do_normalize": self.do_normalize,
                 "image_mean": self.image_mean,
                 "image_std": self.image_std,
                 "do_reduce_labels": self.do_reduce_labels,
             }
  
  
  
  
  
  
  
  def 		__snake_case		(   )						->     List[Any]:
  
  
  
  
  
       '''simple docstring'''
  
       _UpperCAmelCase    :			Dict              =					load_dataset("hf-internal-testing/fixtures_ade20k"		,						split="test"       )
  
       _UpperCAmelCase    :			List[str]              =					Image.open(dataset[0]["file"]       )
       _UpperCAmelCase    :			Union[str, Any]              =					Image.open(dataset[1]["file"]       )
  
       return image, map
  
  def 		__snake_case		(   )						->     Dict:
  
  
  
  
  
       '''simple docstring'''
  
       _UpperCAmelCase    :			str              =					load_dataset("hf-internal-testing/fixtures_ade20k"		,						split="test"       )
  
       _UpperCAmelCase    :			Optional[int]              =					Image.open(dataset[0]["file"]       )
       _UpperCAmelCase    :			int              =					Image.open(dataset[1]["file"]       )
       _UpperCAmelCase    :			Dict              =					Image.open(dataset[2]["file"]       )
       _UpperCAmelCase    :			Optional[int]              =					Image.open(dataset[3]["file"]       )
  
       return [imagea, imagea], [mapa, mapa]
  
  
  
  
  
  
  @require_torch
  @require_vision
  class 			UpperCAmelCase_						(       _UpperCamelCase ,    unittest.TestCase		):
        __SCREAMING_SNAKE_CASE		:     Union[str, Any]				  =				SegformerImageProcessor if is_vision_available() else None
  
  
  
        def 		snake_case_      (  self  :			Any		):
             _UpperCAmelCase    :			List[str]              =					SegformerImageProcessingTester(self		)
  
  
  
        @property
        def 		snake_case_      (  self  :			Optional[Any]		):
             return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
        def 		snake_case_      (  self  :			List[str]		):
             _UpperCAmelCase    :			Any              =					self.image_processing_class(**self.image_processor_dict		)
             self.assertTrue(hasattr(A  ,			"do_resize"		)		)
             self.assertTrue(hasattr(A  ,			"size"		)		)
             self.assertTrue(hasattr(A  ,			"do_normalize"		)		)
             self.assertTrue(hasattr(A  ,			"image_mean"		)		)
             self.assertTrue(hasattr(A  ,			"image_std"		)		)
             self.assertTrue(hasattr(A  ,			"do_reduce_labels"		)		)
  
  
  
        def 		snake_case_      (  self  :			Optional[Any]		):
             _UpperCAmelCase    :			List[Any]              =					self.image_processing_class.from_dict(self.image_processor_dict		)
             self.assertEqual(image_processor.size  ,			{"height": 3_0, "width": 3_0}		)
             self.assertEqual(image_processor.do_reduce_labels  ,			A		)
  
             _UpperCAmelCase    :			Optional[int]              =					self.image_processing_class.from_dict(self.image_processor_dict  ,			size=4_2  ,			reduce_labels=A		)
             self.assertEqual(image_processor.size  ,			{"height": 4_2, "width": 4_2}		)
             self.assertEqual(image_processor.do_reduce_labels  ,			A		)
  
  
  
        def 		snake_case_      (  self  :			Any		):
             pass
  
  
  
        def 		snake_case_      (  self  :			Tuple		):
             # Initialize image_processing
             _UpperCAmelCase    :			Dict              =					self.image_processing_class(**self.image_processor_dict		)
             # create random PIL images
             _UpperCAmelCase    :			Dict              =					prepare_image_inputs(self.image_processor_tester  ,			equal_resolution=A		)
             for image in image_inputs:
                  self.assertIsInstance(A  ,			Image.Image		)
  
             # Test not batched input
             _UpperCAmelCase    :			Optional[Any]              =					image_processing(image_inputs[0]  ,			return_tensors="pt"		).pixel_values
             self.assertEqual(
                 encoded_images.shape  ,			(
                     1,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
  
             # Test batched
             _UpperCAmelCase    :			Dict              =					image_processing(A  ,			return_tensors="pt"		).pixel_values
             self.assertEqual(
                 encoded_images.shape  ,			(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
  
  
  
        def 		snake_case_      (  self  :			Optional[Any]		):
             # Initialize image_processing
             _UpperCAmelCase    :			Union[str, Any]              =					self.image_processing_class(**self.image_processor_dict		)
             # create random numpy tensors
             _UpperCAmelCase    :			Optional[Any]              =					prepare_image_inputs(self.image_processor_tester  ,			equal_resolution=A  ,			numpify=A		)
             for image in image_inputs:
                  self.assertIsInstance(A  ,			np.ndarray		)
  
             # Test not batched input
             _UpperCAmelCase    :			Tuple              =					image_processing(image_inputs[0]  ,			return_tensors="pt"		).pixel_values
             self.assertEqual(
                 encoded_images.shape  ,			(
                     1,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
  
             # Test batched
             _UpperCAmelCase    :			Tuple              =					image_processing(A  ,			return_tensors="pt"		).pixel_values
             self.assertEqual(
                 encoded_images.shape  ,			(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
  
  
  
        def 		snake_case_      (  self  :			Optional[Any]		):
             # Initialize image_processing
             _UpperCAmelCase    :			int              =					self.image_processing_class(**self.image_processor_dict		)
             # create random PyTorch tensors
             _UpperCAmelCase    :			List[Any]              =					prepare_image_inputs(self.image_processor_tester  ,			equal_resolution=A  ,			torchify=A		)
             for image in image_inputs:
                  self.assertIsInstance(A  ,			torch.Tensor		)
  
             # Test not batched input
             _UpperCAmelCase    :			Tuple              =					image_processing(image_inputs[0]  ,			return_tensors="pt"		).pixel_values
             self.assertEqual(
                 encoded_images.shape  ,			(
                     1,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
  
             # Test batched
             _UpperCAmelCase    :			Optional[int]              =					image_processing(A  ,			return_tensors="pt"		).pixel_values
             self.assertEqual(
                 encoded_images.shape  ,			(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
  
  
  
        def 		snake_case_      (  self  :			List[Any]		):
             # Initialize image_processing
             _UpperCAmelCase    :			Tuple              =					self.image_processing_class(**self.image_processor_dict		)
             # create random PyTorch tensors
             _UpperCAmelCase    :			str              =					prepare_image_inputs(self.image_processor_tester  ,			equal_resolution=A  ,			torchify=A		)
             _UpperCAmelCase    :			Any              =					[]
             for image in image_inputs:
                  self.assertIsInstance(A  ,			torch.Tensor		)
                  maps.append(torch.zeros(image.shape[-2:]		).long()		)
  
             # Test not batched input
             _UpperCAmelCase    :			Any              =					image_processing(image_inputs[0]  ,			maps[0]  ,			return_tensors="pt"		)
             self.assertEqual(
                 encoding["pixel_values"].shape  ,			(
                     1,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
             self.assertEqual(
                 encoding["labels"].shape  ,			(
                     1,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
             self.assertEqual(encoding["labels"].dtype  ,			torch.long		)
             self.assertTrue(encoding["labels"].min().item() >= 0		)
             self.assertTrue(encoding["labels"].max().item() <= 2_5_5		)
  
             # Test batched
             _UpperCAmelCase    :			Any              =					image_processing(A  ,			A  ,			return_tensors="pt"		)
             self.assertEqual(
                 encoding["pixel_values"].shape  ,			(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
             self.assertEqual(
                 encoding["labels"].shape  ,			(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
             self.assertEqual(encoding["labels"].dtype  ,			torch.long		)
             self.assertTrue(encoding["labels"].min().item() >= 0		)
             self.assertTrue(encoding["labels"].max().item() <= 2_5_5		)
  
             # Test not batched input (PIL images)
             _UpperCAmelCase    :			Optional[Any]              =					prepare_semantic_single_inputs()
  
             _UpperCAmelCase    :			Optional[int]              =					image_processing(A  ,			A  ,			return_tensors="pt"		)
             self.assertEqual(
                 encoding["pixel_values"].shape  ,			(
                     1,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
             self.assertEqual(
                 encoding["labels"].shape  ,			(
                     1,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
             self.assertEqual(encoding["labels"].dtype  ,			torch.long		)
             self.assertTrue(encoding["labels"].min().item() >= 0		)
             self.assertTrue(encoding["labels"].max().item() <= 2_5_5		)
  
             # Test batched input (PIL images)
             _UpperCAmelCase    :			int              =					prepare_semantic_batch_inputs()
  
             _UpperCAmelCase    :			List[Any]              =					image_processing(A  ,			A  ,			return_tensors="pt"		)
             self.assertEqual(
                 encoding["pixel_values"].shape  ,			(
                     2,
                     self.image_processor_tester.num_channels,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
             self.assertEqual(
                 encoding["labels"].shape  ,			(
                     2,
                     self.image_processor_tester.size["height"],
                     self.image_processor_tester.size["width"],
                 )  ,			)
             self.assertEqual(encoding["labels"].dtype  ,			torch.long		)
             self.assertTrue(encoding["labels"].min().item() >= 0		)
             self.assertTrue(encoding["labels"].max().item() <= 2_5_5		)
  
  
  
        def 		snake_case_      (  self  :			Dict		):
             # Initialize image_processing
             _UpperCAmelCase    :			Optional[int]              =					self.image_processing_class(**self.image_processor_dict		)
  
             # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
             _UpperCAmelCase    :			Optional[int]              =					prepare_semantic_single_inputs()
             _UpperCAmelCase    :			Dict              =					image_processing(A  ,			A  ,			return_tensors="pt"		)
             self.assertTrue(encoding["labels"].min().item() >= 0		)
             self.assertTrue(encoding["labels"].max().item() <= 1_5_0		)
  
             _UpperCAmelCase    :			str              =					True
             _UpperCAmelCase    :			Any              =					image_processing(A  ,			A  ,			return_tensors="pt"		)
             self.assertTrue(encoding["labels"].min().item() >= 0		)
             self.assertTrue(encoding["labels"].max().item() <= 2_5_5		)
  
style_context: 
  
  
  
  """simple docstring"""
  
  
  
  
  import os
  from shutil import copyfile
  from typing import List, Optional, Tuple
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import is_sentencepiece_available, logging
  
  
  if is_sentencepiece_available():
   from .tokenization_xglm import XGLMTokenizer
  else:
   _lowerCAmelCase       :      Tuple							=							None
  
  
  _lowerCAmelCase       :      List[str]							=							logging.get_logger(__name__)
  
  _lowerCAmelCase       :      str							=							{"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"}
  
  _lowerCAmelCase       :      Optional[Any]							=							{
      "vocab_file": {
          "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model",
      },
      "tokenizer_file": {
          "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/tokenizer.json",
      },
  }
  
  _lowerCAmelCase       :      Union[str, Any]							=							{
      "facebook/xglm-564M": 20_48,
  }
  
  
  
  
  
  
  class 			UpperCAmelCase_						(       _UpperCamelCase		):
        __SCREAMING_SNAKE_CASE		:     str				  =				VOCAB_FILES_NAMES
        __SCREAMING_SNAKE_CASE		:     List[str]				  =				PRETRAINED_VOCAB_FILES_MAP
        __SCREAMING_SNAKE_CASE		:     str				  =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
        __SCREAMING_SNAKE_CASE		:     int				  =				['input_ids', 'attention_mask']
        __SCREAMING_SNAKE_CASE		:     str				  =				XGLMTokenizer
  
  
  
        def __init__(  self  :			List[Any]  ,			A  :			Union[str, Any]=None  ,			A  :			Optional[Any]=None  ,			A  :			Optional[Any]="<s>"  ,			A  :			Optional[int]="</s>"  ,			A  :			str="</s>"  ,			A  :			int="<s>"  ,			A  :			int="<unk>"  ,			A  :			List[str]="<pad>"  ,			**A  :			Tuple  ,			):
             # Compatibility with the original tokenizer
             _UpperCAmelCase    :			Union[str, Any]              =					7
             _UpperCAmelCase    :			Optional[int]              =					[f'<madeupword{i}>' for i in range(self.num_madeup_words		)]
  
             _UpperCAmelCase    :			Any              =					kwargs.get("additional_special_tokens"  ,			[]		)
             kwargs["additional_special_tokens"] += [
                 word for word in madeup_words if word not in kwargs["additional_special_tokens"]
             ]
  
             super().__init__(
                 A  ,			tokenizer_file=A  ,			bos_token=A  ,			eos_token=A  ,			sep_token=A  ,			cls_token=A  ,			unk_token=A  ,			pad_token=A  ,			**A  ,			)
  
             _UpperCAmelCase    :			Any              =					vocab_file
             _UpperCAmelCase    :			Union[str, Any]              =					False if not self.vocab_file else True
  
  
  
        def 		snake_case_      (  self  :			List[str]  ,			A  :			List[int]  ,			A  :			Optional[List[int]] = None		):
  
             if token_ids_a is None:
                  return [self.sep_token_id] + token_ids_a
             _UpperCAmelCase    :			Tuple              =					[self.sep_token_id]
             return sep + token_ids_a + sep + sep + token_ids_a
  
  
  
        def 		snake_case_      (  self  :			str  ,			A  :			List[int]  ,			A  :			Optional[List[int]] = None		):
             _UpperCAmelCase    :			Optional[int]              =					[self.sep_token_id]
  
             if token_ids_a is None:
                  return len(sep + token_ids_a		) * [0]
             return len(sep + token_ids_a + sep + sep + token_ids_a		) * [0]
  
  
  
        def 		snake_case_      (  self  :			Dict  ,			A  :			str  ,			A  :			Optional[str] = None		):
             if not self.can_save_slow_tokenizer:
                  raise ValueError(
                      "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
                      "tokenizer."		)
  
             if not os.path.isdir(A		):
                  logger.error(f'Vocabulary path ({save_directory}) should be a directory.'		)
                  return
             _UpperCAmelCase    :			str              =					os.path.join(
                 A  ,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]		)
  
             if os.path.abspath(self.vocab_file		) != os.path.abspath(A		):
                  copyfile(self.vocab_file  ,			A		)
  
             return (out_vocab_file,)
  