





'''simple docstring'''






import time
import unittest

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

from ..test_modeling_common import ids_tensor


if is_torch_available():
      import torch

      from transformers.generation import (
          MaxLengthCriteria,
          MaxNewTokensCriteria,
          MaxTimeCriteria,
          StoppingCriteriaList,
          validate_stopping_criteria,
      )







@require_torch
class 		UpperCAmelCase (					unittest.TestCase):


  """simple docstring"""







  def 	UpperCamelCase__   (					self     :       Any				,						UpperCamelCase__     :       Union[str, Any]	)  ->    int:
    _UpperCamelCase							      =3
    _UpperCamelCase							      =250

    _UpperCamelCase							      =ids_tensor((batch_size, length)				,						UpperCamelCase__	)
    _UpperCamelCase							      =torch.ones((batch_size, length)				,						device=UpperCamelCase__				,						dtype=torch.float	) / length
    return input_ids, scores


  def 	UpperCamelCase__   (					self     :       str	)  ->    Optional[int]:
    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(5	)

    _UpperCamelCase							      =StoppingCriteriaList(
        [
            MaxLengthCriteria(max_length=10	),
            MaxTimeCriteria(max_time=0.1	),
        ]	)

    self.assertFalse(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)

    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(9	)
    self.assertFalse(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)

    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(10	)
    self.assertTrue(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)


  def 	UpperCamelCase__   (					self     :       Tuple	)  ->    int:
    _UpperCamelCase							      =MaxLengthCriteria(max_length=10	)

    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(5	)
    self.assertFalse(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)

    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(9	)
    self.assertFalse(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)

    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(10	)
    self.assertTrue(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)


  def 	UpperCamelCase__   (					self     :       List[Any]	)  ->    Any:
    _UpperCamelCase							      =MaxNewTokensCriteria(start_length=5				,						max_new_tokens=5	)

    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(5	)
    self.assertFalse(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)

    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(9	)
    self.assertFalse(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)

    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(10	)
    self.assertTrue(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)

    _UpperCamelCase							      =StoppingCriteriaList([criteria]	)
    self.assertEqual(criteria_list.max_length				,						10	)


  def 	UpperCamelCase__   (					self     :       Union[str, Any]	)  ->    Tuple:
    _UpperCamelCase      ,  _UpperCamelCase							      =self._get_tensors(5	)

    _UpperCamelCase							      =MaxTimeCriteria(max_time=0.1	)
    self.assertFalse(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)

    _UpperCamelCase							      =MaxTimeCriteria(max_time=0.1				,						initial_timestamp=time.time() - 0.2	)
    self.assertTrue(criteria(UpperCamelCase__				,						UpperCamelCase__	)	)




  def 	UpperCamelCase__   (					self     :       Any	)  ->    Optional[Any]:
    validate_stopping_criteria(StoppingCriteriaList([MaxLengthCriteria(10	)]	)				,						10	)

    with self.assertWarns(UpperCamelCase__	):
      validate_stopping_criteria(StoppingCriteriaList([MaxLengthCriteria(10	)]	)				,						11	)

    _UpperCamelCase							      =validate_stopping_criteria(StoppingCriteriaList()				,						11	)

    self.assertEqual(len(UpperCamelCase__	)				,						1	)









import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


lowercase_   							=  '\nHugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf originally as a company that developed a chatbot app targeted at teenagers.[2] After open-sourcing the model behind the chatbot, the company pivoted to focus on being a platform for machine learning.\n\nIn March 2021, Hugging Face raised $40 million in a Series B funding round.[3]\n\nOn April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model.[4] In 2022, the workshop concluded with the announcement of BLOOM, a multilingual large language model with 176 billion parameters.[5]\n'





class 					__lowerCAmelCase	(   unittest.TestCase     ,     SCREAMING_SNAKE_CASE				):




  def     A__	(							self   )    ->					Union[str, Any]:
        '''simple docstring'''






        _lowercase      			=load_tool('text-question-answering'   )
        self.tool.setup()
        _lowercase      			=load_tool('text-question-answering'				,  remote=lowerCAmelCase   )




  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=self.tool(lowerCAmelCase				,  'What did Hugging Face do in April 2021?'   )
        self.assertEqual(lowerCAmelCase				,  'launched the BigScience Research Workshop'   )




  def     A__	(							self   )    ->					Optional[Any]:
        '''simple docstring'''






        _lowercase      			=self.remote_tool(lowerCAmelCase				,  'What did Hugging Face do in April 2021?'   )
        self.assertEqual(lowerCAmelCase				,  'launched the BigScience Research Workshop'   )




  def     A__	(							self   )    ->					Any:
        '''simple docstring'''






        _lowercase      			=self.tool(text=lowerCAmelCase				,  question='What did Hugging Face do in April 2021?'   )
        self.assertEqual(lowerCAmelCase				,  'launched the BigScience Research Workshop'   )




  def     A__	(							self   )    ->					Optional[int]:
        '''simple docstring'''






        _lowercase      			=self.remote_tool(text=lowerCAmelCase				,  question='What did Hugging Face do in April 2021?'   )
        self.assertEqual(lowerCAmelCase				,  'launched the BigScience Research Workshop'   )


