


import importlib
import json
import os
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
import transformers.models.auto
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.bert.configuration_bert import BertConfig
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


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

from test_module.custom_configuration import CustomConfig  # noqa E402


_A		:				Optional[Any]									=       get_tests_dir('''fixtures/dummy-config.json''')



class        a					(			unittest.TestCase   ):





     def  SCREAMING_SNAKE_CASE__       (    self					:				Any							):
        __lowerCamelCase:				List[str]     =	0





     def  SCREAMING_SNAKE_CASE__       (    self					:				Tuple							):
        self.assertIsNotNone(transformers.models.auto.__spec__							)
        self.assertIsNotNone(importlib.util.find_spec("""transformers.models.auto"""							)							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Optional[int]							):
        __lowerCamelCase:				Tuple     =	AutoConfig.from_pretrained("""bert-base-uncased"""							)
        self.assertIsInstance(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				List[str]							):
        __lowerCamelCase:				Optional[Any]     =	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_							)
        self.assertIsInstance(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Union[str, Any]							):
        __lowerCamelCase:				Optional[Any]     =	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_							)
        self.assertIsInstance(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				List[Any]							):
        __lowerCamelCase:				List[str]     =	AutoConfig.for_model("""roberta"""							)
        self.assertIsInstance(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Any							):
        with tempfile.TemporaryDirectory() as tmp_dir:
           # This model name contains bert and roberta, but roberta ends up being picked.
           __lowerCamelCase:				Optional[Any]     =	os.path.join(SCREAMING_SNAKE_CASE_    ,	"""fake-roberta"""							)
           os.makedirs(SCREAMING_SNAKE_CASE_    ,	exist_ok=SCREAMING_SNAKE_CASE_							)
           with open(os.path.join(SCREAMING_SNAKE_CASE_    ,	"""config.json"""							)    ,	"""w"""							) as f:
              f.write(json.dumps({}							)							)
           __lowerCamelCase:				List[str]     =	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_							)
           self.assertEqual(type(SCREAMING_SNAKE_CASE_							)    ,	SCREAMING_SNAKE_CASE_							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Union[str, Any]							):
        try:
           AutoConfig.register("""custom"""    ,	SCREAMING_SNAKE_CASE_							)
           # Wrong model type will raise an error
           with self.assertRaises(SCREAMING_SNAKE_CASE_							):
              AutoConfig.register("""model"""    ,	SCREAMING_SNAKE_CASE_							)
           # Trying to register something existing in the Transformers library will raise an error
           with self.assertRaises(SCREAMING_SNAKE_CASE_							):
              AutoConfig.register("""bert"""    ,	SCREAMING_SNAKE_CASE_							)

           # Now that the config is registered, it can be used as any other config with the auto-API
           __lowerCamelCase:				List[Any]     =	CustomConfig()
           with tempfile.TemporaryDirectory() as tmp_dir:
              config.save_pretrained(SCREAMING_SNAKE_CASE_							)
              __lowerCamelCase:				Dict     =	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_							)
              self.assertIsInstance(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							)

        finally:
           if "custom" in CONFIG_MAPPING._extra_content:
              del CONFIG_MAPPING._extra_content["custom"]





     def  SCREAMING_SNAKE_CASE__       (    self					:				Optional[Any]							):
        with self.assertRaisesRegex(
            SCREAMING_SNAKE_CASE_    ,	"""bert-base is not a local folder and is not a valid model identifier"""							):
           __lowerCamelCase:				Optional[int]     =	AutoConfig.from_pretrained("""bert-base"""							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Dict							):
        with self.assertRaisesRegex(
            SCREAMING_SNAKE_CASE_    ,	R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""							):
           __lowerCamelCase:				Any     =	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    ,	revision="""aaaaaa"""							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				List[str]							):
        with self.assertRaisesRegex(
            SCREAMING_SNAKE_CASE_    ,	"""hf-internal-testing/no-config-test-repo does not appear to have a file named config.json."""    ,	):
           __lowerCamelCase:				List[Any]     =	AutoConfig.from_pretrained("""hf-internal-testing/no-config-test-repo"""							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				str							):
        # If remote code is not set, we will time out when asking whether to load the model.
        with self.assertRaises(SCREAMING_SNAKE_CASE_							):
           __lowerCamelCase:				Optional[int]     =	AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model"""							)
        # If remote code is disabled, we can't load this config.
        with self.assertRaises(SCREAMING_SNAKE_CASE_							):
           __lowerCamelCase:				Tuple     =	AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model"""    ,	trust_remote_code=SCREAMING_SNAKE_CASE_							)

        __lowerCamelCase:				Tuple     =	AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model"""    ,	trust_remote_code=SCREAMING_SNAKE_CASE_							)
        self.assertEqual(config.__class__.__name__    ,	"""NewModelConfig"""							)

        # Test config can be reloaded.
        with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(SCREAMING_SNAKE_CASE_							)
           __lowerCamelCase:				Optional[int]     =	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_    ,	trust_remote_code=SCREAMING_SNAKE_CASE_							)
        self.assertEqual(reloaded_config.__class__.__name__    ,	"""NewModelConfig"""							)







     def  SCREAMING_SNAKE_CASE__       (    self					:				Dict							):



        class        a					(			_UpperCAmelCase   ):
             UpperCAmelCase__ :  Optional[int]						      =	"new-model"

        try:
           AutoConfig.register("""new-model"""    ,	SCREAMING_SNAKE_CASE_							)
           # If remote code is not set, the default is to use local
           __lowerCamelCase:				Any     =	AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model"""							)
           self.assertEqual(config.__class__.__name__    ,	"""NewModelConfigLocal"""							)

           # If remote code is disabled, we load the local one.
           __lowerCamelCase:				Any     =	AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model"""    ,	trust_remote_code=SCREAMING_SNAKE_CASE_							)
           self.assertEqual(config.__class__.__name__    ,	"""NewModelConfigLocal"""							)

           # If remote is enabled, we load from the Hub
           __lowerCamelCase:				List[str]     =	AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model"""    ,	trust_remote_code=SCREAMING_SNAKE_CASE_							)
           self.assertEqual(config.__class__.__name__    ,	"""NewModelConfig"""							)

        finally:
           if "new-model" in CONFIG_MAPPING._extra_content:
              del CONFIG_MAPPING._extra_content["new-model"]






