


'''simple docstring'''



import subprocess
import sys

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


class 		_snake_case					(     a__	):




					@require_torch
					def 				snake_case__						(      self):
								# this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before
								# `transformers` is loaded, and it's too late for inside pytest - so we are changing it
								# while running an external program

								# python one-liner segments

								# this must be loaded before socket.socket is monkey-patched
								UpperCAmelCase__  :					List[Any]        =     """
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

								UpperCAmelCase__  :					Any        =     """
mname = \"hf-internal-testing/tiny-random-bert\"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task=\"fill-mask\", model=mname)
print(\"success\")
        """

								UpperCAmelCase__  :					List[str]        =     """
import socket
def offline_socket(*args, **kwargs): raise RuntimeError(\"Offline mode is enabled, we shouldn't access internet\")
socket.socket = offline_socket
        """

								# Force fetching the files so that we can use the cache
								UpperCAmelCase__  :					Optional[int]        =     """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
								UpperCAmelCase__  :					List[Any]        =     [sys.executable, """-c""", """\n""".join([load, run, mock])]

								# should succeed
								UpperCAmelCase__  :					Optional[int]        =     self.get_env()
								# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
								UpperCAmelCase__  :					int        =     """1"""
								UpperCAmelCase__  :					Optional[int]        =     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):
								# python one-liner segments
								# this must be loaded before socket.socket is monkey-patched
								UpperCAmelCase__  :					Tuple        =     """
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

								UpperCAmelCase__  :					str        =     """
mname = \"hf-internal-testing/tiny-random-bert\"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task=\"fill-mask\", model=mname)
print(\"success\")
        """

								UpperCAmelCase__  :					Optional[Any]        =     """
import socket
def offline_socket(*args, **kwargs): raise socket.error(\"Faking flaky internet\")
socket.socket = offline_socket
        """

								# Force fetching the files so that we can use the cache
								UpperCAmelCase__  :					List[Any]        =     """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
								UpperCAmelCase__  :					Union[str, Any]        =     [sys.executable, """-c""", """\n""".join([load, run, mock])]

								# should succeed
								UpperCAmelCase__  :					Any        =     self.get_env()
								UpperCAmelCase__  :					Optional[int]        =     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):
								# this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before
								# `transformers` is loaded, and it's too late for inside pytest - so we are changing it
								# while running an external program

								# python one-liner segments

								# this must be loaded before socket.socket is monkey-patched
								UpperCAmelCase__  :					Optional[int]        =     """
from transformers import BertConfig, BertModel, BertTokenizer
        """

								UpperCAmelCase__  :					Any        =     """
mname = \"hf-internal-testing/tiny-random-bert-sharded\"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print(\"success\")
        """

								UpperCAmelCase__  :					Dict        =     """
import socket
def offline_socket(*args, **kwargs): raise ValueError(\"Offline mode is enabled\")
socket.socket = offline_socket
        """

								# baseline - just load from_pretrained with normal network
								UpperCAmelCase__  :					Optional[int]        =     [sys.executable, """-c""", """\n""".join([load, run])]

								# should succeed
								UpperCAmelCase__  :					Union[str, Any]        =     self.get_env()
								UpperCAmelCase__  :					int        =     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
								UpperCAmelCase__  :					List[str]        =     [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
								UpperCAmelCase__  :					Tuple        =     """1"""
								UpperCAmelCase__  :					str        =     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):
								UpperCAmelCase__  :					int        =     """
from transformers import pipeline
        """
								UpperCAmelCase__  :					List[Any]        =     """
mname = \"hf-internal-testing/tiny-random-bert\"
pipe = pipeline(model=mname)
        """

								UpperCAmelCase__  :					List[str]        =     """
import socket
def offline_socket(*args, **kwargs): raise socket.error(\"Offline mode is enabled\")
socket.socket = offline_socket
        """
								UpperCAmelCase__  :					int        =     self.get_env()
								UpperCAmelCase__  :					Optional[int]        =     """1"""
								UpperCAmelCase__  :					int        =     [sys.executable, """-c""", """\n""".join([load, mock, run])]
								UpperCAmelCase__  :					List[Any]        =     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):
								UpperCAmelCase__  :					Dict        =     """
from transformers import AutoModel
        """
								UpperCAmelCase__  :					Tuple        =     """
mname = \"hf-internal-testing/test_dynamic_model\"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print(\"success\")
        """

								# baseline - just load from_pretrained with normal network
								UpperCAmelCase__  :					List[str]        =     [sys.executable, """-c""", """\n""".join([load, run])]

								# should succeed
								UpperCAmelCase__  :					Tuple        =     self.get_env()
								UpperCAmelCase__  :					Optional[Any]        =     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
								UpperCAmelCase__  :					Optional[int]        =     """1"""
								UpperCAmelCase__  :					Optional[Any]        =     subprocess.run(_lowerCamelCase							,							env=_lowerCamelCase							,							check=_lowerCamelCase							,							capture_output=_lowerCamelCase)
								self.assertEqual(result.returncode							,							0							,							result.stderr)
								self.assertIn("""success"""							,							result.stdout.decode())



'''simple docstring'''



from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__A	=logging.get_logger(__name__)

__A	={
    'xlm-mlm-en-2048': 'https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json',
    'xlm-mlm-ende-1024': 'https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json',
    'xlm-mlm-enfr-1024': 'https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json',
    'xlm-mlm-enro-1024': 'https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json',
    'xlm-mlm-tlm-xnli15-1024': 'https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json',
    'xlm-mlm-xnli15-1024': 'https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json',
    'xlm-clm-enfr-1024': 'https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json',
    'xlm-clm-ende-1024': 'https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json',
    'xlm-mlm-17-1280': 'https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json',
    'xlm-mlm-100-1280': 'https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json',
}


class 		_snake_case					(     a__	):
					lowerCAmelCase      :Any   =					'''xlm'''
					lowerCAmelCase      :Any   =					{
					    '''hidden_size''': '''emb_dim''',
					    '''num_attention_heads''': '''n_heads''',
					    '''num_hidden_layers''': '''n_layers''',
					    '''n_words''': '''vocab_size''',  # For backward compatibility
					}




					def __init__(      self							,							_lowerCamelCase=3_0145							,							_lowerCamelCase=2048							,							_lowerCamelCase=12							,							_lowerCamelCase=16							,							_lowerCamelCase=0.1							,							_lowerCamelCase=0.1							,							_lowerCamelCase=True							,							_lowerCamelCase=False							,							_lowerCamelCase=False							,							_lowerCamelCase=False							,							_lowerCamelCase=1							,							_lowerCamelCase=True							,							_lowerCamelCase=512							,							_lowerCamelCase=2048**-0.5							,							_lowerCamelCase=1e-1_2							,							_lowerCamelCase=0.02							,							_lowerCamelCase=0							,							_lowerCamelCase=1							,							_lowerCamelCase=2							,							_lowerCamelCase=3							,							_lowerCamelCase=5							,							_lowerCamelCase=True							,							_lowerCamelCase="first"							,							_lowerCamelCase=True							,							_lowerCamelCase=None							,							_lowerCamelCase=True							,							_lowerCamelCase=0.1							,							_lowerCamelCase=5							,							_lowerCamelCase=5							,							_lowerCamelCase=0							,							_lowerCamelCase=0							,							_lowerCamelCase=2							,							_lowerCamelCase=0							,							**_lowerCamelCase							,							):
								UpperCAmelCase__  :					Tuple        =     vocab_size
								UpperCAmelCase__  :					Tuple        =     emb_dim
								UpperCAmelCase__  :					Optional[Any]        =     n_layers
								UpperCAmelCase__  :					List[str]        =     n_heads
								UpperCAmelCase__  :					List[str]        =     dropout
								UpperCAmelCase__  :					Optional[int]        =     attention_dropout
								UpperCAmelCase__  :					Tuple        =     gelu_activation
								UpperCAmelCase__  :					Optional[Any]        =     sinusoidal_embeddings
								UpperCAmelCase__  :					int        =     causal
								UpperCAmelCase__  :					Union[str, Any]        =     asm
								UpperCAmelCase__  :					Optional[Any]        =     n_langs
								UpperCAmelCase__  :					List[Any]        =     use_lang_emb
								UpperCAmelCase__  :					Union[str, Any]        =     layer_norm_eps
								UpperCAmelCase__  :					List[str]        =     bos_index
								UpperCAmelCase__  :					List[Any]        =     eos_index
								UpperCAmelCase__  :					int        =     pad_index
								UpperCAmelCase__  :					str        =     unk_index
								UpperCAmelCase__  :					Dict        =     mask_index
								UpperCAmelCase__  :					str        =     is_encoder
								UpperCAmelCase__  :					Dict        =     max_position_embeddings
								UpperCAmelCase__  :					Any        =     embed_init_std
								UpperCAmelCase__  :					List[Any]        =     init_std
								UpperCAmelCase__  :					List[str]        =     summary_type
								UpperCAmelCase__  :					Union[str, Any]        =     summary_use_proj
								UpperCAmelCase__  :					Any        =     summary_activation
								UpperCAmelCase__  :					List[str]        =     summary_proj_to_labels
								UpperCAmelCase__  :					Union[str, Any]        =     summary_first_dropout
								UpperCAmelCase__  :					str        =     start_n_top
								UpperCAmelCase__  :					str        =     end_n_top
								UpperCAmelCase__  :					Tuple        =     mask_token_id
								UpperCAmelCase__  :					Union[str, Any]        =     lang_id

								if "n_words" in kwargs:
											UpperCAmelCase__  :					List[str]        =     kwargs["""n_words"""]

								super().__init__(pad_token_id=_lowerCamelCase							,							bos_token_id=_lowerCamelCase							,							**_lowerCamelCase)


class 		_snake_case					(     a__	):




					@property
					def 				snake_case__						(      self):
								if self.task == "multiple-choice":
											UpperCAmelCase__  :					Any        =     {0: """batch""", 1: """choice""", 2: """sequence"""}
								else:
											UpperCAmelCase__  :					List[Any]        =     {0: """batch""", 1: """sequence"""}
								return OrderedDict(
								    [
								        ("""input_ids""", dynamic_axis),
								        ("""attention_mask""", dynamic_axis),
								        ("""token_type_ids""", dynamic_axis),
								    ])