



"""simple docstring"""


from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching

def 			_lowerCAmelCase				(       ):
						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

						UpperCAmelCase					=			'__test_patch_submodule_mock__'
						with patch_submodule(_test_patching		,     'os.path.join'		,     lowercase_						):
												# 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 			_lowerCAmelCase				(       ):
						assert _test_patching.open is open

						UpperCAmelCase					=			'__test_patch_submodule_builtin_mock__'
						# _test_patching has "open" in its globals
						assert _test_patching.open is open
						with patch_submodule(_test_patching		,     'open'		,     lowercase_						):
												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 			_lowerCAmelCase				(       ):
						# pandas.read_csv is not present in _test_patching
						UpperCAmelCase					=			'__test_patch_submodule_missing_mock__'
						with patch_submodule(_test_patching		,     'pandas.read_csv'		,     lowercase_						):
												pass

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

def 			_lowerCAmelCase				(       ):
						UpperCAmelCase					=			'__test_patch_submodule_start_and_stop_mock__'
						UpperCAmelCase					=			patch_submodule(_test_patching		,     'open'		,     lowercase_						)
						assert _test_patching.open is open
						patch.start()
						assert _test_patching.open is mock
						patch.stop()
						assert _test_patching.open is open

def 			_lowerCAmelCase				(       ):
						from os import rename as original_rename
						from os.path import dirname as original_dirname
						from os.path import join as original_join

						UpperCAmelCase					=			'__test_patch_submodule_successive_join__'
						UpperCAmelCase					=			'__test_patch_submodule_successive_dirname__'
						UpperCAmelCase					=			'__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'		,     lowercase_						):
												with patch_submodule(_test_patching		,     'os.rename'		,     lowercase_						):
																		with patch_submodule(_test_patching		,     'os.path.dirname'		,     lowercase_						):
																								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'		,     lowercase_						):
												with patch_submodule(_test_patching		,     'os.path.join'		,     lowercase_						):
																		with patch_submodule(_test_patching		,     'os.path.dirname'		,     lowercase_						):
																								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 			_lowerCAmelCase				(       ):
						UpperCAmelCase					=			'__test_patch_submodule_doesnt_exist_mock__'
						with patch_submodule(_test_patching		,     '__module_that_doesn_exist__.__attribute_that_doesn_exist__'		,     lowercase_						):
												pass
						with patch_submodule(_test_patching		,     'os.__attribute_that_doesn_exist__'		,     lowercase_						):
												pass




"""simple docstring"""


# Copyright 2022 The HuggingFace Team and The OpenBMB Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


snake_case_    					=	{
    """configuration_cpmant""": ["""CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CpmAntConfig"""],
    """tokenization_cpmant""": ["""CpmAntTokenizer"""],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				snake_case_    					=	[
				    """CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST""",
				    """CpmAntForCausalLM""",
				    """CpmAntModel""",
				    """CpmAntPreTrainedModel""",
				]


if TYPE_CHECKING:
				from .configuration_cpmant import CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP, CpmAntConfig
				from .tokenization_cpmant import CpmAntTokenizer

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_cpmant import (
								    CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    CpmAntForCausalLM,
								    CpmAntModel,
								    CpmAntPreTrainedModel,
								)


else:
				import sys

				snake_case_    					=	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





