






"""simple docstring"""
from ....configuration_utils import PretrainedConfig
from ....utils import logging


SCREAMING_SNAKE_CASE__      						=  logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__      						=  {
    "speechbrain/m-ctc-t-large": "https://huggingface.co/speechbrain/m-ctc-t-large/resolve/main/config.json",
    # See all M-CTC-T models at https://huggingface.co/models?filter=mctct
}



class   lowerCAmelCase_    (			lowercase__					):



				"""simple docstring"""
				_lowerCAmelCase     :    str			  =						"""mctct"""

				def __init__(				self		,    lowerCAmelCase=80_65		,    lowerCAmelCase=15_36		,    lowerCAmelCase=36		,    lowerCAmelCase=61_44		,    lowerCAmelCase=4		,    lowerCAmelCase=3_84		,    lowerCAmelCase=9_20		,    lowerCAmelCase=1E-5		,    lowerCAmelCase=0.3		,    lowerCAmelCase="relu"		,    lowerCAmelCase=0.02		,    lowerCAmelCase=0.3		,    lowerCAmelCase=0.3		,    lowerCAmelCase=1		,    lowerCAmelCase=0		,    lowerCAmelCase=2		,    lowerCAmelCase=1		,    lowerCAmelCase=0.3		,    lowerCAmelCase=1		,    lowerCAmelCase=(7,)		,    lowerCAmelCase=(3,)		,    lowerCAmelCase=80		,    lowerCAmelCase=1		,    lowerCAmelCase=None		,    lowerCAmelCase="sum"		,    lowerCAmelCase=False		,    **lowerCAmelCase		,    ):






										"""simple docstring"""

										super().__init__(**UpperCAmelCase__		,    pad_token_id=UpperCAmelCase__		,    bos_token_id=UpperCAmelCase__		,    eos_token_id=UpperCAmelCase__    )
										snake_case								=			vocab_size
										snake_case								=			hidden_size
										snake_case								=			num_hidden_layers
										snake_case								=			intermediate_size
										snake_case								=			num_attention_heads
										snake_case								=			attention_head_dim
										snake_case								=			max_position_embeddings
										snake_case								=			layer_norm_eps
										snake_case								=			layerdrop
										snake_case								=			hidden_act
										snake_case								=			initializer_range
										snake_case								=			hidden_dropout_prob
										snake_case								=			attention_probs_dropout_prob
										snake_case								=			pad_token_id
										snake_case								=			bos_token_id
										snake_case								=			eos_token_id
										snake_case								=			conv_glu_dim
										snake_case								=			conv_dropout
										snake_case								=			num_conv_layers
										snake_case								=			input_feat_per_channel
										snake_case								=			input_channels
										snake_case								=			conv_channels
										snake_case								=			ctc_loss_reduction
										snake_case								=			ctc_zero_infinity

										# prevents config testing fail with exporting to json
										snake_case								=			list(UpperCAmelCase__    )
										snake_case								=			list(UpperCAmelCase__    )

										if len(self.conv_kernel    ) != self.num_conv_layers:
																raise ValueError(
																    'Configuration for convolutional module is incorrect. '
																    'It is required that `len(config.conv_kernel)` == `config.num_conv_layers` '
																    F"""but is `len(config.conv_kernel) = {len(self.conv_kernel    )}`, """
																    F"""`config.num_conv_layers = {self.num_conv_layers}`."""    )



"""simple docstring"""
import subprocess
import sys

from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch



class   lowerCAmelCase_    (			lowerCAmelCase					):



				"""simple docstring"""

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

										snake_case								=			'\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

										snake_case								=			'\nimport socket\ndef offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")\nsocket.socket = offline_socket\n        '

										# Force fetching the files so that we can use the cache
										snake_case								=			'hf-internal-testing/tiny-random-bert'
										BertConfig.from_pretrained(lowerCAmelCase    )
										BertModel.from_pretrained(lowerCAmelCase    )
										BertTokenizer.from_pretrained(lowerCAmelCase    )
										pipeline(task='fill-mask'		,    model=lowerCAmelCase    )

										# baseline - just load from_pretrained with normal network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, run, mock]    )]

										# should succeed
										snake_case								=			self.get_env()
										# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
										snake_case								=			'1'
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

										snake_case								=			'\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

										snake_case								=			'\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")\nsocket.socket = offline_socket\n        '

										# Force fetching the files so that we can use the cache
										snake_case								=			'hf-internal-testing/tiny-random-bert'
										BertConfig.from_pretrained(lowerCAmelCase    )
										BertModel.from_pretrained(lowerCAmelCase    )
										BertTokenizer.from_pretrained(lowerCAmelCase    )
										pipeline(task='fill-mask'		,    model=lowerCAmelCase    )

										# baseline - just load from_pretrained with normal network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, run, mock]    )]

										# should succeed
										snake_case								=			self.get_env()
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        '

										snake_case								=			'\nmname = "hf-internal-testing/tiny-random-bert-sharded"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint("success")\n        '

										snake_case								=			'\nimport socket\ndef offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")\nsocket.socket = offline_socket\n        '

										# baseline - just load from_pretrained with normal network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, run]    )]

										# should succeed
										snake_case								=			self.get_env()
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

										# next emulate no network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, mock, run]    )]

										# Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
										# env["TRANSFORMERS_OFFLINE"] = "0"
										# result = subprocess.run(cmd, env=env, check=False, capture_output=True)
										# self.assertEqual(result.returncode, 1, result.stderr)

										# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
										snake_case								=			'1'
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import pipeline\n        '
										snake_case								=			'\nmname = "hf-internal-testing/tiny-random-bert"\npipe = pipeline(model=mname)\n        '

										snake_case								=			'\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")\nsocket.socket = offline_socket\n        '
										snake_case								=			self.get_env()
										snake_case								=			'1'
										snake_case								=			[sys.executable, '-c', '\n'.join([load, mock, run]    )]
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    1		,    result.stderr    )
										self.assertIn(
										    'You cannot infer task automatically within `pipeline` when using offline mode'		,    result.stderr.decode().replace('\n'		,    ''    )		,    )

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import AutoModel\n        '
										snake_case								=			'\nmname = "hf-internal-testing/test_dynamic_model"\nAutoModel.from_pretrained(mname, trust_remote_code=True)\nprint("success")\n        '

										# baseline - just load from_pretrained with normal network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, run]    )]

										# should succeed
										snake_case								=			self.get_env()
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

										# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
										snake_case								=			'1'
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )


