"""simple docstring"""






import copy
from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


if TYPE_CHECKING:
       from ... import PreTrainedTokenizerBase, TensorType

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





class 				_A		( lowerCAmelCase			):
      snake_case__    :     Dict													=			'vision-encoder-decoder'
      snake_case__    :     Dict													=			True

      def __init__(		self	, **__lowerCAmelCase		):







            """simple docstring"""



            super().__init__(**__lowerCAmelCase		)
            if "encoder" not in kwargs or "decoder" not in kwargs:
                  raise ValueError(
                      f'A configuraton of type {self.model_type} cannot be instantiated because '
                      f'not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}'		)

            lowercase														=			kwargs.pop("""encoder"""		)
            lowercase														=			encoder_config.pop("""model_type"""		)
            lowercase														=			kwargs.pop("""decoder"""		)
            lowercase														=			decoder_config.pop("""model_type"""		)

            lowercase														=			AutoConfig.for_model(__lowerCAmelCase	, **__lowerCAmelCase		)
            lowercase														=			AutoConfig.for_model(__lowerCAmelCase	, **__lowerCAmelCase		)
            lowercase														=			True

      @classmethod
      def        A__ (		cls	, __lowerCAmelCase	, __lowerCAmelCase	, **__lowerCAmelCase		):







            """simple docstring"""



            logger.info("""Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config"""		)
            lowercase														=			True
            lowercase														=			True

            return cls(encoder=encoder_config.to_dict()	, decoder=decoder_config.to_dict()	, **__lowerCAmelCase		)







      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			copy.deepcopy(self.__dict__		)
            lowercase														=			self.encoder.to_dict()
            lowercase														=			self.decoder.to_dict()
            lowercase														=			self.__class__.model_type
            return output






class 				_A		( lowerCAmelCase			):
      snake_case__    :     Dict													=			version.parse('1.11'			)

      @property
      def        A__ (		self		):







            """simple docstring"""



            return OrderedDict(
                [
                    ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
                ]		)

      @property
      def        A__ (		self		):







            """simple docstring"""



            return 1E-4







      @property
      def        A__ (		self		):







            """simple docstring"""



            return OrderedDict({"""last_hidden_state""": {0: """batch""", 1: """encoder_sequence"""}}		)






class 				_A		( lowerCAmelCase			):

      @property
      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			OrderedDict()
            lowercase														=			{0: """batch""", 1: """past_decoder_sequence + sequence"""}
            lowercase														=			{0: """batch""", 1: """past_decoder_sequence + sequence"""}
            lowercase														=			{0: """batch""", 1: """encoder_sequence"""}

            return common_inputs







      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase = -1	, __lowerCAmelCase = -1	, __lowerCAmelCase = False	, __lowerCAmelCase = None	, ):







            """simple docstring"""



            import torch

            lowercase														=			OrderedDict()

            lowercase														=			super().generate_dummy_inputs(
                __lowerCAmelCase	, batch_size=__lowerCAmelCase	, seq_length=__lowerCAmelCase	, is_pair=__lowerCAmelCase	, framework=__lowerCAmelCase		)

            lowercase							,							lowercase														=			dummy_input["""input_ids"""].shape
            lowercase														=			(batch, encoder_sequence, self._config.encoder_hidden_size)
            lowercase														=			dummy_input.pop("""input_ids"""		)
            lowercase														=			dummy_input.pop("""attention_mask"""		)
            lowercase														=			torch.zeros(__lowerCAmelCase		)

            return common_inputs






class 				_A		( lowerCAmelCase			):

      @property
      def        A__ (		self		):







            """simple docstring"""



            pass

      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



            return VisionEncoderDecoderEncoderOnnxConfig(__lowerCAmelCase		)







      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase = "default"		):







            """simple docstring"""



            lowercase														=			encoder_config.hidden_size
            return VisionEncoderDecoderDecoderOnnxConfig(__lowerCAmelCase	, __lowerCAmelCase		)




