



'''simple docstring'''





import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           XLMForMultipleChoice,
           XLMForQuestionAnswering,
           XLMForQuestionAnsweringSimple,
           XLMForSequenceClassification,
           XLMForTokenClassification,
           XLMModel,
           XLMWithLMHeadModel,
       )
       from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST



class       UpperCAmelCase__:

   '''simple docstring'''




   def __init__(						self  :			str			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Tuple=13			,				lowerCAmelCase  :			Dict=7			,				lowerCAmelCase  :			Optional[Any]=True			,				lowerCAmelCase  :			List[str]=True			,				lowerCAmelCase  :			int=True			,				lowerCAmelCase  :			Dict=True			,				lowerCAmelCase  :			Tuple=True			,				lowerCAmelCase  :			List[Any]=False			,				lowerCAmelCase  :			Optional[int]=False			,				lowerCAmelCase  :			int=False			,				lowerCAmelCase  :			Tuple=2			,				lowerCAmelCase  :			Any=99			,				lowerCAmelCase  :			List[Any]=0			,				lowerCAmelCase  :			Any=32			,				lowerCAmelCase  :			Tuple=5			,				lowerCAmelCase  :			Union[str, Any]=4			,				lowerCAmelCase  :			Optional[Any]=0.1			,				lowerCAmelCase  :			Optional[Any]=0.1			,				lowerCAmelCase  :			List[str]=5_12			,				lowerCAmelCase  :			List[str]=2			,				lowerCAmelCase  :			List[str]=0.02			,				lowerCAmelCase  :			Dict=2			,				lowerCAmelCase  :			Union[str, Any]=4			,				lowerCAmelCase  :			int="last"			,				lowerCAmelCase  :			Tuple=True			,				lowerCAmelCase  :			str=None			,				lowerCAmelCase  :			List[str]=0			,				)	->				Dict:




         """simple docstring"""

         lowercase__     =  parent
         lowercase__     =  batch_size
         lowercase__     =  seq_length
         lowercase__     =  is_training
         lowercase__     =  use_input_lengths
         lowercase__     =  use_token_type_ids
         lowercase__     =  use_labels
         lowercase__     =  gelu_activation
         lowercase__     =  sinusoidal_embeddings
         lowercase__     =  causal
         lowercase__     =  asm
         lowercase__     =  n_langs
         lowercase__     =  vocab_size
         lowercase__     =  n_special
         lowercase__     =  hidden_size
         lowercase__     =  num_hidden_layers
         lowercase__     =  num_attention_heads
         lowercase__     =  hidden_dropout_prob
         lowercase__     =  attention_probs_dropout_prob
         lowercase__     =  max_position_embeddings
         lowercase__     =  type_sequence_label_size
         lowercase__     =  initializer_range
         lowercase__     =  num_labels
         lowercase__     =  num_choices
         lowercase__     =  summary_type
         lowercase__     =  use_proj
         lowercase__     =  scope
         lowercase__     =  bos_token_id


   def 			UpperCAmelCase		(						self  :			Union[str, Any])	->				Dict:




         """simple docstring"""

         lowercase__     =  ids_tensor([self.batch_size, self.seq_length]			,				self.vocab_size)
         lowercase__     =  random_attention_mask([self.batch_size, self.seq_length])

         lowercase__     =  None
         if self.use_input_lengths:
               lowercase__     =  (
                   ids_tensor([self.batch_size]			,				vocab_size=2) + self.seq_length - 2
               )  # small variation of seq_length

         lowercase__     =  None
         if self.use_token_type_ids:
               lowercase__     =  ids_tensor([self.batch_size, self.seq_length]			,				self.n_langs)

         lowercase__     =  None
         lowercase__     =  None
         lowercase__     =  None
         if self.use_labels:
               lowercase__     =  ids_tensor([self.batch_size]			,				self.type_sequence_label_size)
               lowercase__     =  ids_tensor([self.batch_size, self.seq_length]			,				self.num_labels)
               lowercase__     =  ids_tensor([self.batch_size]			,				2).float()
               lowercase__     =  ids_tensor([self.batch_size]			,				self.num_choices)

         lowercase__     =  self.get_config()

         return (
             config,
             input_ids,
             token_type_ids,
             input_lengths,
             sequence_labels,
             token_labels,
             is_impossible_labels,
             choice_labels,
             input_mask,
         )


   def 			UpperCAmelCase		(						self  :			List[str])	->				Optional[Any]:




         """simple docstring"""

         return XLMConfig(
             vocab_size=self.vocab_size			,				n_special=self.n_special			,				emb_dim=self.hidden_size			,				n_layers=self.num_hidden_layers			,				n_heads=self.num_attention_heads			,				dropout=self.hidden_dropout_prob			,				attention_dropout=self.attention_probs_dropout_prob			,				gelu_activation=self.gelu_activation			,				sinusoidal_embeddings=self.sinusoidal_embeddings			,				asm=self.asm			,				causal=self.causal			,				n_langs=self.n_langs			,				max_position_embeddings=self.max_position_embeddings			,				initializer_range=self.initializer_range			,				summary_type=self.summary_type			,				use_proj=self.use_proj			,				num_labels=self.num_labels			,				bos_token_id=self.bos_token_id			,				)


   def 			UpperCAmelCase		(						self  :			Tuple			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			int			,				)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  XLMModel(config=__lowerCamelCase)
         model.to(__lowerCamelCase)
         model.eval()
         lowercase__     =  model(__lowerCamelCase			,				lengths=__lowerCamelCase			,				langs=__lowerCamelCase)
         lowercase__     =  model(__lowerCamelCase			,				langs=__lowerCamelCase)
         lowercase__     =  model(__lowerCamelCase)
         self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size))


   def 			UpperCAmelCase		(						self  :			int			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Tuple			,				)	->				int:




         """simple docstring"""

         lowercase__     =  XLMWithLMHeadModel(__lowerCamelCase)
         model.to(__lowerCamelCase)
         model.eval()

         lowercase__     =  model(__lowerCamelCase			,				token_type_ids=__lowerCamelCase			,				labels=__lowerCamelCase)
         self.parent.assertEqual(result.loss.shape			,				())
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.vocab_size))


   def 			UpperCAmelCase		(						self  :			List[str]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Tuple			,				)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  XLMForQuestionAnsweringSimple(__lowerCamelCase)
         model.to(__lowerCamelCase)
         model.eval()

         lowercase__     =  model(__lowerCamelCase)

         lowercase__     =  model(__lowerCamelCase			,				start_positions=__lowerCamelCase			,				end_positions=__lowerCamelCase)
         lowercase__     =  outputs
         self.parent.assertEqual(result.start_logits.shape			,				(self.batch_size, self.seq_length))
         self.parent.assertEqual(result.end_logits.shape			,				(self.batch_size, self.seq_length))


   def 			UpperCAmelCase		(						self  :			Optional[Any]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Tuple			,				)	->				int:




         """simple docstring"""

         lowercase__     =  XLMForQuestionAnswering(__lowerCamelCase)
         model.to(__lowerCamelCase)
         model.eval()

         lowercase__     =  model(__lowerCamelCase)

         lowercase__     =  model(
             __lowerCamelCase			,				start_positions=__lowerCamelCase			,				end_positions=__lowerCamelCase			,				cls_index=__lowerCamelCase			,				is_impossible=__lowerCamelCase			,				p_mask=__lowerCamelCase			,				)

         lowercase__     =  model(
             __lowerCamelCase			,				start_positions=__lowerCamelCase			,				end_positions=__lowerCamelCase			,				cls_index=__lowerCamelCase			,				is_impossible=__lowerCamelCase			,				)

         (lowercase__	)     =  result_with_labels.to_tuple()

         lowercase__     =  model(__lowerCamelCase			,				start_positions=__lowerCamelCase			,				end_positions=__lowerCamelCase)

         (lowercase__	)     =  result_with_labels.to_tuple()

         self.parent.assertEqual(result_with_labels.loss.shape			,				())
         self.parent.assertEqual(result.start_top_log_probs.shape			,				(self.batch_size, model.config.start_n_top))
         self.parent.assertEqual(result.start_top_index.shape			,				(self.batch_size, model.config.start_n_top))
         self.parent.assertEqual(
             result.end_top_log_probs.shape			,				(self.batch_size, model.config.start_n_top * model.config.end_n_top))
         self.parent.assertEqual(
             result.end_top_index.shape			,				(self.batch_size, model.config.start_n_top * model.config.end_n_top))
         self.parent.assertEqual(result.cls_logits.shape			,				(self.batch_size,))


   def 			UpperCAmelCase		(						self  :			Dict			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Union[str, Any]			,				)	->				str:




         """simple docstring"""

         lowercase__     =  XLMForSequenceClassification(__lowerCamelCase)
         model.to(__lowerCamelCase)
         model.eval()

         lowercase__     =  model(__lowerCamelCase)
         lowercase__     =  model(__lowerCamelCase			,				labels=__lowerCamelCase)
         self.parent.assertEqual(result.loss.shape			,				())
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.type_sequence_label_size))


   def 			UpperCAmelCase		(						self  :			Union[str, Any]			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			int			,				)	->				str:




         """simple docstring"""

         lowercase__     =  self.num_labels
         lowercase__     =  XLMForTokenClassification(__lowerCamelCase)
         model.to(__lowerCamelCase)
         model.eval()

         lowercase__     =  model(__lowerCamelCase			,				attention_mask=__lowerCamelCase			,				labels=__lowerCamelCase)
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.num_labels))


   def 			UpperCAmelCase		(						self  :			List[str]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Dict			,				)	->				Any:




         """simple docstring"""

         lowercase__     =  self.num_choices
         lowercase__     =  XLMForMultipleChoice(config=__lowerCamelCase)
         model.to(__lowerCamelCase)
         model.eval()
         lowercase__     =  input_ids.unsqueeze(1).expand(-1			,				self.num_choices			,				-1).contiguous()
         lowercase__     =  token_type_ids.unsqueeze(1).expand(-1			,				self.num_choices			,				-1).contiguous()
         lowercase__     =  input_mask.unsqueeze(1).expand(-1			,				self.num_choices			,				-1).contiguous()
         lowercase__     =  model(
             __lowerCamelCase			,				attention_mask=__lowerCamelCase			,				token_type_ids=__lowerCamelCase			,				labels=__lowerCamelCase			,				)
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_choices))



   def 			UpperCAmelCase		(						self  :			Any)	->				Tuple:




         """simple docstring"""

         lowercase__     =  self.prepare_config_and_inputs()
         (
             lowercase__	
         )     =  config_and_inputs
         lowercase__     =  {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''lengths''': input_lengths}
         return config, inputs_dict



@require_torch
class       UpperCAmelCase__(							lowerCamelCase__     ,							lowerCamelCase__     ,							lowerCamelCase__     ,							unittest.TestCase	):

   '''simple docstring'''




   A    :  int       				=    (
       (
           XLMModel,
           XLMWithLMHeadModel,
           XLMForQuestionAnswering,
           XLMForSequenceClassification,
           XLMForQuestionAnsweringSimple,
           XLMForTokenClassification,
           XLMForMultipleChoice,
       )
       if is_torch_available()
       else ()
   )
   A    :  Union[str, Any]       				=    (
       (XLMWithLMHeadModel,) if is_torch_available() else ()
   )  # TODO (PVP): Check other models whether language generation is also applicable
   A    :  List[str]       				=    (
       {
           "feature-extraction": XLMModel,
           "fill-mask": XLMWithLMHeadModel,
           "question-answering": XLMForQuestionAnsweringSimple,
           "text-classification": XLMForSequenceClassification,
           "text-generation": XLMWithLMHeadModel,
           "token-classification": XLMForTokenClassification,
           "zero-shot": XLMForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )


   def 			UpperCAmelCase		(						self  :			Optional[Any]			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Tuple)	->				Optional[Any]:




         """simple docstring"""

         if (
             pipeline_test_casse_name == "QAPipelineTests"
             and tokenizer_name is not None
             and not tokenizer_name.endswith('Fast')
         ):
               # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
               # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
               # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
               return True

         return False


   def 			UpperCAmelCase		(						self  :			List[Any]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			Optional[Any]=False)	->				List[Any]:




         """simple docstring"""

         lowercase__     =  super()._prepare_for_class(__lowerCamelCase			,				__lowerCamelCase			,				return_labels=__lowerCamelCase)

         if return_labels:
               if model_class.__name__ == "XLMForQuestionAnswering":
                     lowercase__     =  torch.zeros(
                         self.model_tester.batch_size			,				dtype=torch.long			,				device=__lowerCamelCase)
                     lowercase__     =  torch.zeros(
                         self.model_tester.batch_size			,				dtype=torch.long			,				device=__lowerCamelCase)

         return inputs_dict


   def 			UpperCAmelCase		(						self  :			List[str])	->				Any:




         """simple docstring"""

         lowercase__     =  XLMModelTester(self)
         lowercase__     =  ConfigTester(self			,				config_class=__lowerCamelCase			,				emb_dim=37)


   def 			UpperCAmelCase		(						self  :			str)	->				Union[str, Any]:




         """simple docstring"""

         self.config_tester.run_common_tests()


   def 			UpperCAmelCase		(						self  :			Any)	->				Any:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_model(*__lowerCamelCase)


   def 			UpperCAmelCase		(						self  :			Optional[int])	->				List[str]:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_lm_head(*__lowerCamelCase)


   def 			UpperCAmelCase		(						self  :			str)	->				str:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_simple_qa(*__lowerCamelCase)


   def 			UpperCAmelCase		(						self  :			str)	->				Optional[Any]:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_qa(*__lowerCamelCase)


   def 			UpperCAmelCase		(						self  :			Optional[Any])	->				Any:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_sequence_classif(*__lowerCamelCase)


   def 			UpperCAmelCase		(						self  :			List[Any])	->				Tuple:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_token_classif(*__lowerCamelCase)


   def 			UpperCAmelCase		(						self  :			List[str])	->				int:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_multiple_choice(*__lowerCamelCase)


   def 			UpperCAmelCase		(						self  :			Optional[Any]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			int=False			,				lowerCAmelCase  :			Optional[Any]=1)	->				Dict:




         """simple docstring"""

         self.assertIsInstance(__lowerCamelCase			,				__lowerCamelCase)
         self.assertListEqual(
             [isinstance(__lowerCamelCase			,				__lowerCamelCase) for iter_attentions in attentions]			,				[True] * len(__lowerCamelCase))
         self.assertEqual(len(__lowerCamelCase)			,				(max_length - min_length) * num_beam_groups)

         for idx, iter_attentions in enumerate(__lowerCamelCase):
               # adds PAD dummy token
               lowercase__     =  min_length + idx + 1
               lowercase__     =  min_length + idx + 1

               lowercase__     =  (
                   batch_size * num_beam_groups,
                   config.num_attention_heads,
                   tgt_len,
                   src_len,
               )
               # check attn size
               self.assertListEqual(
                   [layer_attention.shape for layer_attention in iter_attentions]			,				[expected_shape] * len(__lowerCamelCase))


   def 			UpperCAmelCase		(						self  :			int			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			List[Any]=False			,				lowerCAmelCase  :			Dict=1)	->				Union[str, Any]:




         """simple docstring"""

         self.assertIsInstance(__lowerCamelCase			,				__lowerCamelCase)
         self.assertListEqual(
             [isinstance(__lowerCamelCase			,				__lowerCamelCase) for iter_hidden_states in hidden_states]			,				[True] * len(__lowerCamelCase)			,				)
         self.assertEqual(len(__lowerCamelCase)			,				(max_length - min_length) * num_beam_groups)

         for idx, iter_hidden_states in enumerate(__lowerCamelCase):
               # adds PAD dummy token
               lowercase__     =  min_length + idx + 1
               lowercase__     =  (batch_size * num_beam_groups, seq_len, config.hidden_size)
               # check hidden size
               self.assertListEqual(
                   [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]			,				[expected_shape] * len(__lowerCamelCase)			,				)
         pass



   @slow
   def 			UpperCAmelCase		(						self  :			Tuple)	->				Optional[Any]:




         """simple docstring"""

         for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowercase__     =  XLMModel.from_pretrained(__lowerCamelCase)
               self.assertIsNotNone(__lowerCamelCase)



@require_torch
class       UpperCAmelCase__(							unittest.TestCase	):

   '''simple docstring'''




   @slow
   def 			UpperCAmelCase		(						self  :			Optional[Any])	->				Union[str, Any]:




         """simple docstring"""

         lowercase__     =  XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048')
         model.to(__lowerCamelCase)
         lowercase__     =  torch.tensor([[14, 4_47]]			,				dtype=torch.long			,				device=__lowerCamelCase)  # the president
         lowercase__     =  [
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
         ]  # the president the president the president the president the president the president the president the president the president the president
         # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
         lowercase__     =  model.generate(__lowerCamelCase			,				do_sample=__lowerCamelCase)
         self.assertListEqual(output_ids[0].cpu().numpy().tolist()			,				__lowerCamelCase)





import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin



class       UpperCAmelCase__(							unittest.TestCase     ,							lowerCamelCase	):

   '''simple docstring'''




   def 			UpperCAmelCase		(						self  :			List[str])	->				Any:




         """simple docstring"""

         lowercase__     =  load_tool('text-classification')
         self.tool.setup()
         lowercase__     =  load_tool('text-classification'			,				remote=lowerCAmelCase)


   def 			UpperCAmelCase		(						self  :			Any)	->				Tuple:




         """simple docstring"""

         lowercase__     =  self.tool('That\'s quite cool'			,				['positive', 'negative'])
         self.assertEqual(lowerCAmelCase			,				'positive')


   def 			UpperCAmelCase		(						self  :			int)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  self.remote_tool('That\'s quite cool'			,				['positive', 'negative'])
         self.assertEqual(lowerCAmelCase			,				'positive')


   def 			UpperCAmelCase		(						self  :			Optional[Any])	->				Union[str, Any]:




         """simple docstring"""

         lowercase__     =  self.tool(text='That\'s quite cool'			,				labels=['positive', 'negative'])
         self.assertEqual(lowerCAmelCase			,				'positive')



   def 			UpperCAmelCase		(						self  :			Any)	->				Any:




         """simple docstring"""

         lowercase__     =  self.remote_tool(text='That\'s quite cool'			,				labels=['positive', 'negative'])
         self.assertEqual(lowerCAmelCase			,				'positive')
