






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__      :				str				    =						MODEL_FOR_CAUSAL_LM_MAPPING
		UpperCAmelCase__      :				Any				    =						TF_MODEL_FOR_CAUSAL_LM_MAPPING


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

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

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


		@require_tf
		def   __snake_case			(						self       ):
						SCREAMING_SNAKE_CASE_   :	Dict													=   pipeline(task='text-generation' ,    model='sshleifer/tiny-ctrl' ,    framework='tf'       )

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

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


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

						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   text_generator(UpperCamelCase__ ,    stop_sequence=' fe'       )
						self.assertEqual(UpperCamelCase__ ,    [{'generated_text': 'Hello I believe in fe'}]       )


		def   __snake_case			(						self ,    UpperCamelCase__ ,    UpperCamelCase__       ):
						SCREAMING_SNAKE_CASE_   :	List[Any]													=   text_generator.model
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   text_generator.tokenizer

						SCREAMING_SNAKE_CASE_   :	Tuple													=   text_generator('This is a test'       )
						self.assertEqual(UpperCamelCase__ ,    [{'generated_text': ANY(UpperCamelCase__       )}]       )
						self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'       )       )

						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   text_generator('This is a test' ,    return_full_text=UpperCamelCase__       )
						self.assertEqual(UpperCamelCase__ ,    [{'generated_text': ANY(UpperCamelCase__       )}]       )
						self.assertNotIn('This is a test' ,    outputs[0]['generated_text']       )

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

						SCREAMING_SNAKE_CASE_   :	List[str]													=   text_generator('This is a test' ,    return_full_text=UpperCamelCase__       )
						self.assertEqual(UpperCamelCase__ ,    [{'generated_text': ANY(UpperCamelCase__       )}]       )
						self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'       )       )

						SCREAMING_SNAKE_CASE_   :	Any													=   text_generator(['This is great !', 'Something else'] ,    num_return_sequences=2 ,    do_sample=UpperCamelCase__       )
						self.assertEqual(
						    UpperCamelCase__ ,    [
						        [{'generated_text': ANY(UpperCamelCase__       )}, {'generated_text': ANY(UpperCamelCase__       )}],
						        [{'generated_text': ANY(UpperCamelCase__       )}, {'generated_text': ANY(UpperCamelCase__       )}],
						    ] ,    )

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

						with self.assertRaises(UpperCamelCase__       ):
										SCREAMING_SNAKE_CASE_   :	List[Any]													=   text_generator('test' ,    return_full_text=UpperCamelCase__ ,    return_text=UpperCamelCase__       )
						with self.assertRaises(UpperCamelCase__       ):
										SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   text_generator('test' ,    return_full_text=UpperCamelCase__ ,    return_tensors=UpperCamelCase__       )
						with self.assertRaises(UpperCamelCase__       ):
										SCREAMING_SNAKE_CASE_   :	Tuple													=   text_generator('test' ,    return_text=UpperCamelCase__ ,    return_tensors=UpperCamelCase__       )

						# 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__
						):
										SCREAMING_SNAKE_CASE_   :	Tuple													=   text_generator(''       )
										self.assertEqual(UpperCamelCase__ ,    [{'generated_text': ANY(UpperCamelCase__       )}]       )
						else:
										with self.assertRaises((ValueError, AssertionError)       ):
														SCREAMING_SNAKE_CASE_   :	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.
						SCREAMING_SNAKE_CASE_   :	List[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       )

										SCREAMING_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(UpperCamelCase__       ):
														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       ):
						import torch

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

						SCREAMING_SNAKE_CASE_   :	Optional[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   __snake_case			(						self       ):
						import torch

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






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

						# The user only sets one -> no warning
						with CaptureLogger(UpperCamelCase__       ) as cl:
										SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   text_generator(UpperCamelCase__ ,    max_new_tokens=1       )
						self.assertNotIn(UpperCamelCase__ ,    cl.out       )

						with CaptureLogger(UpperCamelCase__       ) as cl:
										SCREAMING_SNAKE_CASE_   :	str													=   text_generator(UpperCamelCase__ ,    max_length=10       )
						self.assertNotIn(UpperCamelCase__ ,    cl.out       )







from datetime import datetime

import requests
from bsa import BeautifulSoup

if __name__ == "__main__":
				A        =			input('Enter image url: ').strip()
				print(f"""Downloading image from {url} ...""")
				A        =			BeautifulSoup(requests.get(url).content, 'html.parser')
				# The image URL is in the content field of the first meta tag with property og:image
				A        =			soup.find('meta', {'property': 'og:image'})['content']
				A        =			requests.get(image_url).content
				A        =			f"""{datetime.now():%Y-%m-%d_%H:%M:%S}.jpg"""
				with open(file_name, 'wb') as fp:
								fp.write(image_data)
				print(f"""Done. Image saved to disk as {file_name}.""")