"""simple docstring"""






import os
from pathlib import Path
from unittest.mock import patch

import pytest
import zstandard as zstd

from datasets.download.download_config import DownloadConfig
from datasets.utils.file_utils import (
    OfflineModeIsEnabled,
    cached_path,
    fsspec_get,
    fsspec_head,
    ftp_get,
    ftp_head,
    get_from_cache,
    http_get,
    http_head,
)


__lowerCAmelCase					: List[Any]        ="""\
    Text data.
    Second line of data."""

__lowerCAmelCase					: Any        ="""file"""


@pytest.fixture(scope="""session"""	)
def     UpperCAmelCase__ (       lowerCAmelCase__  :str	)				->					Union[str, Any]:
      '''simple docstring'''


      lowercase														=			tmp_path_factory.mktemp("""data"""	) / (FILE_PATH + """.zstd""")
      lowercase														=			bytes(lowerCAmelCase__      ,	"""utf-8"""	)
      with zstd.open(lowerCAmelCase__      ,	"""wb"""	) as f:
            f.write(lowerCAmelCase__	)
      return path


@pytest.fixture
def     UpperCAmelCase__ (       lowerCAmelCase__  :Tuple	)				->					Dict:
      '''simple docstring'''


      with open(os.path.join(tmpfs.local_root_dir      ,	lowerCAmelCase__	)      ,	"""w"""	) as f:
            f.write(lowerCAmelCase__	)
      return FILE_PATH


@pytest.mark.parametrize("""compression_format"""      ,	["""gzip""", """xz""", """zstd"""]	)
def     UpperCAmelCase__ (       lowerCAmelCase__  :Any      ,	lowerCAmelCase__  :Any      ,	lowerCAmelCase__  :List[Any]      ,	lowerCAmelCase__  :Optional[Any]      ,	lowerCAmelCase__  :Any      ,	lowerCAmelCase__  :int	)				->					Union[str, Any]:
      '''simple docstring'''


      lowercase														=			{"""gzip""": gz_file, """xz""": xz_file, """zstd""": zstd_path}
      lowercase														=			input_paths[compression_format]
      lowercase														=			tmp_path / """cache"""
      lowercase														=			DownloadConfig(cache_dir=lowerCAmelCase__      ,	extract_compressed_file=lowerCAmelCase__	)
      lowercase														=			cached_path(lowerCAmelCase__      ,	download_config=lowerCAmelCase__	)
      with open(lowerCAmelCase__	) as f:
            lowercase														=			f.read()
      with open(lowerCAmelCase__	) as f:
            lowercase														=			f.read()
      assert extracted_file_content == expected_file_content


@pytest.mark.parametrize("""default_extracted"""      ,	[True, False]	)
@pytest.mark.parametrize("""default_cache_dir"""      ,	[True, False]	)
def     UpperCAmelCase__ (       lowerCAmelCase__  :Dict      ,	lowerCAmelCase__  :Tuple      ,	lowerCAmelCase__  :Tuple      ,	lowerCAmelCase__  :Union[str, Any]      ,	lowerCAmelCase__  :List[str]	)				->					Any:
      '''simple docstring'''


      lowercase														=			"""custom_cache"""
      lowercase														=			"""custom_extracted_dir"""
      lowercase														=			tmp_path / """custom_extracted_path"""
      if default_extracted:
            lowercase														=			("""downloads""" if default_cache_dir else custom_cache_dir, """extracted""")
      else:
            monkeypatch.setattr("""datasets.config.EXTRACTED_DATASETS_DIR"""      ,	lowerCAmelCase__	)
            monkeypatch.setattr("""datasets.config.EXTRACTED_DATASETS_PATH"""      ,	str(lowerCAmelCase__	)	)
            lowercase														=			custom_extracted_path.parts[-2:] if default_cache_dir else (custom_cache_dir, custom_extracted_dir)

      lowercase														=			xz_file
      lowercase														=			(
          DownloadConfig(extract_compressed_file=lowerCAmelCase__	)
          if default_cache_dir
          else DownloadConfig(cache_dir=tmp_path / custom_cache_dir      ,	extract_compressed_file=lowerCAmelCase__	)
      )
      lowercase														=			cached_path(lowerCAmelCase__      ,	download_config=lowerCAmelCase__	)
      assert Path(lowerCAmelCase__	).parent.parts[-2:] == expected


