'''simple docstring'''




import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar

class 	lowerCamelCase_	(unittest.TestCase    ):
      '''simple docstring'''

      def      _A	(       self						:				List[Any]       ):
             _UpperCAmelCase     :  List[Any]							      =    logging.get_logger()

             # the current default level is logging.WARNING
             _UpperCAmelCase     :  int							      =    logging.get_verbosity()

             logging.set_verbosity_error()
             self.assertEqual(logger.getEffectiveLevel()						,					logging.get_verbosity()       )

             logging.set_verbosity_warning()
             self.assertEqual(logger.getEffectiveLevel()						,					logging.get_verbosity()       )

             logging.set_verbosity_info()
             self.assertEqual(logger.getEffectiveLevel()						,					logging.get_verbosity()       )

             logging.set_verbosity_debug()
             self.assertEqual(logger.getEffectiveLevel()						,					logging.get_verbosity()       )

             # restore to the original level
             logging.set_verbosity(A       )




      def      _A	(       self						:				int       ):
             _UpperCAmelCase     :  int							      =    logging.get_verbosity()

             _UpperCAmelCase     :  int							      =    logging.get_logger("transformers.models.bart.tokenization_bart"       )
             _UpperCAmelCase     :  List[str]							      =    "Testing 1, 2, 3"

             # should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
             if level_origin <= logging.WARNING:
                    with CaptureLogger(A       ) as cl:
                           logger.warning(A       )
                    self.assertEqual(cl.out						,					msg + "\n"       )

             # this is setting the level for all of `transformers.*` loggers
             logging.set_verbosity_error()

             # should not be able to log warnings
             with CaptureLogger(A       ) as cl:
                    logger.warning(A       )
             self.assertEqual(cl.out						,					""       )

             # should be able to log warnings again
             logging.set_verbosity_warning()
             with CaptureLogger(A       ) as cl:
                    logger.warning(A       )
             self.assertEqual(cl.out						,					msg + "\n"       )

             # restore to the original level
             logging.set_verbosity(A       )




      @mockenv(TRANSFORMERS_VERBOSITY="error"       )
      def      _A	(       self						:				Dict       ):
             # reset for the env var to take effect, next time some logger call is made
             transformers.utils.logging._reset_library_root_logger()
             # this action activates the env var
             _UpperCAmelCase     :  str							      =    logging.get_logger("transformers.models.bart.tokenization_bart"       )

             _UpperCAmelCase     :  Optional[int]							      =    os.getenv("TRANSFORMERS_VERBOSITY"						,					A       )
             _UpperCAmelCase     :  Any							      =    logging.log_levels[env_level_str]

             _UpperCAmelCase     :  Tuple							      =    logging.get_verbosity()
             self.assertEqual(
                 A						,					A						,					F"""TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}"""						,					)

             # restore to the original level
             _UpperCAmelCase     :  int							      =    ""
             transformers.utils.logging._reset_library_root_logger()




      @mockenv(TRANSFORMERS_VERBOSITY="super-error"       )
      def      _A	(       self						:				Union[str, Any]       ):
             # reset for the env var to take effect, next time some logger call is made
             transformers.utils.logging._reset_library_root_logger()
             _UpperCAmelCase     :  List[Any]							      =    logging.logging.getLogger()
             with CaptureLogger(A       ) as cl:
                    # this action activates the env var
                    logging.get_logger("transformers.models.bart.tokenization_bart"       )
             self.assertIn("Unknown option TRANSFORMERS_VERBOSITY=super-error"						,					cl.out       )

             # no need to restore as nothing was changed





      def      _A	(       self						:				List[Any]       ):
             # testing `logger.warning_advice()`
             transformers.utils.logging._reset_library_root_logger()

             _UpperCAmelCase     :  Optional[Any]							      =    logging.get_logger("transformers.models.bart.tokenization_bart"       )
             _UpperCAmelCase     :  List[Any]							      =    "Testing 1, 2, 3"

             with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS="1"       ):
                    # nothing should be logged as env var disables this method
                    with CaptureLogger(A       ) as cl:
                           logger.warning_advice(A       )
                    self.assertEqual(cl.out						,					""       )

             with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=""       ):
                    # should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
                    with CaptureLogger(A       ) as cl:
                           logger.warning_advice(A       )
                    self.assertEqual(cl.out						,					msg + "\n"       )

def 	UpperCamelCase_							(					)    ->    List[Any]:


       """simple docstring"""







       disable_progress_bar()
       assert are_progress_bars_disabled()

       enable_progress_bar()
       assert not are_progress_bars_disabled()


'''simple docstring'''




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 	UpperCamelCase_							(					_UpperCAmelCase  :      dict    )    ->    tuple:


       """simple docstring"""







       return (data["data"], data["target"])

def 	UpperCamelCase_							(					_UpperCAmelCase  :      np.ndarray			,	_UpperCAmelCase  :      np.ndarray    )    ->    XGBClassifier:


       """simple docstring"""







       _UpperCAmelCase     :  Any							      =    XGBClassifier()
       classifier.fit(_UpperCAmelCase			,	_UpperCAmelCase    )
       return classifier

def 	UpperCamelCase_							(					)    ->    None:


       """simple docstring"""







       _UpperCAmelCase     :  List[str]							      =    load_iris()
       _UpperCAmelCase      ,  _UpperCAmelCase     :  Dict							      =    data_handling(_UpperCAmelCase    )
       _UpperCAmelCase      ,  _UpperCAmelCase      ,  _UpperCAmelCase      ,  _UpperCAmelCase     :  str							      =    train_test_split(
           _UpperCAmelCase			,	_UpperCAmelCase			,	test_size=0.2_5    )

       _UpperCAmelCase     :  Optional[Any]							      =    iris["target_names"]

       # Create an XGBoost Classifier from the training data
       _UpperCAmelCase     :  Tuple							      =    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()

