




import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


__lowerCAmelCase						:							List[str]			     =						"""
Hugging 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.

In March 2021, Hugging Face raised $40 million in a Series B funding round.[3]

On 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]
"""




class        snake_case__				(unittest.TestCase       ,			_a  ):
				"""simple docstring"""



				def 				__UpperCAmelCase				( self							:	Optional[Any]				)   ->	List[Any]:
							a       =     load_tool("summarization"				)
							self.tool.setup()
							a       =     load_tool("summarization"   , remote=snake_case_				)





				def 				__UpperCAmelCase				( self							:	List[Any]				)   ->	List[Any]:
							a       =     self.tool(snake_case_				)
							self.assertEqual(
							    snake_case_   , "Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."   , )





				def 				__UpperCAmelCase				( self							:	List[Any]				)   ->	int:
							a       =     self.remote_tool(snake_case_				)
							self.assertEqual(
							    snake_case_   , "Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."   , )





				def 				__UpperCAmelCase				( self							:	Any				)   ->	Optional[Any]:
							a       =     self.tool(text=snake_case_				)
							self.assertEqual(
							    snake_case_   , "Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."   , )





				def 				__UpperCAmelCase				( self							:	str				)   ->	str:
							a       =     self.remote_tool(text=snake_case_				)
							self.assertEqual(
							    snake_case_   , "Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."   , )














"""simple docstring"""





import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A__       :			int=						logging.get_logger(__name__)

A__       :			Optional[int]=						{
    """facebook/hubert-base-ls960""": """https://huggingface.co/facebook/hubert-base-ls960/resolve/main/config.json""",
    # See all Hubert models at https://huggingface.co/models?filter=hubert
}
class  __lowerCamelCase     (	_a	):
   a   :					Dict			    ="""hubert"""

   def __init__(       self			,					snake_case_=32			,					snake_case_=768			,					snake_case_=12			,					snake_case_=12			,					snake_case_=3072			,					snake_case_="gelu"			,					snake_case_=0.1			,					snake_case_=0.1			,					snake_case_=0.1			,					snake_case_=True			,					snake_case_=0.0			,					snake_case_=0.1			,					snake_case_=0.1			,					snake_case_=0.02			,					snake_case_=1E-5			,					snake_case_="group"			,					snake_case_="gelu"			,					snake_case_=(512, 512, 512, 512, 512, 512, 512)			,					snake_case_=(5, 2, 2, 2, 2, 2, 2)			,					snake_case_=(10, 3, 3, 3, 3, 2, 2)			,					snake_case_=False			,					snake_case_=128			,					snake_case_=16			,					snake_case_=False			,					snake_case_=True			,					snake_case_=0.05			,					snake_case_=10			,					snake_case_=2			,					snake_case_=0.0			,					snake_case_=10			,					snake_case_=0			,					snake_case_="sum"			,					snake_case_=False			,					snake_case_=False			,					snake_case_=256			,					snake_case_=0			,					snake_case_=1			,					snake_case_=2			,					**snake_case_			,					)		->							Any:
       super().__init__(**snake_case_			,					pad_token_id=snake_case_			,					bos_token_id=snake_case_			,					eos_token_id=snake_case_   )
       UpperCamelCase__								=     hidden_size
       UpperCamelCase__								=     feat_extract_norm
       UpperCamelCase__								=     feat_extract_activation
       UpperCamelCase__								=     list(snake_case_   )
       UpperCamelCase__								=     list(snake_case_   )
       UpperCamelCase__								=     list(snake_case_   )
       UpperCamelCase__								=     conv_bias
       UpperCamelCase__								=     num_conv_pos_embeddings
       UpperCamelCase__								=     num_conv_pos_embedding_groups
       UpperCamelCase__								=     len(self.conv_dim   )
       UpperCamelCase__								=     num_hidden_layers
       UpperCamelCase__								=     intermediate_size
       UpperCamelCase__								=     hidden_act
       UpperCamelCase__								=     num_attention_heads
       UpperCamelCase__								=     hidden_dropout
       UpperCamelCase__								=     attention_dropout
       UpperCamelCase__								=     activation_dropout
       UpperCamelCase__								=     feat_proj_layer_norm
       UpperCamelCase__								=     feat_proj_dropout
       UpperCamelCase__								=     final_dropout
       UpperCamelCase__								=     layerdrop
       UpperCamelCase__								=     layer_norm_eps
       UpperCamelCase__								=     initializer_range
       UpperCamelCase__								=     vocab_size
       UpperCamelCase__								=     do_stable_layer_norm
       UpperCamelCase__								=     use_weighted_layer_sum
       UpperCamelCase__								=     classifier_proj_size

       if (
           (len(self.conv_stride   ) != self.num_feat_extract_layers)
           or (len(self.conv_kernel   ) != self.num_feat_extract_layers)
           or (len(self.conv_dim   ) != self.num_feat_extract_layers)
       ):
           raise ValueError(
               'Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='
               ' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='
               F' {len(self.conv_dim   )}`, `len(config.conv_stride) = {len(self.conv_stride   )}`,'
               F' `len(config.conv_kernel) = {len(self.conv_kernel   )}`.'   )

       # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
       UpperCamelCase__								=     apply_spec_augment
       UpperCamelCase__								=     mask_time_prob
       UpperCamelCase__								=     mask_time_length
       UpperCamelCase__								=     mask_time_min_masks
       UpperCamelCase__								=     mask_feature_prob
       UpperCamelCase__								=     mask_feature_length
       UpperCamelCase__								=     mask_feature_min_masks

       # ctc loss
       UpperCamelCase__								=     ctc_loss_reduction
       UpperCamelCase__								=     ctc_zero_infinity







   @property
   def     SCREAMING_SNAKE_CASE__			(       self   )		->							Dict:
       return functools.reduce(operator.mul			,					self.conv_stride			,					1   )




