


import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY

@is_pipeline_test
@require_torch_or_tf
class        a	(unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							Tuple  						=						MODEL_FOR_CAUSAL_LM_MAPPING
							__UpperCAmelCase					:							List[str]  						=						TF_MODEL_FOR_CAUSAL_LM_MAPPING

							@require_torch
							def 					__snake_case      (							self :						Any       )			->					Any:
														__snake_case	:    Dict											=     pipeline(task="text-generation"					,			model="sshleifer/tiny-ctrl"					,			framework="pt"       )
														# Using `do_sample=False` to force deterministic output
														__snake_case	:    List[Any]											=     text_generator("This is a test"					,			do_sample=lowerCamelCase       )
														self.assertEqual(
														    lowerCamelCase					,			[
														        {
														            "generated_text": (
														                "This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
														                " oscope. FiliFili@@"
														            )
														        }
														    ]					,			)

														__snake_case	:    Union[str, Any]											=     text_generator(["This is a test", "This is a second test"]       )
														self.assertEqual(
														    lowerCamelCase					,			[
														        [
														            {
														                "generated_text": (
														                    "This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
														                    " oscope. FiliFili@@"
														                )
														            }
														        ],
														        [
														            {
														                "generated_text": (
														                    "This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy"
														                    " oscope. oscope. FiliFili@@"
														                )
														            }
														        ],
														    ]					,			)

														__snake_case	:    str											=     text_generator("This is a test"					,			do_sample=lowerCamelCase					,			num_return_sequences=2					,			return_tensors=lowerCamelCase       )
														self.assertEqual(
														    lowerCamelCase					,			[
														        {"generated_token_ids": ANY(lowerCamelCase       )},
														        {"generated_token_ids": ANY(lowerCamelCase       )},
														    ]					,			)
														__snake_case	:    Optional[Any]											=     text_generator.model.config.eos_token_id
														__snake_case	:    Optional[Any]											=     "<pad>"
														__snake_case	:    Dict											=     text_generator(
														    ["This is a test", "This is a second test"]					,			do_sample=lowerCamelCase					,			num_return_sequences=2					,			batch_size=2					,			return_tensors=lowerCamelCase					,			)
														self.assertEqual(
														    lowerCamelCase					,			[
														        [
														            {"generated_token_ids": ANY(lowerCamelCase       )},
														            {"generated_token_ids": ANY(lowerCamelCase       )},
														        ],
														        [
														            {"generated_token_ids": ANY(lowerCamelCase       )},
														            {"generated_token_ids": ANY(lowerCamelCase       )},
														        ],
														    ]					,			)

							@require_tf
							def 					__snake_case      (							self :						Tuple       )			->					Union[str, Any]:
														__snake_case	:    Dict											=     pipeline(task="text-generation"					,			model="sshleifer/tiny-ctrl"					,			framework="tf"       )

														# Using `do_sample=False` to force deterministic output
														__snake_case	:    Optional[Any]											=     text_generator("This is a test"					,			do_sample=lowerCamelCase       )
														self.assertEqual(
														    lowerCamelCase					,			[
														        {
														            "generated_text": (
														                "This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"
														                " please,"
														            )
														        }
														    ]					,			)

														__snake_case	:    Union[str, Any]											=     text_generator(["This is a test", "This is a second test"]					,			do_sample=lowerCamelCase       )
														self.assertEqual(
														    lowerCamelCase					,			[
														        [
														            {
														                "generated_text": (
														                    "This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"
														                    " please,"
														                )
														            }
														        ],
														        [
														            {
														                "generated_text": (
														                    "This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes"
														                    " Cannes 閲閲Cannes Cannes Cannes 攵 please,"
														                )
														            }
														        ],
														    ]					,			)

							def 					__snake_case      (							self :						Tuple					,			lowerCamelCase :						Optional[Any]					,			lowerCamelCase :						Optional[Any]					,			lowerCamelCase :						List[str]       )			->					Optional[int]:
														__snake_case	:    str											=     TextGenerationPipeline(model=lowerCamelCase					,			tokenizer=lowerCamelCase       )
														return text_generator, ["This is a test", "Another test"]

							def 					__snake_case      (							self :						List[Any]       )			->					Tuple:
														__snake_case	:    Dict											=     "Hello I believe in"
														__snake_case	:    int											=     pipeline("text-generation"					,			model="hf-internal-testing/tiny-random-gpt2"       )
														__snake_case	:    Optional[int]											=     text_generator(lowerCamelCase       )
														self.assertEqual(
														    lowerCamelCase					,			[{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}]					,			)

														__snake_case	:    List[Any]											=     text_generator(lowerCamelCase					,			stop_sequence=" fe"       )
														self.assertEqual(lowerCamelCase					,			[{"generated_text": "Hello I believe in fe"}]       )

							def 					__snake_case      (							self :						List[Any]					,			lowerCamelCase :						Dict					,			lowerCamelCase :						int       )			->					List[Any]:
														__snake_case	:    str											=     text_generator.model
														__snake_case	:    Union[str, Any]											=     text_generator.tokenizer

														__snake_case	:    Dict											=     text_generator("This is a test"       )
														self.assertEqual(lowerCamelCase					,			[{"generated_text": ANY(lowerCamelCase       )}]       )
														self.assertTrue(outputs[0]["generated_text"].startswith("This is a test"       )       )

														__snake_case	:    List[str]											=     text_generator("This is a test"					,			return_full_text=lowerCamelCase       )
														self.assertEqual(lowerCamelCase					,			[{"generated_text": ANY(lowerCamelCase       )}]       )
														self.assertNotIn("This is a test"					,			outputs[0]["generated_text"]       )

														__snake_case	:    str											=     pipeline(task="text-generation"					,			model=lowerCamelCase					,			tokenizer=lowerCamelCase					,			return_full_text=lowerCamelCase       )
														__snake_case	:    Any											=     text_generator("This is a test"       )
														self.assertEqual(lowerCamelCase					,			[{"generated_text": ANY(lowerCamelCase       )}]       )
														self.assertNotIn("This is a test"					,			outputs[0]["generated_text"]       )

														__snake_case	:    Any											=     text_generator("This is a test"					,			return_full_text=lowerCamelCase       )
														self.assertEqual(lowerCamelCase					,			[{"generated_text": ANY(lowerCamelCase       )}]       )
														self.assertTrue(outputs[0]["generated_text"].startswith("This is a test"       )       )

														__snake_case	:    Union[str, Any]											=     text_generator(["This is great !", "Something else"]					,			num_return_sequences=2					,			do_sample=lowerCamelCase       )
														self.assertEqual(
														    lowerCamelCase					,			[
														        [{"generated_text": ANY(lowerCamelCase       )}, {"generated_text": ANY(lowerCamelCase       )}],
														        [{"generated_text": ANY(lowerCamelCase       )}, {"generated_text": ANY(lowerCamelCase       )}],
														    ]					,			)

														if text_generator.tokenizer.pad_token is not None:
																					__snake_case	:    Optional[int]											=     text_generator(
																					    ["This is great !", "Something else"]					,			num_return_sequences=2					,			batch_size=2					,			do_sample=lowerCamelCase       )
																					self.assertEqual(
																					    lowerCamelCase					,			[
																					        [{"generated_text": ANY(lowerCamelCase       )}, {"generated_text": ANY(lowerCamelCase       )}],
																					        [{"generated_text": ANY(lowerCamelCase       )}, {"generated_text": ANY(lowerCamelCase       )}],
																					    ]					,			)

														with self.assertRaises(lowerCamelCase       ):
																					__snake_case	:    List[str]											=     text_generator("test"					,			return_full_text=lowerCamelCase					,			return_text=lowerCamelCase       )
														with self.assertRaises(lowerCamelCase       ):
																					__snake_case	:    str											=     text_generator("test"					,			return_full_text=lowerCamelCase					,			return_tensors=lowerCamelCase       )
														with self.assertRaises(lowerCamelCase       ):
																					__snake_case	:    int											=     text_generator("test"					,			return_text=lowerCamelCase					,			return_tensors=lowerCamelCase       )

														# Empty prompt is slighly special
														# it requires BOS token to exist.
														# Special case for Pegasus which will always append EOS so will
														# work even without BOS.
														if (
														    text_generator.tokenizer.bos_token_id is not None
														    or "Pegasus" in tokenizer.__class__.__name__
														    or "Git" in model.__class__.__name__
														):
																					__snake_case	:    Tuple											=     text_generator(""       )
																					self.assertEqual(lowerCamelCase					,			[{"generated_text": ANY(lowerCamelCase       )}]       )
														else:
																					with self.assertRaises((ValueError, AssertionError)       ):
																												__snake_case	:    Tuple											=     text_generator(""       )

														if text_generator.framework == "tf":
																					# TF generation does not support max_new_tokens, and it's impossible
																					# to control long generation with only max_length without
																					# fancy calculation, dismissing tests for now.
																					return
														# We don't care about infinite range models.
														# They already work.
														# Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
														__snake_case	:    str											=     ["RwkvForCausalLM", "XGLMForCausalLM", "GPTNeoXForCausalLM"]
														if (
														    tokenizer.model_max_length < 10000
														    and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
														):
																					# Handling of large generations
																					with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)       ):
																												text_generator("This is a test" * 500					,			max_new_tokens=20       )

																					__snake_case	:    List[str]											=     text_generator("This is a test" * 500					,			handle_long_generation="hole"					,			max_new_tokens=20       )
																					# Hole strategy cannot work
																					with self.assertRaises(lowerCamelCase       ):
																												text_generator(
																												    "This is a test" * 500					,			handle_long_generation="hole"					,			max_new_tokens=tokenizer.model_max_length + 10					,			)

							@require_torch
							@require_accelerate
							@require_torch_gpu
							def 					__snake_case      (							self :						Optional[int]       )			->					Dict:
														import torch

														# Classic `model_kwargs`
														__snake_case	:    Dict											=     pipeline(
														    model="hf-internal-testing/tiny-random-bloom"					,			model_kwargs={"device_map": "auto", "torch_dtype": torch.bfloataa}					,			)
														self.assertEqual(pipe.model.device					,			torch.device(0       )       )
														self.assertEqual(pipe.model.lm_head.weight.dtype					,			torch.bfloataa       )
														__snake_case	:    Optional[Any]											=     pipe("This is a test"       )
														self.assertEqual(
														    lowerCamelCase					,			[
														        {
														            "generated_text": (
														                "This is a test test test test test test test test test test test test test test test test"
														                " test"
														            )
														        }
														    ]					,			)

														# Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
														__snake_case	:    Dict											=     pipeline(model="hf-internal-testing/tiny-random-bloom"					,			device_map="auto"					,			torch_dtype=torch.bfloataa       )
														self.assertEqual(pipe.model.device					,			torch.device(0       )       )
														self.assertEqual(pipe.model.lm_head.weight.dtype					,			torch.bfloataa       )
														__snake_case	:    Union[str, Any]											=     pipe("This is a test"       )
														self.assertEqual(
														    lowerCamelCase					,			[
														        {
														            "generated_text": (
														                "This is a test test test test test test test test test test test test test test test test"
														                " test"
														            )
														        }
														    ]					,			)

														# torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
														__snake_case	:    Dict											=     pipeline(model="hf-internal-testing/tiny-random-bloom"					,			device_map="auto"       )
														self.assertEqual(pipe.model.device					,			torch.device(0       )       )
														self.assertEqual(pipe.model.lm_head.weight.dtype					,			torch.floataa       )
														__snake_case	:    Optional[Any]											=     pipe("This is a test"       )
														self.assertEqual(
														    lowerCamelCase					,			[
														        {
														            "generated_text": (
														                "This is a test test test test test test test test test test test test test test test test"
														                " test"
														            )
														        }
														    ]					,			)

							@require_torch
							@require_torch_gpu
							def 					__snake_case      (							self :						Optional[int]       )			->					List[Any]:
														import torch

														__snake_case	:    List[str]											=     pipeline(model="hf-internal-testing/tiny-random-bloom"					,			device=0					,			torch_dtype=torch.floataa       )
														pipe("This is a test"       )

							@require_torch
							@require_accelerate
							@require_torch_gpu
							def 					__snake_case      (							self :						int       )			->					Optional[Any]:
														import torch

														__snake_case	:    Any											=     pipeline(model="hf-internal-testing/tiny-random-bloom"					,			device_map="auto"					,			torch_dtype=torch.floataa       )
														pipe("This is a test"					,			do_sample=lowerCamelCase					,			top_p=0.5       )






							def 					__snake_case      (							self :						Any       )			->					Dict:
														__snake_case	:    Optional[Any]											=     "Hello world"
														__snake_case	:    Optional[int]											=     pipeline("text-generation"					,			model="hf-internal-testing/tiny-random-gpt2"       )
														if text_generator.model.framework == "tf":
																					__snake_case	:    Optional[int]											=     logging.get_logger("transformers.generation.tf_utils"       )
														else:
																					__snake_case	:    List[str]											=     logging.get_logger("transformers.generation.utils"       )
														__snake_case	:    Dict											=     "Both `max_new_tokens`"  # The beggining of the message to be checked in this test

														# Both are set by the user -> log warning
														with CaptureLogger(lowerCamelCase       ) as cl:
																					__snake_case	:    Union[str, Any]											=     text_generator(lowerCamelCase					,			max_length=10					,			max_new_tokens=1       )
														self.assertIn(lowerCamelCase					,			cl.out       )

														# The user only sets one -> no warning
														with CaptureLogger(lowerCamelCase       ) as cl:
																					__snake_case	:    Dict											=     text_generator(lowerCamelCase					,			max_new_tokens=1       )
														self.assertNotIn(lowerCamelCase					,			cl.out       )

														with CaptureLogger(lowerCamelCase       ) as cl:
																					__snake_case	:    Tuple											=     text_generator(lowerCamelCase					,			max_length=10       )
														self.assertNotIn(lowerCamelCase					,			cl.out       )





def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase			):
							return int((input_a, input_a).count(0			) == 0			)







def        lowerCAmelCase_  (      ):
							assert and_gate(0							,			0			) == 0
							assert and_gate(0							,			1			) == 0
							assert and_gate(1							,			0			) == 0
							assert and_gate(1							,			1			) == 1


if __name__ == "__main__":
			test_and_gate()
			print(and_gate(1, 0))
			print(and_gate(0, 0))
			print(and_gate(0, 1))
			print(and_gate(1, 1))

