





import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs



class        _lowerCAmelCase    (			UpperCAmelCase_							):


  '''simple docstring'''







  def __init__(      self      :					Tuple      ,				UpperCamelCase      :					List[Any]      ,				UpperCamelCase      :					int=None      ,				UpperCamelCase      :					List[Any]=True      ,				UpperCamelCase      :					List[Any]=None      ,				**UpperCamelCase      :					List[Any]							):


    '''simple docstring'''





    _snake_case   :				Tuple														=	parent
    _snake_case   :				Union[str, Any]														=	config_class
    _snake_case   :				Optional[int]														=	has_text_modality
    _snake_case   :				Optional[int]														=	kwargs
    _snake_case   :				str														=	common_properties







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    _snake_case   :				Any														=	self.config_class(**self.inputs_dict							)
    _snake_case   :				Any														=	(
        ['hidden_size', 'num_attention_heads', 'num_hidden_layers']
        if self.common_properties is None
        else self.common_properties
    )

    # Add common fields for text models
    if self.has_text_modality:
      common_properties.extend(['vocab_size']							)

    # Test that config has the common properties as getters
    for prop in common_properties:
      self.parent.assertTrue(hasattr(UpperCamelCase      ,				UpperCamelCase							)      ,				msg=f"""`{prop}` does not exist"""							)

    # Test that config has the common properties as setter
    for idx, name in enumerate(UpperCamelCase							):
      try:
        setattr(UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase							)
        self.parent.assertEqual(
            getattr(UpperCamelCase      ,				UpperCamelCase							)      ,				UpperCamelCase      ,				msg=f"""`{name} value {idx} expected, but was {getattr(UpperCamelCase      ,				UpperCamelCase							)}"""							)
      except NotImplementedError:
        # Some models might not be able to implement setters for common_properties
        # In that case, a NotImplementedError is raised
        pass

        # Test if config class can be called with Config(prop_name=..)
    for idx, name in enumerate(UpperCamelCase							):
      try:
        _snake_case   :				List[str]														=	self.config_class(**{name: idx}							)
        self.parent.assertEqual(
            getattr(UpperCamelCase      ,				UpperCamelCase							)      ,				UpperCamelCase      ,				msg=f"""`{name} value {idx} expected, but was {getattr(UpperCamelCase      ,				UpperCamelCase							)}"""							)
      except NotImplementedError:
        # Some models might not be able to implement setters for common_properties
        # In that case, a NotImplementedError is raised
        pass







  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    _snake_case   :				int														=	self.config_class(**self.inputs_dict							)
    _snake_case   :				List[Any]														=	json.loads(config.to_json_string()							)
    for key, value in self.inputs_dict.items():
      self.parent.assertEqual(obj[key]      ,				UpperCamelCase							)







  def UpperCamelCase_ (      self      :					Union[str, Any]							):


    '''simple docstring'''





    _snake_case   :				int														=	self.config_class(**self.inputs_dict							)

    with tempfile.TemporaryDirectory() as tmpdirname:
      _snake_case   :				str														=	os.path.join(UpperCamelCase      ,				'config.json'							)
      config_first.to_json_file(UpperCamelCase							)
      _snake_case   :				str														=	self.config_class.from_json_file(UpperCamelCase							)

    self.parent.assertEqual(config_second.to_dict()      ,				config_first.to_dict()							)







  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    _snake_case   :				str														=	self.config_class(**self.inputs_dict							)

    with tempfile.TemporaryDirectory() as tmpdirname:
      config_first.save_pretrained(UpperCamelCase							)
      _snake_case   :				Dict														=	self.config_class.from_pretrained(UpperCamelCase							)

    self.parent.assertEqual(config_second.to_dict()      ,				config_first.to_dict()							)







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





    _snake_case   :				Optional[Any]														=	self.config_class(**self.inputs_dict							)

    _snake_case   :				Optional[int]														=	'test'
    with tempfile.TemporaryDirectory() as tmpdirname:
      _snake_case   :				Optional[Any]														=	os.path.join(UpperCamelCase      ,				UpperCamelCase							)
      config_first.save_pretrained(UpperCamelCase							)
      _snake_case   :				Optional[Any]														=	self.config_class.from_pretrained(UpperCamelCase      ,				subfolder=UpperCamelCase							)

    self.parent.assertEqual(config_second.to_dict()      ,				config_first.to_dict()							)







  def UpperCamelCase_ (      self      :					Tuple							):


    '''simple docstring'''





    _snake_case   :				Optional[int]														=	self.config_class(**self.inputs_dict      ,				num_labels=5							)
    self.parent.assertEqual(len(config.idalabel							)      ,				5							)
    self.parent.assertEqual(len(config.labelaid							)      ,				5							)

    _snake_case   :				List[str]														=	3
    self.parent.assertEqual(len(config.idalabel							)      ,				3							)
    self.parent.assertEqual(len(config.labelaid							)      ,				3							)







  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    if self.config_class.is_composition:
      return
    _snake_case   :				Tuple														=	self.config_class()
    self.parent.assertIsNotNone(UpperCamelCase							)







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





    _snake_case   :				Any														=	copy.deepcopy(UpperCamelCase							)
    _snake_case   :				int														=	self.config_class(**UpperCamelCase							)
    _snake_case   :				Optional[Any]														=	[]
    for key, value in config_common_kwargs.items():
      if key == "torch_dtype":
        if not is_torch_available():
          continue
        else:
          import torch

          if config.torch_dtype != torch.floataa:
            wrong_values.append(('torch_dtype', config.torch_dtype, torch.floataa)							)
      elif getattr(UpperCamelCase      ,				UpperCamelCase							) != value:
        wrong_values.append((key, getattr(UpperCamelCase      ,				UpperCamelCase							), value)							)

    if len(UpperCamelCase							) > 0:
      _snake_case   :				Union[str, Any]														=	'\n'.join([f"""- {v[0]}: got {v[1]} instead of {v[2]}""" for v in wrong_values]							)
      raise ValueError(f"""The following keys were not properly set in the config:\n{errors}"""							)







  def UpperCamelCase_ (      self      :					str							):


    '''simple docstring'''





    self.create_and_test_config_common_properties()
    self.create_and_test_config_to_json_string()
    self.create_and_test_config_to_json_file()
    self.create_and_test_config_from_and_save_pretrained()
    self.create_and_test_config_from_and_save_pretrained_subfolder()
    self.create_and_test_config_with_num_labels()
    self.check_config_can_be_init_without_params()
    self.check_config_arguments_init()











