





"""simple docstring"""




import os

from ...utils import logging
from .utils import DataProcessor, InputExample


UpperCamelCase_	 =logging.get_logger(__name__)




class 					_a		( _lowerCAmelCase							):






				def __init__(					self						:       List[str],					lowerCAmelCase__						:       List[Any],					lowerCAmelCase__						:       Tuple=None				)      -> int:




										'''simple docstring'''



										_UpperCamelCase     :   Optional[int]      =       language
										_UpperCamelCase     :   Dict      =       train_language






				def 							snake_case      (					self						:       Optional[int],					lowerCAmelCase__						:       Any				)      -> int:




										'''simple docstring'''



										_UpperCamelCase     :   List[Any]      =       self.language if self.train_language is None else self.train_language
										_UpperCamelCase     :   Optional[int]      =       self._read_tsv(os.path.join(lowerCAmelCase__,					f"""XNLI-MT-1.0/multinli/multinli.train.{lg}.tsv"""				)				)
										_UpperCamelCase     :   List[str]      =       []
										for i, line in enumerate(lowerCAmelCase__				):
																if i == 0:
																						continue
																_UpperCamelCase     :   str      =       f"""train-{i}"""
																_UpperCamelCase     :   Union[str, Any]      =       line[0]
																_UpperCamelCase     :   Dict      =       line[1]
																_UpperCamelCase     :   Dict      =       '''contradiction''' if line[2] == '''contradictory''' else line[2]
																if not isinstance(lowerCAmelCase__,					lowerCAmelCase__				):
																						raise ValueError(f"""Training input {text_a} is not a string"""				)
																if not isinstance(lowerCAmelCase__,					lowerCAmelCase__				):
																						raise ValueError(f"""Training input {text_b} is not a string"""				)
																if not isinstance(lowerCAmelCase__,					lowerCAmelCase__				):
																						raise ValueError(f"""Training label {label} is not a string"""				)
																examples.append(InputExample(guid=lowerCAmelCase__,					text_a=lowerCAmelCase__,					text_b=lowerCAmelCase__,					label=lowerCAmelCase__				)				)
										return examples






				def 							snake_case      (					self						:       Any,					lowerCAmelCase__						:       int				)      -> str:




										'''simple docstring'''



										_UpperCamelCase     :   Union[str, Any]      =       self._read_tsv(os.path.join(lowerCAmelCase__,					'''XNLI-1.0/xnli.test.tsv'''				)				)
										_UpperCamelCase     :   List[Any]      =       []
										for i, line in enumerate(lowerCAmelCase__				):
																if i == 0:
																						continue
																_UpperCamelCase     :   Optional[Any]      =       line[0]
																if language != self.language:
																						continue
																_UpperCamelCase     :   Optional[int]      =       f"""test-{i}"""
																_UpperCamelCase     :   Optional[int]      =       line[6]
																_UpperCamelCase     :   Union[str, Any]      =       line[7]
																_UpperCamelCase     :   Dict      =       line[1]
																if not isinstance(lowerCAmelCase__,					lowerCAmelCase__				):
																						raise ValueError(f"""Training input {text_a} is not a string"""				)
																if not isinstance(lowerCAmelCase__,					lowerCAmelCase__				):
																						raise ValueError(f"""Training input {text_b} is not a string"""				)
																if not isinstance(lowerCAmelCase__,					lowerCAmelCase__				):
																						raise ValueError(f"""Training label {label} is not a string"""				)
																examples.append(InputExample(guid=lowerCAmelCase__,					text_a=lowerCAmelCase__,					text_b=lowerCAmelCase__,					label=lowerCAmelCase__				)				)
										return examples






				def 							snake_case      (					self						:       int				)      -> Union[str, Any]:




										'''simple docstring'''



										return ["contradiction", "entailment", "neutral"]

UpperCamelCase_	 ={
    """xnli""": XnliProcessor,
}

UpperCamelCase_	 ={
    """xnli""": """classification""",
}

UpperCamelCase_	 ={
    """xnli""": 3,
}







from .hash_table import HashTable
from .number_theory.prime_numbers import is_prime, next_prime





class     __a     (       __UpperCamelCase ):
 def __init__(  self							,					*lowerCAmelCase__							,					**lowerCAmelCase__					)   ->							Any:




        '''simple docstring'''
        super().__init__(*lowerCAmelCase__							,					**lowerCAmelCase__					)
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							Union[str, Any]:




        '''simple docstring'''
        lowercase__:  str         =  (
            next_prime(value % self.size_table					)
            if not is_prime(value % self.size_table					)
            else value % self.size_table
        )  # gt = bigger than
        return next_prime_gt - (data % next_prime_gt)
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							Union[str, Any]:




        '''simple docstring'''
        return (increment * self.__hash_function_a(lowerCAmelCase__							,					lowerCAmelCase__					)) % self.size_table
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__=None					)   ->							str:




        '''simple docstring'''
        lowercase__:  Dict         =  1
        lowercase__:  str         =  self.hash_function(lowerCAmelCase__					)

        while self.values[new_key] is not None and self.values[new_key] != key:
               lowercase__:  List[Any]         =  (
                   self.__hash_double_function(lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)
                   if self.balanced_factor() >= self.lim_charge
                   else None
               )
               if new_key is None:
                      break
               else:
                      i += 1

        return new_key


