



from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching



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

    A__		 =					'''__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 		lowerCAmelCase__    (					)->  Optional[int]:
    assert _test_patching.open is open

    A__		 =					'''__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 		lowerCAmelCase__    (					)->  Optional[Any]:
    # pandas.read_csv is not present in _test_patching
    A__		 =					'''__test_patch_submodule_missing_mock__'''
    with patch_submodule(_test_patching ,       '''pandas.read_csv''' ,       UpperCamelCase_	):
        pass



def 		lowerCAmelCase__    (					)->  Tuple:
    # builtin should always be mocked even if they're not in the globals
    # in case they're loaded at one point
    A__		 =					'''__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 		lowerCAmelCase__    (					)->  str:
    A__		 =					'''__test_patch_submodule_start_and_stop_mock__'''
    A__		 =					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 		lowerCAmelCase__    (					)->  Optional[int]:
    from os import rename as original_rename
    from os.path import dirname as original_dirname
    from os.path import join as original_join

    A__		 =					'''__test_patch_submodule_successive_join__'''
    A__		 =					'''__test_patch_submodule_successive_dirname__'''
    A__		 =					'''__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 		lowerCAmelCase__    (					)->  Tuple:
    A__		 =					'''__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





import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import load_iris
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from xgboost import XGBClassifier



def 		lowerCAmelCase__    (					UpperCamelCase_				:       dict	)->  tuple:
    return (data["data"], data["target"])



def 		lowerCAmelCase__    (					UpperCamelCase_				:       np.ndarray ,       UpperCamelCase_				:       np.ndarray	)->  XGBClassifier:
    A__		 =					XGBClassifier()
    classifier.fit(UpperCamelCase_ ,       UpperCamelCase_	)
    return classifier



def 		lowerCAmelCase__    (					)->  None:
    A__		 =					load_iris()
    A__ ,	A__		 =					data_handling(UpperCamelCase_	)
    A__ ,	A__ ,	A__ ,	A__		 =					train_test_split(
        UpperCamelCase_ ,       UpperCamelCase_ ,       test_size=0.25	)

    A__		 =					iris['''target_names''']

    # Create an XGBoost Classifier from the training data
    A__		 =					xgboost(UpperCamelCase_ ,       UpperCamelCase_	)

    # Display the confusion matrix of the classifier with both training and test sets
    ConfusionMatrixDisplay.from_estimator(
        UpperCamelCase_ ,       UpperCamelCase_ ,       UpperCamelCase_ ,       display_labels=UpperCamelCase_ ,       cmap='''Blues''' ,       normalize='''true''' ,       )
    plt.title('''Normalized Confusion Matrix - IRIS Dataset'''	)
    plt.show()


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)
   main()