from unittest import TestCase

from datasets import Dataset
from minhash_deduplication import deduplicate_dataset, make_duplicate_clusters


def     lowerCamelCase_	(      )->		Any:
  _snake_case   :				List[str]														=	{
      'repo_name': ['test_repo1', 'test_repo2', 'test_repo3'],
      'path': ['test_1.py', 'test_2.py', 'unit_test.py'],
      'content': ['a ' * 20, 'a ' * 30, 'b ' * 7],
  }
  _snake_case   :				Optional[Any]														=	Dataset.from_dict(lowerCAmelCase				)
  return dataset







class        _lowerCAmelCase    (			UpperCAmelCase_							):


  '''simple docstring'''







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    _snake_case   :				Union[str, Any]														=	get_dataset()
    _snake_case   :				Tuple														=	make_duplicate_clusters(UpperCamelCase      ,				0.85							)
    self.assertEqual(len(duplicate_clusters[0]							)      ,				2							)







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    _snake_case   :				List[str]														=	get_dataset()
    _snake_case							,					_snake_case   :				str														=	deduplicate_dataset(UpperCamelCase							)
    self.assertEqual(len(UpperCamelCase							)      ,				2							)
    print(UpperCamelCase							)
    self.assertEqual(duplicate_clusters[0][0]['copies']      ,				2							)
    self.assertEqual(duplicate_clusters[0][0]['is_extreme']      ,				UpperCamelCase							)