def     UpperCAmelCase__ (       lowerCAmelCase__  :List[str]	)				->					Tuple:
      '''simple docstring'''


      lowercase														=			str(Path(lowerCAmelCase__	).resolve()	)
      assert cached_path(lowerCAmelCase__	) == text_file
      # relative path
      lowercase														=			str(Path(lowerCAmelCase__	).resolve().relative_to(Path(os.getcwd()	)	)	)
      assert cached_path(lowerCAmelCase__	) == text_file


def     UpperCAmelCase__ (       lowerCAmelCase__  :Any	)				->					List[Any]:
      '''simple docstring'''


      lowercase														=			str(tmp_path.resolve() / """__missing_file__.txt"""	)
      with pytest.raises(lowerCAmelCase__	):
            cached_path(lowerCAmelCase__	)
      # relative path
      lowercase														=			"""./__missing_file__.txt"""
      with pytest.raises(lowerCAmelCase__	):
            cached_path(lowerCAmelCase__	)


def     UpperCAmelCase__ (       lowerCAmelCase__  :Any	)				->					Union[str, Any]:
      '''simple docstring'''


      lowercase														=			get_from_cache(f'tmp://{tmpfs_file}'	)
      with open(lowerCAmelCase__	) as f:
            lowercase														=			f.read()
      assert output_file_content == FILE_CONTENT


@patch("""datasets.config.HF_DATASETS_OFFLINE"""      ,	lowerCAmelCase__	)
def     UpperCAmelCase__ (       )				->					str:
      '''simple docstring'''


      with pytest.raises(lowerCAmelCase__	):
            cached_path("""https://huggingface.co"""	)


@patch("""datasets.config.HF_DATASETS_OFFLINE"""      ,	lowerCAmelCase__	)
def     UpperCAmelCase__ (       lowerCAmelCase__  :Tuple	)				->					Any:
      '''simple docstring'''


      lowercase														=			tmp_path_factory.mktemp("""data"""	) / """file.html"""
      with pytest.raises(lowerCAmelCase__	):
            http_get("""https://huggingface.co"""      ,	temp_file=lowerCAmelCase__	)
      with pytest.raises(lowerCAmelCase__	):
            http_head("""https://huggingface.co"""	)


@patch("""datasets.config.HF_DATASETS_OFFLINE"""      ,	lowerCAmelCase__	)
def     UpperCAmelCase__ (       lowerCAmelCase__  :str	)				->					Any:
      '''simple docstring'''


      lowercase														=			tmp_path_factory.mktemp("""data"""	) / """file.html"""
      with pytest.raises(lowerCAmelCase__	):
            ftp_get("""ftp://huggingface.co"""      ,	temp_file=lowerCAmelCase__	)
      with pytest.raises(lowerCAmelCase__	):
            ftp_head("""ftp://huggingface.co"""	)






@patch("""datasets.config.HF_DATASETS_OFFLINE"""      ,	lowerCAmelCase__	)
def     UpperCAmelCase__ (       lowerCAmelCase__  :Any	)				->					Dict:
      '''simple docstring'''


      lowercase														=			tmp_path_factory.mktemp("""data"""	) / """file.html"""
      with pytest.raises(lowerCAmelCase__	):
            fsspec_get("""s3://huggingface.co"""      ,	temp_file=lowerCAmelCase__	)
      with pytest.raises(lowerCAmelCase__	):
            fsspec_head("""s3://huggingface.co"""	)



