



'''simple docstring'''



import os
import sys
import unittest


lowerCAmelCase_  :							Dict             =    os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, 'utils'))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
lowerCAmelCase_  :							Any             =    os.path.join(git_repo_path, 'src', 'transformers')

lowerCAmelCase_  :							int             =    '\n{0} = None\n'

lowerCAmelCase_  :							Optional[Any]             =    '\nclass {0}(metaclass=DummyObject):\n    _backends = {1}\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, {1})\n'


lowerCAmelCase_  :							Union[str, Any]             =    '\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n'
class 						lowerCamelCase_				(       unittest.TestCase      ):







						def        __lowercase     (	self :   Dict					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Dict         =      find_backend('''    _import_structure["models.albert"].append("AlbertTokenizerFast")'''					)
													self.assertIsNone(lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Any         =      find_backend('''    if not is_tokenizers_available():'''					)
													self.assertEqual(lowerCAmelCase__					,     '''tokenizers'''					)

													SCREAMING_SNAKE_CASE       :   Optional[int]         =      find_backend('''    if not is_tensorflow_text_available():'''					)
													self.assertEqual(lowerCAmelCase__					,     '''tensorflow_text'''					)

													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      find_backend('''    if not (is_sentencepiece_available() and is_tokenizers_available()):'''					)
													self.assertEqual(lowerCAmelCase__					,     '''sentencepiece_and_tokenizers'''					)

													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      find_backend(
													    '''    if not (is_sentencepiece_available() and is_tensorflow_text_available()):'''					)
													self.assertEqual(lowerCAmelCase__					,     '''sentencepiece_and_tensorflow_text'''					)

													SCREAMING_SNAKE_CASE       :   List[Any]         =      find_backend(
													    '''    if not (is_sentencepiece_available() and is_tokenizers_available() and is_vision_available()):'''					)
													self.assertEqual(lowerCAmelCase__					,     '''sentencepiece_and_tokenizers_and_vision'''					)







						def        __lowercase     (	self :   str					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   List[Any]         =      read_init()
													# We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
													self.assertIn('''torch'''					,     lowerCAmelCase__					)
													self.assertIn('''tensorflow_text'''					,     lowerCAmelCase__					)
													self.assertIn('''sentencepiece_and_tokenizers'''					,     lowerCAmelCase__					)

													# Likewise, we can't assert on the exact content of a key
													self.assertIn('''BertModel'''					,     objects['''torch''']					)
													self.assertIn('''TFBertModel'''					,     objects['''tf''']					)
													self.assertIn('''FlaxBertModel'''					,     objects['''flax''']					)
													self.assertIn('''BertModel'''					,     objects['''torch''']					)
													self.assertIn('''TFBertTokenizer'''					,     objects['''tensorflow_text''']					)
													self.assertIn('''convert_slow_tokenizer'''					,     objects['''sentencepiece_and_tokenizers''']					)







						def        __lowercase     (	self :   Dict					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Dict         =      create_dummy_object('''CONSTANT'''					,     '''\'torch\''''					)
													self.assertEqual(lowerCAmelCase__					,     '''\nCONSTANT = None\n'''					)

													SCREAMING_SNAKE_CASE       :   Dict         =      create_dummy_object('''function'''					,     '''\'torch\''''					)
													self.assertEqual(
													    lowerCAmelCase__					,     '''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n'''					)

													SCREAMING_SNAKE_CASE       :   Optional[int]         =      '''
class FakeClass(metaclass=DummyObject):
    _backends = \'torch\'

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')
'''
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      create_dummy_object('''FakeClass'''					,     '''\'torch\''''					)
													self.assertEqual(lowerCAmelCase__					,     lowerCAmelCase__					)







						def        __lowercase     (	self :   Union[str, Any]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Dict         =      '''# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, ["torch"])


class FakeClass(metaclass=DummyObject):
    _backends = ["torch"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, ["torch"])
'''
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']}					)
													self.assertEqual(dummy_files['''torch''']					,     lowerCAmelCase__					)









'''simple docstring'''



from __future__ import annotations
def        UpperCAmelCase (    A	:					list[int]       ,		A	:					int					):
							if len(A					) < k or k < 0:
														raise ValueError('''Invalid Input'''					)
							SCREAMING_SNAKE_CASE       :   Dict         =      sum(array[:k]					)
							for i in range(len(A					) - k					):
														SCREAMING_SNAKE_CASE       :   Optional[Any]         =      current_sum - array[i] + array[i + k]
														SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      max(A       ,		A					)
							return max_sum


if __name__ == "__main__":
							from doctest import testmod
							from random import randint

							testmod()
							lowerCAmelCase_  :							Optional[int]             =    [randint(-1000, 1000) for i in range(100)]
							lowerCAmelCase_  :							Optional[int]             =    randint(0, 110)
							print(f'The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}')




