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 			lowerCamelCase_  (     unittest.TestCase				):






    '''simple docstring'''






    a__			:		str      			=   MODEL_FOR_CAUSAL_LM_MAPPING
    a__			:		Optional[int]      			=   TF_MODEL_FOR_CAUSAL_LM_MAPPING







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

        __UpperCamelCase  :str    						=	text_generator(['''This is a test''', '''This is a second test'''])
        self.assertEqual(
            __lowercase				,				[
                [
                    {
                        '''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@@'''
                        )
                    }
                ],
            ]				,				)

        __UpperCamelCase  :List[Any]    						=	text_generator('''This is a test'''				,				do_sample=__lowercase				,				num_return_sequences=2				,				return_tensors=__lowercase)
        self.assertEqual(
            __lowercase				,				[
                {'''generated_token_ids''': ANY(__lowercase)},
                {'''generated_token_ids''': ANY(__lowercase)},
            ]				,				)
        __UpperCamelCase  :Optional[int]    						=	text_generator.model.config.eos_token_id
        __UpperCamelCase  :Union[str, Any]    						=	'''<pad>'''
        __UpperCamelCase  :int    						=	text_generator(
            ['''This is a test''', '''This is a second test''']				,				do_sample=__lowercase				,				num_return_sequences=2				,				batch_size=2				,				return_tensors=__lowercase				,				)
        self.assertEqual(
            __lowercase				,				[
                [
                    {'''generated_token_ids''': ANY(__lowercase)},
                    {'''generated_token_ids''': ANY(__lowercase)},
                ],
                [
                    {'''generated_token_ids''': ANY(__lowercase)},
                    {'''generated_token_ids''': ANY(__lowercase)},
                ],
            ]				,				)







    @require_tf
    def     UpperCamelCase__     (			self) ->			Optional[int]:
        __UpperCamelCase  :List[str]    						=	pipeline(task='''text-generation'''				,				model='''sshleifer/tiny-ctrl'''				,				framework='''tf''')

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

        __UpperCamelCase  :Any    						=	text_generator(['''This is a test''', '''This is a second test''']				,				do_sample=__lowercase)
        self.assertEqual(
            __lowercase				,				[
                [
                    {
                        '''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     UpperCamelCase__     (			self				,				__lowercase				,				__lowercase				,				__lowercase) ->			Optional[Any]:
        __UpperCamelCase  :List[str]    						=	TextGenerationPipeline(model=__lowercase				,				tokenizer=__lowercase)
        return text_generator, ["This is a test", "Another test"]







    def     UpperCamelCase__     (			self) ->			Any:
        __UpperCamelCase  :Tuple    						=	'''Hello I believe in'''
        __UpperCamelCase  :List[Any]    						=	pipeline('''text-generation'''				,				model='''hf-internal-testing/tiny-random-gpt2''')
        __UpperCamelCase  :Any    						=	text_generator(__lowercase)
        self.assertEqual(
            __lowercase				,				[{'''generated_text''': '''Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'''}]				,				)

        __UpperCamelCase  :Optional[int]    						=	text_generator(__lowercase				,				stop_sequence=''' fe''')
        self.assertEqual(__lowercase				,				[{'''generated_text''': '''Hello I believe in fe'''}])







    def     UpperCamelCase__     (			self				,				__lowercase				,				__lowercase) ->			Dict:
        __UpperCamelCase  :List[Any]    						=	text_generator.model
        __UpperCamelCase  :int    						=	text_generator.tokenizer

        __UpperCamelCase  :Optional[Any]    						=	text_generator('''This is a test''')
        self.assertEqual(__lowercase				,				[{'''generated_text''': ANY(__lowercase)}])
        self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''))

        __UpperCamelCase  :Dict    						=	text_generator('''This is a test'''				,				return_full_text=__lowercase)
        self.assertEqual(__lowercase				,				[{'''generated_text''': ANY(__lowercase)}])
        self.assertNotIn('''This is a test'''				,				outputs[0]['''generated_text'''])

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

        __UpperCamelCase  :Optional[int]    						=	text_generator('''This is a test'''				,				return_full_text=__lowercase)
        self.assertEqual(__lowercase				,				[{'''generated_text''': ANY(__lowercase)}])
        self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''))

        __UpperCamelCase  :List[str]    						=	text_generator(['''This is great !''', '''Something else''']				,				num_return_sequences=2				,				do_sample=__lowercase)
        self.assertEqual(
            __lowercase				,				[
                [{'''generated_text''': ANY(__lowercase)}, {'''generated_text''': ANY(__lowercase)}],
                [{'''generated_text''': ANY(__lowercase)}, {'''generated_text''': ANY(__lowercase)}],
            ]				,				)

        if text_generator.tokenizer.pad_token is not None:
            __UpperCamelCase  :Tuple    						=	text_generator(
                ['''This is great !''', '''Something else''']				,				num_return_sequences=2				,				batch_size=2				,				do_sample=__lowercase)
            self.assertEqual(
                __lowercase				,				[
                    [{'''generated_text''': ANY(__lowercase)}, {'''generated_text''': ANY(__lowercase)}],
                    [{'''generated_text''': ANY(__lowercase)}, {'''generated_text''': ANY(__lowercase)}],
                ]				,				)

        with self.assertRaises(__lowercase):
            __UpperCamelCase  :List[str]    						=	text_generator('''test'''				,				return_full_text=__lowercase				,				return_text=__lowercase)
        with self.assertRaises(__lowercase):
            __UpperCamelCase  :Optional[int]    						=	text_generator('''test'''				,				return_full_text=__lowercase				,				return_tensors=__lowercase)
        with self.assertRaises(__lowercase):
            __UpperCamelCase  :int    						=	text_generator('''test'''				,				return_text=__lowercase				,				return_tensors=__lowercase)

        # 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__
        ):
            __UpperCamelCase  :Any    						=	text_generator('''''')
            self.assertEqual(__lowercase				,				[{'''generated_text''': ANY(__lowercase)}])
        else:
            with self.assertRaises((ValueError, AssertionError)):
                __UpperCamelCase  :int    						=	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.
        __UpperCamelCase  :int    						=	['''RwkvForCausalLM''', '''XGLMForCausalLM''', '''GPTNeoXForCausalLM''']
        if (
            tokenizer.model_max_length < 10_000
            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)

            __UpperCamelCase  :Tuple    						=	text_generator('''This is a test''' * 500				,				handle_long_generation='''hole'''				,				max_new_tokens=20)
            # Hole strategy cannot work
            with self.assertRaises(__lowercase):
                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     UpperCamelCase__     (			self) ->			Union[str, Any]:
        import torch

        # Classic `model_kwargs`
        __UpperCamelCase  :Optional[Any]    						=	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)
        __UpperCamelCase  :int    						=	pipe('''This is a test''')
        self.assertEqual(
            __lowercase				,				[
                {
                    '''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.)
        __UpperCamelCase  :Optional[Any]    						=	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)
        __UpperCamelCase  :Optional[int]    						=	pipe('''This is a test''')
        self.assertEqual(
            __lowercase				,				[
                {
                    '''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
        __UpperCamelCase  :Tuple    						=	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)
        __UpperCamelCase  :List[Any]    						=	pipe('''This is a test''')
        self.assertEqual(
            __lowercase				,				[
                {
                    '''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     UpperCamelCase__     (			self) ->			Optional[int]:
        import torch

        __UpperCamelCase  :List[Any]    						=	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     UpperCamelCase__     (			self) ->			Optional[Any]:
        import torch

        __UpperCamelCase  :Optional[Any]    						=	pipeline(model='''hf-internal-testing/tiny-random-bloom'''				,				device_map='''auto'''				,				torch_dtype=torch.floataa)
        pipe('''This is a test'''				,				do_sample=__lowercase				,				top_p=0.5)







    def     UpperCamelCase__     (			self) ->			Union[str, Any]:
        __UpperCamelCase  :Dict    						=	'''Hello world'''
        __UpperCamelCase  :Any    						=	pipeline('''text-generation'''				,				model='''hf-internal-testing/tiny-random-gpt2''')
        if text_generator.model.framework == "tf":
            __UpperCamelCase  :Optional[int]    						=	logging.get_logger('''transformers.generation.tf_utils''')
        else:
            __UpperCamelCase  :List[Any]    						=	logging.get_logger('''transformers.generation.utils''')
        __UpperCamelCase  :Tuple    						=	'''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(__lowercase) as cl:
            __UpperCamelCase  :int    						=	text_generator(__lowercase				,				max_length=10				,				max_new_tokens=1)
        self.assertIn(__lowercase				,				cl.out)

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

        with CaptureLogger(__lowercase) as cl:
            __UpperCamelCase  :Union[str, Any]    						=	text_generator(__lowercase				,				max_length=10)
        self.assertNotIn(__lowercase				,				cl.out)






import qiskit



def lowerCamelCase						(     SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			):
    '''simple docstring'''







    __UpperCamelCase  :Dict    						=	qiskit.Aer.get_backend('''aer_simulator'''			)

    __UpperCamelCase  :Tuple    						=	qiskit.QuantumCircuit(4						,    2			)
    # encode inputs in qubits 0 and 1
    if bita == 1:
        qc_ha.x(0			)
    if bita == 1:
        qc_ha.x(1			)
    qc_ha.barrier()

    # use cnots to write XOR of the inputs on qubit2
    qc_ha.cx(0						,    2			)
    qc_ha.cx(1						,    2			)

    # use ccx / toffoli gate to write AND of the inputs on qubit3
    qc_ha.ccx(0						,    1						,    3			)
    qc_ha.barrier()

    # extract outputs
    qc_ha.measure(2						,    0			)  # extract XOR value
    qc_ha.measure(3						,    1			)  # extract AND value

    # Execute the circuit on the qasm simulator
    __UpperCamelCase  :Optional[Any]    						=	qiskit.execute(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    shots=1_000			)

    # Return the histogram data of the results of the experiment
    return job.result().get_counts(SCREAMING_SNAKE_CASE			)


if __name__ == "__main__":
    __lowercase											=      half_adder(1, 1)
    print(F'Half Adder Output Qubit Counts: {counts}')





