



"""simple docstring"""
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / "utils"))

from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


UpperCAmelCase						:		Any			= get_tests_dir("fixtures")


class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):

				def 					_UpperCAmelCase	(				self			:				Tuple):







						"""simple docstring"""







						lowercase_								= mock.Mock()
						lowercase_								= 5_0_0
						lowercase_								= {}
						lowercase_								= HTTPError
						lowercase_								= {}

						# Download this model to make sure it's in the cache.
						lowercase_								= WavaVecaFeatureExtractor.from_pretrained("""hf-internal-testing/tiny-random-wav2vec2""")
						# Under the mock environment we get a 500 error when trying to reach the model.
						with mock.patch("""requests.Session.request""" ,  return_value=lowerCAmelCase_) as mock_head:
								lowercase_								= WavaVecaFeatureExtractor.from_pretrained("""hf-internal-testing/tiny-random-wav2vec2""")
								# This check we did call the fake head request
								mock_head.assert_called()




				def 					_UpperCAmelCase	(				self			:				str):







						"""simple docstring"""







						lowercase_								= WavaVecaFeatureExtractor.from_pretrained(
						    """https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json""")







@is_staging_test
class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):

				@classmethod
				def 					_UpperCAmelCase	(				cls			:				str):







						"""simple docstring"""







						lowercase_								= TOKEN
						HfFolder.save_token(lowerCAmelCase_)

				@classmethod
				def 					_UpperCAmelCase	(				cls			:				Any):







						"""simple docstring"""







						try:
								delete_repo(token=cls._token ,  repo_id="""test-feature-extractor""")
						except HTTPError:
								pass

						try:
								delete_repo(token=cls._token ,  repo_id="""valid_org/test-feature-extractor-org""")
						except HTTPError:
								pass

						try:
								delete_repo(token=cls._token ,  repo_id="""test-dynamic-feature-extractor""")
						except HTTPError:
								pass

				def 					_UpperCAmelCase	(				self			:				Dict):







						"""simple docstring"""







						lowercase_								= WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase_)
						feature_extractor.push_to_hub("""test-feature-extractor""" ,  use_auth_token=self._token)

						lowercase_								= WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor''')
						for k, v in feature_extractor.__dict__.items():
								self.assertEqual(lowerCAmelCase_ ,  getattr(lowerCAmelCase_ ,  lowerCAmelCase_))

						# Reset repo
						delete_repo(token=self._token ,  repo_id="""test-feature-extractor""")

						# Push to hub via save_pretrained
						with tempfile.TemporaryDirectory() as tmp_dir:
								feature_extractor.save_pretrained(
								    lowerCAmelCase_ ,  repo_id="""test-feature-extractor""" ,  push_to_hub=lowerCAmelCase_ ,  use_auth_token=self._token)

						lowercase_								= WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor''')
						for k, v in feature_extractor.__dict__.items():
								self.assertEqual(lowerCAmelCase_ ,  getattr(lowerCAmelCase_ ,  lowerCAmelCase_))

				def 					_UpperCAmelCase	(				self			:				Optional[int]):







						"""simple docstring"""







						lowercase_								= WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase_)
						feature_extractor.push_to_hub("""valid_org/test-feature-extractor""" ,  use_auth_token=self._token)

						lowercase_								= WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor""")
						for k, v in feature_extractor.__dict__.items():
								self.assertEqual(lowerCAmelCase_ ,  getattr(lowerCAmelCase_ ,  lowerCAmelCase_))

						# Reset repo
						delete_repo(token=self._token ,  repo_id="""valid_org/test-feature-extractor""")

						# Push to hub via save_pretrained
						with tempfile.TemporaryDirectory() as tmp_dir:
								feature_extractor.save_pretrained(
								    lowerCAmelCase_ ,  repo_id="""valid_org/test-feature-extractor-org""" ,  push_to_hub=lowerCAmelCase_ ,  use_auth_token=self._token)

						lowercase_								= WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor-org""")
						for k, v in feature_extractor.__dict__.items():
								self.assertEqual(lowerCAmelCase_ ,  getattr(lowerCAmelCase_ ,  lowerCAmelCase_))




				def 					_UpperCAmelCase	(				self			:				List[Any]):







						"""simple docstring"""







						CustomFeatureExtractor.register_for_auto_class()
						lowercase_								= CustomFeatureExtractor.from_pretrained(lowerCAmelCase_)

						feature_extractor.push_to_hub("""test-dynamic-feature-extractor""" ,  use_auth_token=self._token)

						# This has added the proper auto_map field to the config
						self.assertDictEqual(
						    feature_extractor.auto_map ,  {"""AutoFeatureExtractor""": """custom_feature_extraction.CustomFeatureExtractor"""} ,  )

						lowercase_								= AutoFeatureExtractor.from_pretrained(
						    F'''{USER}/test-dynamic-feature-extractor''' ,  trust_remote_code=lowerCAmelCase_)
						# Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module
						self.assertEqual(new_feature_extractor.__class__.__name__ ,  """CustomFeatureExtractor""")






"""simple docstring"""
import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase							) ->						tuple:







  '''simple docstring'''


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


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							) ->						np.ndarray:







  '''simple docstring'''


  lowercase_								= XGBRegressor(verbosity=0 ,  random_state=42							)
  xgb.fit(__lowerCAmelCase ,  __lowerCAmelCase							)
  # Predict target for test data
  lowercase_								= xgb.predict(__lowerCAmelCase							)
  lowercase_								= predictions.reshape(len(__lowerCAmelCase							) ,  1							)
  return predictions


def 			_SCREAMING_SNAKE_CASE						() ->						None:







  '''simple docstring'''


  lowercase_								= fetch_california_housing()
  lowercase_					,    lowercase_								= data_handling(__lowerCAmelCase							)
  lowercase_					,    lowercase_					,    lowercase_					,    lowercase_								= train_test_split(
      __lowerCAmelCase ,  __lowerCAmelCase ,  test_size=0.25 ,  random_state=1							)
  lowercase_								= xgboost(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							)
  # Error printing
  print(F'''Mean Absolute Error : {mean_absolute_error(__lowerCAmelCase ,  __lowerCAmelCase							)}'''							)
  print(F'''Mean Square Error  : {mean_squared_error(__lowerCAmelCase ,  __lowerCAmelCase							)}'''							)


if __name__ == "__main__":
       import doctest

       doctest.testmod(verbose=True)
       main()

