




from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				import os as original_os
				from os import path as original_path
				from os import rename as original_rename
				from os.path import dirname as original_dirname
				from os.path import join as original_join

				assert _test_patching.os is original_os
				assert _test_patching.path is original_path
				assert _test_patching.join is original_join

				assert _test_patching.renamed_os is original_os
				assert _test_patching.renamed_path is original_path
				assert _test_patching.renamed_join is original_join

				_lowerCAmelCase    :    List[Any]										=      """__test_patch_submodule_mock__"""
				with patch_submodule(_test_patching      ,    """os.path.join"""      ,    UpperCamelCase_       ):
								# Every way to access os.path.join must be patched, and the rest must stay untouched

								# check os.path.join
								assert isinstance(_test_patching.os      ,    _PatchedModuleObj       )
								assert isinstance(_test_patching.os.path      ,    _PatchedModuleObj       )
								assert _test_patching.os.path.join is mock

								# check path.join
								assert isinstance(_test_patching.path      ,    _PatchedModuleObj       )
								assert _test_patching.path.join is mock

								# check join
								assert _test_patching.join is mock

								# check that the other attributes are untouched
								assert _test_patching.os.rename is original_rename
								assert _test_patching.path.dirname is original_dirname
								assert _test_patching.os.path.dirname is original_dirname

								# Even renamed modules or objects must be patched

								# check renamed_os.path.join
								assert isinstance(_test_patching.renamed_os      ,    _PatchedModuleObj       )
								assert isinstance(_test_patching.renamed_os.path      ,    _PatchedModuleObj       )
								assert _test_patching.renamed_os.path.join is mock

								# check renamed_path.join
								assert isinstance(_test_patching.renamed_path      ,    _PatchedModuleObj       )
								assert _test_patching.renamed_path.join is mock

								# check renamed_join
								assert _test_patching.renamed_join is mock

								# check that the other attributes are untouched
								assert _test_patching.renamed_os.rename is original_rename
								assert _test_patching.renamed_path.dirname is original_dirname
								assert _test_patching.renamed_os.path.dirname is original_dirname

				# check that everthing is back to normal when the patch is over

				assert _test_patching.os is original_os
				assert _test_patching.path is original_path
				assert _test_patching.join is original_join

				assert _test_patching.renamed_os is original_os
				assert _test_patching.renamed_path is original_path
				assert _test_patching.renamed_join is original_join




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				assert _test_patching.open is open

				_lowerCAmelCase    :    Tuple										=      """__test_patch_submodule_builtin_mock__"""
				# _test_patching has "open" in its globals
				assert _test_patching.open is open
				with patch_submodule(_test_patching      ,    """open"""      ,    UpperCamelCase_       ):
								assert _test_patching.open is mock

				# check that everthing is back to normal when the patch is over

				assert _test_patching.open is open




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				# pandas.read_csv is not present in _test_patching
				_lowerCAmelCase    :    Optional[Any]										=      """__test_patch_submodule_missing_mock__"""
				with patch_submodule(_test_patching      ,    """pandas.read_csv"""      ,    UpperCamelCase_       ):
								pass




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				# builtin should always be mocked even if they're not in the globals
				# in case they're loaded at one point
				_lowerCAmelCase    :    Tuple										=      """__test_patch_submodule_missing_builtin_mock__"""
				# _test_patching doesn't have "len" in its globals
				assert getattr(_test_patching      ,    """len"""      ,    UpperCamelCase_       ) is None
				with patch_submodule(_test_patching      ,    """len"""      ,    UpperCamelCase_       ):
								assert _test_patching.len is mock
				assert _test_patching.len is len




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				_lowerCAmelCase    :    Dict										=      """__test_patch_submodule_start_and_stop_mock__"""
				_lowerCAmelCase    :    Optional[Any]										=      patch_submodule(_test_patching      ,    """open"""      ,    UpperCamelCase_       )
				assert _test_patching.open is open
				patch.start()
				assert _test_patching.open is mock
				patch.stop()
				assert _test_patching.open is open




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				from os import rename as original_rename
				from os.path import dirname as original_dirname
				from os.path import join as original_join

				_lowerCAmelCase    :    List[str]										=      """__test_patch_submodule_successive_join__"""
				_lowerCAmelCase    :    Optional[Any]										=      """__test_patch_submodule_successive_dirname__"""
				_lowerCAmelCase    :    Tuple										=      """__test_patch_submodule_successive_rename__"""
				assert _test_patching.os.path.join is original_join
				assert _test_patching.os.path.dirname is original_dirname
				assert _test_patching.os.rename is original_rename

				with patch_submodule(_test_patching      ,    """os.path.join"""      ,    UpperCamelCase_       ):
								with patch_submodule(_test_patching      ,    """os.rename"""      ,    UpperCamelCase_       ):
												with patch_submodule(_test_patching      ,    """os.path.dirname"""      ,    UpperCamelCase_       ):
																assert _test_patching.os.path.join is mock_join
																assert _test_patching.os.path.dirname is mock_dirname
																assert _test_patching.os.rename is mock_rename

    # try another order
				with patch_submodule(_test_patching      ,    """os.rename"""      ,    UpperCamelCase_       ):
								with patch_submodule(_test_patching      ,    """os.path.join"""      ,    UpperCamelCase_       ):
												with patch_submodule(_test_patching      ,    """os.path.dirname"""      ,    UpperCamelCase_       ):
																assert _test_patching.os.path.join is mock_join
																assert _test_patching.os.path.dirname is mock_dirname
																assert _test_patching.os.rename is mock_rename

				assert _test_patching.os.path.join is original_join
				assert _test_patching.os.path.dirname is original_dirname
				assert _test_patching.os.rename is original_rename





def 							_UpperCAmelCase  ():
				'''simple docstring'''
				_lowerCAmelCase    :    Optional[int]										=      """__test_patch_submodule_doesnt_exist_mock__"""
				with patch_submodule(_test_patching      ,    """__module_that_doesn_exist__.__attribute_that_doesn_exist__"""      ,    UpperCamelCase_       ):
								pass
				with patch_submodule(_test_patching      ,    """os.__attribute_that_doesn_exist__"""      ,    UpperCamelCase_       ):
								pass







def 							_UpperCAmelCase  (UpperCamelCase_ : str       ):
				'''simple docstring'''
				_lowerCAmelCase    :    List[str]										=      [int(UpperCamelCase_       ) for i in ip_va_address.split("""."""       ) if i.isdigit()]
				return len(UpperCamelCase_       ) == 4 and all(0 <= int(UpperCamelCase_       ) <= 254 for octet in octets       )


if __name__ == "__main__":
	_lowerCamelCase      :  List[str]      						=						input().strip()
	_lowerCamelCase      :  int      						=						"valid" if is_ip_va_address_valid(ip) else "invalid"
	print(F'''{ip} is a {valid_or_invalid} IP v4 address.''')

