
'''simple docstring'''





import csv
import dataclasses
import json
from dataclasses import dataclass
from typing import List, Optional, Union

from ...utils import is_tf_available, is_torch_available, logging


a		:  Optional[Any]   			=			logging.get_logger(__name__)




@dataclass
class     UpperCamelCase					:
  a    :str
  a    :str
  a    :Optional[str]      					=				None
  a    :Optional[str]      					=				None



  def 						a_       ( self   ):







      '''simple docstring'''


      return json.dumps(dataclasses.asdict(self   )		,    indent=2   ) + "\n"






@dataclass(frozen=snake_case__					)
class     UpperCamelCase					:
  a    :List[int]
  a    :Optional[List[int]]      					=				None
  a    :Optional[List[int]]      					=				None
  a    :Optional[Union[int, float]]      					=				None



  def 						a_       ( self   ):







      '''simple docstring'''


      return json.dumps(dataclasses.asdict(self   )   ) + "\n"






class     UpperCamelCase					:



  def 						a_       ( self		,    __lowerCAmelCase   ):







      '''simple docstring'''


      raise NotImplementedError()



  def 						a_       ( self		,    __lowerCAmelCase   ):







      '''simple docstring'''


      raise NotImplementedError()



  def 						a_       ( self		,    __lowerCAmelCase   ):







      '''simple docstring'''


      raise NotImplementedError()



  def 						a_       ( self		,    __lowerCAmelCase   ):







      '''simple docstring'''


      raise NotImplementedError()



  def 						a_       ( self   ):







      '''simple docstring'''


      raise NotImplementedError()



  def 						a_       ( self		,    __lowerCAmelCase   ):







      '''simple docstring'''


      if len(self.get_labels()   ) > 1:
          _a							:       Union[str, Any]       					=			self.get_labels()[int(example.label   )]
      return example



  @classmethod
  def 						a_       ( cls		,    __lowerCAmelCase		,    __lowerCAmelCase=None   ):







      '''simple docstring'''


      with open(__lowerCAmelCase		,    """r"""		,    encoding="""utf-8-sig"""   ) as f:
          return list(csv.reader(__lowerCAmelCase		,    delimiter="""\t"""		,    quotechar=__lowerCAmelCase   )   )






