

'''simple docstring'''







import subprocess
import sys

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


class 					A__      (      _snake_case			):



				@require_torch
				def 					snake_case_			(					self       )						->      Dict:





											'''simple docstring'''
											A_						=      """
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

											A_						=      """
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\")
        """

											A_						=      """
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
											A_						=      """hf-internal-testing/tiny-random-bert"""
											BertConfig.from_pretrained(UpperCamelCase__       )
											BertModel.from_pretrained(UpperCamelCase__       )
											BertTokenizer.from_pretrained(UpperCamelCase__       )
											pipeline(task="""fill-mask"""		,				model=UpperCamelCase__       )

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

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



				@require_torch
				def 					snake_case_			(					self       )						->      str:





											'''simple docstring'''
											A_						=      """
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

											A_						=      """
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\")
        """

											A_						=      """
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
											A_						=      """hf-internal-testing/tiny-random-bert"""
											BertConfig.from_pretrained(UpperCamelCase__       )
											BertModel.from_pretrained(UpperCamelCase__       )
											BertTokenizer.from_pretrained(UpperCamelCase__       )
											pipeline(task="""fill-mask"""		,				model=UpperCamelCase__       )

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

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



				@require_torch
				def 					snake_case_			(					self       )						->      Optional[int]:





											'''simple docstring'''
											A_						=      """
from transformers import BertConfig, BertModel, BertTokenizer
        """

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

											A_						=      """
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
											A_						=      [sys.executable, """-c""", """\n""".join([load, run]       )]

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

											# next emulate no network
											A_						=      [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
											A_						=      """1"""
											A_						=      subprocess.run(UpperCamelCase__		,				env=UpperCamelCase__		,				check=UpperCamelCase__		,				capture_output=UpperCamelCase__       )
											self.assertEqual(result.returncode		,				0		,				result.stderr       )
											self.assertIn("""success"""		,				result.stdout.decode()       )



				@require_torch
				def 					snake_case_			(					self       )						->      List[str]:





											'''simple docstring'''
											A_						=      """
from transformers import pipeline
        """
											A_						=      """
mname = \"hf-internal-testing/tiny-random-bert\"
pipe = pipeline(model=mname)
        """

											A_						=      """
import socket
def offline_socket(*args, **kwargs): raise socket.error(\"Offline mode is enabled\")
socket.socket = offline_socket
        """
											A_						=      self.get_env()
											A_						=      """1"""
											A_						=      [sys.executable, """-c""", """\n""".join([load, mock, run]       )]
											A_						=      subprocess.run(UpperCamelCase__		,				env=UpperCamelCase__		,				check=UpperCamelCase__		,				capture_output=UpperCamelCase__       )
											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       )						->      Optional[int]:





											'''simple docstring'''
											A_						=      """
from transformers import AutoModel
        """
											A_						=      """
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
											A_						=      [sys.executable, """-c""", """\n""".join([load, run]       )]

											# should succeed
											A_						=      self.get_env()
											A_						=      subprocess.run(UpperCamelCase__		,				env=UpperCamelCase__		,				check=UpperCamelCase__		,				capture_output=UpperCamelCase__       )
											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
											A_						=      """1"""
											A_						=      subprocess.run(UpperCamelCase__		,				env=UpperCamelCase__		,				check=UpperCamelCase__		,				capture_output=UpperCamelCase__       )
											self.assertEqual(result.returncode		,				0		,				result.stderr       )
											self.assertIn("""success"""		,				result.stdout.decode()       )



'''simple docstring'''







def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			bool:
       return str(UpperCAmelCase__				) == str(UpperCAmelCase__				)[::-1]
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			int:
       return int(UpperCAmelCase__				) + int(str(UpperCAmelCase__				)[::-1]				)
def       UpperCAmelCase__    (      UpperCAmelCase__ = 1_00_00				)			->			int:
       A_						=      []
       for num in range(1,       UpperCAmelCase__				):
              A_						=      0
              A_						=      num
              while iterations < 50:
                     A_						=      sum_reverse(UpperCAmelCase__				)
                     iterations += 1
                     if is_palindrome(UpperCAmelCase__				):
                            break
              else:
                     lychrel_nums.append(UpperCAmelCase__				)
       return len(UpperCAmelCase__				)


if __name__ == "__main__":
      print(f"""{solution() = }""")
