





'''simple docstring'''







import subprocess
import sys

from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch
class 				__SCREAMING_SNAKE_CASE  (lowerCamelCase_      ):






				"""simple docstring"""







				@require_torch
				def   UpperCamelCase__   (  self     :					str					):
								# 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
								_a								= "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        "

								_a								= "\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        "

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

								# 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(__a					,				env=__a					,				check=__a					,				capture_output=__a					)
								self.assertEqual(result.returncode					,				0					,				result.stderr					)
								self.assertIn("success"					,				result.stdout.decode()					)




				@require_torch
				def   UpperCamelCase__   (  self     :					Optional[Any]					):
								# python one-liner segments
								# this must be loaded before socket.socket is monkey-patched
								_a								= "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        "

								_a								= "\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        "

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

								# 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(__a					,				env=__a					,				check=__a					,				capture_output=__a					)
								self.assertEqual(result.returncode					,				0					,				result.stderr					)
								self.assertIn("success"					,				result.stdout.decode()					)




				@require_torch
				def   UpperCamelCase__   (  self     :					List[Any]					):
								# 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
								_a								= "\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        "

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

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

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




				@require_torch
				def   UpperCamelCase__   (  self     :					Optional[Any]					):
								_a								= "\nfrom transformers import pipeline\n        "
								_a								= "\nmname = \"hf-internal-testing/tiny-random-bert\"\npipe = pipeline(model=mname)\n        "

								_a								= "\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error(\"Offline mode is enabled\")\nsocket.socket = offline_socket\n        "
								_a								= self.get_env()
								_a								= "1"
								_a								= [sys.executable, "-c", "\n".join([load, mock, run]					)]
								_a								= subprocess.run(__a					,				env=__a					,				check=__a					,				capture_output=__a					)
								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   UpperCamelCase__   (  self     :					str					):
								_a								= "\nfrom transformers import AutoModel\n        "
								_a								= "\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
								_a								= [sys.executable, "-c", "\n".join([load, run]					)]

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







from itertools import count


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase = 50 )			->     int:
    lowerCamelCase__    :      Optional[Any]					 =		[1] * min_block_length

    for n in count(_UpperCAmelCase ):
        fill_count_functions.append(1 )

        for block_length in range(_UpperCAmelCase						,	n + 1 ):
            for block_start in range(n - block_length ):
                fill_count_functions[n] += fill_count_functions[
                    n - block_start - block_length - 1
                ]

            fill_count_functions[n] += 1

        if fill_count_functions[n] > 100_0000:
            break

    return n


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