class     UpperCamelCase					(  snake_case__					):



  def __init__( self		,    __lowerCAmelCase=None		,    __lowerCAmelCase=None		,    __lowerCAmelCase="classification"		,    __lowerCAmelCase=False   ):







      '''simple docstring'''


      _a							:       int       					=			[] if labels is None else labels
      _a							:       List[str]       					=			[] if examples is None else examples
      _a							:       Tuple       					=			mode
      _a							:       str       					=			verbose



  def __len__( self   ):







      '''simple docstring'''


      return len(self.examples   )



  def __getitem__( self		,    __lowerCAmelCase   ):







      '''simple docstring'''


      if isinstance(__lowerCAmelCase		,    __lowerCAmelCase   ):
          return SingleSentenceClassificationProcessor(labels=self.labels		,    examples=self.examples[idx]   )
      return self.examples[idx]



  @classmethod
  def 						a_       ( cls		,    __lowerCAmelCase		,    __lowerCAmelCase=""		,    __lowerCAmelCase=0		,    __lowerCAmelCase=1		,    __lowerCAmelCase=None		,    __lowerCAmelCase=False		,    **__lowerCAmelCase   ):







      '''simple docstring'''


      _a							:       int       					=			cls(**__lowerCAmelCase   )
      processor.add_examples_from_csv(
          __lowerCAmelCase		,    split_name=__lowerCAmelCase		,    column_label=__lowerCAmelCase		,    column_text=__lowerCAmelCase		,    column_id=__lowerCAmelCase		,    skip_first_row=__lowerCAmelCase		,    overwrite_labels=__lowerCAmelCase		,    overwrite_examples=__lowerCAmelCase		,    )
      return processor



  @classmethod
  def 						a_       ( cls		,    __lowerCAmelCase		,    __lowerCAmelCase=None		,    **__lowerCAmelCase   ):







      '''simple docstring'''


      _a							:       List[str]       					=			cls(**__lowerCAmelCase   )
      processor.add_examples(__lowerCAmelCase		,    labels=__lowerCAmelCase   )
      return processor



  def 						a_       ( self		,    __lowerCAmelCase		,    __lowerCAmelCase=""		,    __lowerCAmelCase=0		,    __lowerCAmelCase=1		,    __lowerCAmelCase=None		,    __lowerCAmelCase=False		,    __lowerCAmelCase=False		,    __lowerCAmelCase=False		,    ):







      '''simple docstring'''


      _a							:       Any       					=			self._read_tsv(__lowerCAmelCase   )
      if skip_first_row:
          _a							:       Optional[Any]       					=			lines[1:]
      _a							:       List[Any]       					=			[]
      _a							:       Union[str, Any]       					=			[]
      _a							:       Optional[Any]       					=			[]
      for i, line in enumerate(__lowerCAmelCase   ):
          texts.append(line[column_text]   )
          labels.append(line[column_label]   )
          if column_id is not None:
              ids.append(line[column_id]   )
          else:
              _a							:       List[Any]       					=			f'''{split_name}-{i}''' if split_name else str(__lowerCAmelCase   )
              ids.append(__lowerCAmelCase   )

      return self.add_examples(
          __lowerCAmelCase		,    __lowerCAmelCase		,    __lowerCAmelCase		,    overwrite_labels=__lowerCAmelCase		,    overwrite_examples=__lowerCAmelCase   )



  def 						a_       ( self		,    __lowerCAmelCase		,    __lowerCAmelCase=None		,    __lowerCAmelCase=None		,    __lowerCAmelCase=False		,    __lowerCAmelCase=False   ):







      '''simple docstring'''


      if labels is not None and len(__lowerCAmelCase   ) != len(__lowerCAmelCase   ):
          raise ValueError(
              f'''Text and labels have mismatched lengths {len(__lowerCAmelCase   )} and {len(__lowerCAmelCase   )}'''   )
      if ids is not None and len(__lowerCAmelCase   ) != len(__lowerCAmelCase   ):
          raise ValueError(f'''Text and ids have mismatched lengths {len(__lowerCAmelCase   )} and {len(__lowerCAmelCase   )}'''   )
      if ids is None:
          _a							:       Optional[Any]       					=			[None] * len(__lowerCAmelCase   )
      if labels is None:
          _a							:       int       					=			[None] * len(__lowerCAmelCase   )
      _a							:       int       					=			[]
      _a							:       str       					=			set()
      for text_or_text_and_label, label, guid in zip(__lowerCAmelCase		,    __lowerCAmelCase		,    __lowerCAmelCase   ):
          if isinstance(__lowerCAmelCase		,    (tuple, list)   ) and label is None:
              _a							:       Dict       					=			text_or_text_and_label
          else:
              _a							:       Dict       					=			text_or_text_and_label
          added_labels.add(__lowerCAmelCase   )
          examples.append(InputExample(guid=__lowerCAmelCase		,    text_a=__lowerCAmelCase		,    text_b=__lowerCAmelCase		,    label=__lowerCAmelCase   )   )

      # Update examples
      if overwrite_examples:
          _a							:       Tuple       					=			examples
      else:
          self.examples.extend(__lowerCAmelCase   )

      # Update labels
      if overwrite_labels:
          _a							:       Any       					=			list(__lowerCAmelCase   )
      else:
          _a							:       List[Any]       					=			list(set(self.labels   ).union(__lowerCAmelCase   )   )

      return self.examples



  def 						a_       ( self		,    __lowerCAmelCase		,    __lowerCAmelCase=None		,    __lowerCAmelCase=False		,    __lowerCAmelCase=0		,    __lowerCAmelCase=True		,    __lowerCAmelCase=None		,    ):







      '''simple docstring'''


      if max_length is None:
          _a							:       List[str]       					=			tokenizer.max_len

      _a							:       Tuple       					=			{label: i for i, label in enumerate(self.labels   )}

      _a							:       Union[str, Any]       					=			[]
      for ex_index, example in enumerate(self.examples   ):
          if ex_index % 1_0000 == 0:
              logger.info(f'''Tokenizing example {ex_index}'''   )

          _a							:       Dict       					=			tokenizer.encode(
              example.text_a		,    add_special_tokens=__lowerCAmelCase		,    max_length=min(__lowerCAmelCase		,    tokenizer.max_len   )		,    )
          all_input_ids.append(__lowerCAmelCase   )

      _a							:       Any       					=			max(len(__lowerCAmelCase   ) for input_ids in all_input_ids   )

      _a							:       Optional[int]       					=			[]
      for ex_index, (input_ids, example) in enumerate(zip(__lowerCAmelCase		,    self.examples   )   ):
          if ex_index % 1_0000 == 0:
              logger.info(f'''Writing example {ex_index}/{len(self.examples   )}'''   )
          # The mask has 1 for real tokens and 0 for padding tokens. Only real
          # tokens are attended to.
          _a							:       Dict       					=			[1 if mask_padding_with_zero else 0] * len(__lowerCAmelCase   )

          # Zero-pad up to the sequence length.
          _a							:       Optional[int]       					=			batch_length - len(__lowerCAmelCase   )
          if pad_on_left:
              _a							:       Union[str, Any]       					=			([pad_token] * padding_length) + input_ids
              _a							:       Optional[Any]       					=			([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask
          else:
              _a							:       Union[str, Any]       					=			input_ids + ([pad_token] * padding_length)
              _a							:       Dict       					=			attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)

          if len(__lowerCAmelCase   ) != batch_length:
              raise ValueError(f'''Error with input length {len(__lowerCAmelCase   )} vs {batch_length}'''   )
          if len(__lowerCAmelCase   ) != batch_length:
              raise ValueError(f'''Error with input length {len(__lowerCAmelCase   )} vs {batch_length}'''   )

          if self.mode == "classification":
              _a							:       str       					=			label_map[example.label]
          elif self.mode == "regression":
              _a							:       Union[str, Any]       					=			float(example.label   )
          else:
              raise ValueError(self.mode   )

          if ex_index < 5 and self.verbose:
              logger.info("""*** Example ***"""   )
              logger.info(f'''guid: {example.guid}'''   )
              logger.info(f'''input_ids: {' '.join([str(__lowerCAmelCase   ) for x in input_ids]   )}'''   )
              logger.info(f'''attention_mask: {' '.join([str(__lowerCAmelCase   ) for x in attention_mask]   )}'''   )
              logger.info(f'''label: {example.label} (id = {label})'''   )

          features.append(InputFeatures(input_ids=__lowerCAmelCase		,    attention_mask=__lowerCAmelCase		,    label=__lowerCAmelCase   )   )

      if return_tensors is None:
          return features
      elif return_tensors == "tf":
          if not is_tf_available():
              raise RuntimeError("""return_tensors set to 'tf' but TensorFlow 2.0 can't be imported"""   )
          import tensorflow as tf

          def gen():
              for ex in features:
                  yield ({"input_ids": ex.input_ids, "attention_mask": ex.attention_mask}, ex.label)

          _a							:       int       					=			tf.data.Dataset.from_generator(
              __lowerCAmelCase		,    ({"""input_ids""": tf.intaa, """attention_mask""": tf.intaa}, tf.intaa)		,    ({"""input_ids""": tf.TensorShape([None]   ), """attention_mask""": tf.TensorShape([None]   )}, tf.TensorShape([]   ))		,    )
          return dataset
      elif return_tensors == "pt":
          if not is_torch_available():
              raise RuntimeError("""return_tensors set to 'pt' but PyTorch can't be imported"""   )
          import torch
          from torch.utils.data import TensorDataset

          _a							:       List[Any]       					=			torch.tensor([f.input_ids for f in features]		,    dtype=torch.long   )
          _a							:       Dict       					=			torch.tensor([f.attention_mask for f in features]		,    dtype=torch.long   )
          if self.mode == "classification":
              _a							:       Optional[int]       					=			torch.tensor([f.label for f in features]		,    dtype=torch.long   )
          elif self.mode == "regression":
              _a							:       Any       					=			torch.tensor([f.label for f in features]		,    dtype=torch.float   )

          _a							:       List[Any]       					=			TensorDataset(__lowerCAmelCase		,    __lowerCAmelCase		,    __lowerCAmelCase   )
          return dataset
      else:
          raise ValueError("""return_tensors should be one of 'tf' or 'pt'"""   )








'''simple docstring'''





from __future__ import annotations

from enum import Enum




class     UpperCamelCase					(  snake_case__					):
  a    :Optional[int]      					=				2_4
  a    :Dict      					=				2_1
  a    :Dict      					=				1_8
  a    :int      					=				1_5
  a    :List[str]      					=				1_2
  a    :Tuple      					=				9
  a    :Optional[int]      					=				6
  a    :str      					=				3
  a    :Dict      					=				2
  a    :int      					=				1
  a    :List[Any]      					=				-1
  a    :Optional[Any]      					=				-2
  a    :Union[str, Any]      					=				-3
  a    :int      					=				-6
  a    :Union[str, Any]      					=				-9
  a    :Dict      					=				-1_2
  a    :Any      					=				-1_5
  a    :Tuple      					=				-1_8
  a    :Optional[Any]      					=				-2_1
  a    :Union[str, Any]      					=				-2_4






class     UpperCamelCase					(  snake_case__					):
  a    :Optional[Any]      					=				8
  a    :Optional[int]      					=				7
  a    :Optional[int]      					=				6
  a    :List[str]      					=				5
  a    :Union[str, Any]      					=				4
  a    :Union[str, Any]      					=				3
  a    :str      					=				2
  a    :Optional[int]      					=				1






def UpperCAmelCase						(					UpperCAmelCase_      ,  UpperCAmelCase_      ,  UpperCAmelCase_      ,  ):
    if isinstance(UpperCAmelCase_      ,  UpperCAmelCase_	):
        _a							:       int       					=			SIUnit[known_prefix.lower()]
    if isinstance(UpperCAmelCase_      ,  UpperCAmelCase_	):
        _a							:       Optional[Any]       					=			SIUnit[unknown_prefix.lower()]
    _a							:       float       					=			known_amount * (
        10 ** (known_prefix.value - unknown_prefix.value)
    )
    return unknown_amount





def UpperCAmelCase						(					UpperCAmelCase_      ,  UpperCAmelCase_      ,  UpperCAmelCase_      ,  ):
    if isinstance(UpperCAmelCase_      ,  UpperCAmelCase_	):
        _a							:       Optional[Any]       					=			BinaryUnit[known_prefix.lower()]
    if isinstance(UpperCAmelCase_      ,  UpperCAmelCase_	):
        _a							:       Dict       					=			BinaryUnit[unknown_prefix.lower()]
    _a							:       float       					=			known_amount * (
        2 ** ((known_prefix.value - unknown_prefix.value) * 10)
    )
    return unknown_amount


if __name__ == "__main__":
  import doctest

  doctest.testmod()