from sklearn.metrics import fa_score

import datasets


_A		:				Any									=       '''
The F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:
F1 = 2 * (precision * recall) / (precision + recall)
'''


_A		:				Dict									=       '''
Args:
    predictions (`list` of `int`): Predicted labels.
    references (`list` of `int`): Ground truth labels.
    labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.
    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.
    average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.

        - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.
        - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.
        - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.
        - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.
        - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).
    sample_weight (`list` of `float`): Sample weights Defaults to None.

Returns:
    f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.

Examples:

    Example 1-A simple binary example
        >>> f1_metric = datasets.load_metric("f1")
        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])
        >>> print(results)
        {\'f1\': 0.5}

    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.
        >>> f1_metric = datasets.load_metric("f1")
        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)
        >>> print(round(results[\'f1\'], 2))
        0.67

    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.
        >>> f1_metric = datasets.load_metric("f1")
        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])
        >>> print(round(results[\'f1\'], 2))
        0.35

    Example 4-A multiclass example, with different values for the `average` input.
        >>> predictions = [0, 2, 1, 0, 0, 1]
        >>> references = [0, 1, 2, 0, 1, 2]
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="macro")
        >>> print(round(results[\'f1\'], 2))
        0.27
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")
        >>> print(round(results[\'f1\'], 2))
        0.33
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")
        >>> print(round(results[\'f1\'], 2))
        0.27
        >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)
        >>> print(results)
        {\'f1\': array([0.8, 0. , 0. ])}
'''


_A		:				Union[str, Any]									=       '''
@article{scikit-learn,
    title={Scikit-learn: Machine Learning in {P}ython},
    author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
           and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
           and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
           Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
    journal={Journal of Machine Learning Research},
    volume={12},
    pages={2825--2830},
    year={2011}
}
'''



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION     ,_KWARGS_DESCRIPTION   )
class        a					(			datasets.Metric   ):





     def  SCREAMING_SNAKE_CASE__       (    self					:				Union[str, Any]							):
        return datasets.MetricInfo(
            description=_DESCRIPTION    ,	citation=_CITATION    ,	inputs_description=_KWARGS_DESCRIPTION    ,	features=datasets.Features(
                {
                    """predictions""": datasets.Sequence(datasets.Value("""int32"""							)							),
                    """references""": datasets.Sequence(datasets.Value("""int32"""							)							),
                }
                if self.config_name == """multilabel"""
                else {
                    """predictions""": datasets.Value("""int32"""							),
                    """references""": datasets.Value("""int32"""							),
                }							)    ,	reference_urls=["""https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html"""]    ,	)







     def  SCREAMING_SNAKE_CASE__       (    self					:				int    ,	SCREAMING_SNAKE_CASE_					:				Optional[Any]    ,	SCREAMING_SNAKE_CASE_					:				str    ,	SCREAMING_SNAKE_CASE_					:				str=None    ,	SCREAMING_SNAKE_CASE_					:				str=1    ,	SCREAMING_SNAKE_CASE_					:				List[str]="binary"    ,	SCREAMING_SNAKE_CASE_					:				List[str]=None							):
        __lowerCamelCase:				str     =	fa_score(
            SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_    ,	labels=SCREAMING_SNAKE_CASE_    ,	pos_label=SCREAMING_SNAKE_CASE_    ,	average=SCREAMING_SNAKE_CASE_    ,	sample_weight=SCREAMING_SNAKE_CASE_							)
        return {"f1": float(SCREAMING_SNAKE_CASE_							) if score.size == 1 else score}


