





"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__A											=		{
    """configuration_data2vec_audio""": ["""DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP""", """Data2VecAudioConfig"""],
    """configuration_data2vec_text""": [
        """DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """Data2VecTextConfig""",
        """Data2VecTextOnnxConfig""",
    ],
    """configuration_data2vec_vision""": [
        """DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """Data2VecVisionConfig""",
        """Data2VecVisionOnnxConfig""",
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __A											=		[
      """DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """Data2VecAudioForAudioFrameClassification""",
      """Data2VecAudioForCTC""",
      """Data2VecAudioForSequenceClassification""",
      """Data2VecAudioForXVector""",
      """Data2VecAudioModel""",
      """Data2VecAudioPreTrainedModel""",
  ]
  __A											=		[
      """DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """Data2VecTextForCausalLM""",
      """Data2VecTextForMaskedLM""",
      """Data2VecTextForMultipleChoice""",
      """Data2VecTextForQuestionAnswering""",
      """Data2VecTextForSequenceClassification""",
      """Data2VecTextForTokenClassification""",
      """Data2VecTextModel""",
      """Data2VecTextPreTrainedModel""",
  ]
  __A											=		[
      """DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """Data2VecVisionForImageClassification""",
      """Data2VecVisionForMaskedImageModeling""",
      """Data2VecVisionForSemanticSegmentation""",
      """Data2VecVisionModel""",
      """Data2VecVisionPreTrainedModel""",
  ]

if is_tf_available():
  __A											=		[
      """TFData2VecVisionForImageClassification""",
      """TFData2VecVisionForSemanticSegmentation""",
      """TFData2VecVisionModel""",
      """TFData2VecVisionPreTrainedModel""",
  ]

if TYPE_CHECKING:
  from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
  from .configuration_dataavec_text import (
      DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
      DataaVecTextConfig,
      DataaVecTextOnnxConfig,
  )
  from .configuration_dataavec_vision import (
      DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
      DataaVecVisionConfig,
      DataaVecVisionOnnxConfig,
  )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_dataavec_audio import (
        DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
        DataaVecAudioForAudioFrameClassification,
        DataaVecAudioForCTC,
        DataaVecAudioForSequenceClassification,
        DataaVecAudioForXVector,
        DataaVecAudioModel,
        DataaVecAudioPreTrainedModel,
    )
    from .modeling_dataavec_text import (
        DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
        DataaVecTextForCausalLM,
        DataaVecTextForMaskedLM,
        DataaVecTextForMultipleChoice,
        DataaVecTextForQuestionAnswering,
        DataaVecTextForSequenceClassification,
        DataaVecTextForTokenClassification,
        DataaVecTextModel,
        DataaVecTextPreTrainedModel,
    )
    from .modeling_dataavec_vision import (
        DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
        DataaVecVisionForImageClassification,
        DataaVecVisionForMaskedImageModeling,
        DataaVecVisionForSemanticSegmentation,
        DataaVecVisionModel,
        DataaVecVisionPreTrainedModel,
    )
  if is_tf_available():
    from .modeling_tf_dataavec_vision import (
        TFDataaVecVisionForImageClassification,
        TFDataaVecVisionForSemanticSegmentation,
        TFDataaVecVisionModel,
        TFDataaVecVisionPreTrainedModel,
    )

else:
  import sys

  __A											=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)







"""simple docstring"""





import unittest

import numpy as np
import torch

from .utils_summarization import build_mask, compute_token_type_ids, process_story, truncate_or_pad






class 					_lowerCAmelCase   (     unittest.TestCase       ):
       """simple docstring"""




       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Dict											=							1_0






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[int]											=							[1, 2, 3, 4]
         lowerCAmelCase__			:Tuple											=							[1, 2, 3, 4, 0, 0, 0, 0, 0, 0]
         self.assertEqual(truncate_or_pad(__UpperCAmelCase    , self.block_size    , 0      )    , __UpperCAmelCase      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[Any]											=							[1, 2, 3, 4, 5, 6, 7, 8, 9, 1_0]
         lowerCAmelCase__			:List[Any]											=							[1, 2, 3, 4, 5, 6, 7, 8, 9, 1_0]
         self.assertEqual(truncate_or_pad(__UpperCAmelCase    , self.block_size    , 0      )    , __UpperCAmelCase      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Dict											=							[1, 2, 3, 4, 5, 6, 7, 8, 9, 1_0, 1_1, 1_2, 1_3]
         lowerCAmelCase__			:List[Any]											=							[1, 2, 3, 4, 5, 6, 7, 8, 9, 1_0]
         self.assertEqual(truncate_or_pad(__UpperCAmelCase    , self.block_size    , 0      )    , __UpperCAmelCase      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Tuple											=							'It was the year of Our Lord one thousand seven hundred and\n        seventy-five.\n\nSpiritual revelations were conceded to England at that\n        favoured period, as at this.'
         lowerCAmelCase__							,				lowerCAmelCase__			:List[Any]											=							process_story(__UpperCAmelCase      )
         self.assertEqual(__UpperCAmelCase    , []      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Any											=							''
         lowerCAmelCase__							,				lowerCAmelCase__			:Any											=							process_story(__UpperCAmelCase      )
         self.assertEqual(__UpperCAmelCase    , []      )
         self.assertEqual(__UpperCAmelCase    , []      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[str]											=							(
             'It was the year of Our Lord one thousand seven hundred and '
             'seventy-five\n\nSpiritual revelations were conceded to England '
             'at that favoured period, as at this.\n@highlight\n\nIt was the best of times'
         )
         lowerCAmelCase__							,				lowerCAmelCase__			:str											=							process_story(__UpperCAmelCase      )

         lowerCAmelCase__			:List[str]											=							[
             'It was the year of Our Lord one thousand seven hundred and seventy-five.',
             'Spiritual revelations were conceded to England at that favoured period, as at this.',
         ]
         self.assertEqual(__UpperCAmelCase    , __UpperCAmelCase      )

         lowerCAmelCase__			:List[str]											=							['It was the best of times.']
         self.assertEqual(__UpperCAmelCase    , __UpperCAmelCase      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Tuple											=							torch.tensor([1, 2, 3, 4]      )
         lowerCAmelCase__			:List[str]											=							torch.tensor([1, 1, 1, 1]      )
         np.testing.assert_array_equal(build_mask(__UpperCAmelCase    , 0      ).numpy()    , expected.numpy()      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[Any]											=							torch.tensor([1, 2, 3, 4, 2_3, 2_3, 2_3]      )
         lowerCAmelCase__			:Optional[int]											=							torch.tensor([1, 1, 1, 1, 0, 0, 0]      )
         np.testing.assert_array_equal(build_mask(__UpperCAmelCase    , 2_3      ).numpy()    , expected.numpy()      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[Any]											=							torch.tensor([8, 2, 3, 4, 1, 1, 1]      )
         lowerCAmelCase__			:Optional[Any]											=							torch.tensor([1, 1, 1, 1, 0, 0, 0]      )
         np.testing.assert_array_equal(build_mask(__UpperCAmelCase    , 1      ).numpy()    , expected.numpy()      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[Any]											=							1_0_1
         lowerCAmelCase__			:str											=							torch.tensor([[1, 2, 3, 4, 5, 6], [1, 2, 3, 1_0_1, 5, 6], [1, 1_0_1, 3, 4, 1_0_1, 6]]      )
         lowerCAmelCase__			:Any											=							torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 0, 0, 0], [1, 0, 0, 0, 1, 1]]      )

         lowerCAmelCase__			:List[Any]											=							compute_token_type_ids(__UpperCAmelCase    , __UpperCAmelCase      )
         np.testing.assert_array_equal(__UpperCAmelCase    , __UpperCAmelCase      )
