






import subprocess
import sys

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







class 				UpperCAmelCase_  (		__lowerCamelCase		):




     @require_torch
     def   __UpperCAmelCase  (				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, pipeline
        """

          UpperCAmelCase__      :  Optional[int]				      =			"""
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__      :  Dict				      =			"""
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__      :  List[str]				      =			"""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__      :  Optional[Any]				      =			[sys.executable, """-c""", """\n""".join([load, run, mock]		)]

          # should succeed
          UpperCAmelCase__      :  int				      =			self.get_env()
          # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
          UpperCAmelCase__      :  int				      =			"""1"""
          UpperCAmelCase__      :  Union[str, Any]				      =			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   __UpperCAmelCase  (				self		):
          # 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__      :  Optional[int]				      =			"""
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__      :  int				      =			"""
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__      :  Union[str, 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__      :  Any				      =			[sys.executable, """-c""", """\n""".join([load, run, mock]		)]

          # should succeed
          UpperCAmelCase__      :  Any				      =			self.get_env()
          UpperCAmelCase__      :  List[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   __UpperCAmelCase  (				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__      :  int				      =			"""
from transformers import BertConfig, BertModel, BertTokenizer
        """

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

          UpperCAmelCase__      :  List[Any]				      =			"""
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__      :  Union[str, Any]				      =			[sys.executable, """-c""", """\n""".join([load, run]		)]

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

          UpperCAmelCase__      :  Optional[Any]				      =			"""
import socket
def offline_socket(*args, **kwargs): raise socket.error(\"Offline mode is enabled\")
socket.socket = offline_socket
        """
          UpperCAmelCase__      :  Optional[Any]				      =			self.get_env()
          UpperCAmelCase__      :  List[Any]				      =			"""1"""
          UpperCAmelCase__      :  Optional[int]				      =			[sys.executable, """-c""", """\n""".join([load, mock, run]		)]
          UpperCAmelCase__      :  List[str]				      =			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   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  int				      =			"""
from transformers import AutoModel
        """
          UpperCAmelCase__      :  str				      =			"""
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__      :  int				      =			[sys.executable, """-c""", """\n""".join([load, run]		)]

          # should succeed
          UpperCAmelCase__      :  List[str]				      =			self.get_env()
          UpperCAmelCase__      :  Dict				      =			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__      :  Union[str, Any]				      =			"""1"""
          UpperCAmelCase__      :  Union[str, Any]				      =			subprocess.run(_lowerCAmelCase	,						env=_lowerCAmelCase	,						check=_lowerCAmelCase	,						capture_output=_lowerCAmelCase		)
          self.assertEqual(result.returncode	,						0	,						result.stderr		)
          self.assertIn("""success"""	,						result.stdout.decode()		)








from collections.abc import Sequence


def 				__A(lowerCAmelCase = None			)		->					int:

		"""simple docstring"""






		if nums is None or not nums:
				raise ValueError("""Input sequence should not be empty"""			)

		_UpperCamelCase         =						nums[0]
		for i in range(1    ,	len(lowerCAmelCase			)			):
				_UpperCamelCase         =						nums[i]
				_UpperCamelCase         =						max(lowerCAmelCase    ,	ans + num    ,	lowerCAmelCase			)

		return ans


if __name__ == "__main__":
		import doctest

		doctest.testmod()

		# Try on a sample input from the user
		lowerCamelCase__						=				int(input("Enter number of elements : ").strip())
		lowerCamelCase__						=				list(map(int, input("\nEnter the numbers : ").strip().split()))[:n]
		print(max_subsequence_sum(array))



