


import copy
import os
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pyarrow as pa
import pyarrow.parquet as pq
import pytest

from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence
from datasets.features import ArrayaD, ClassLabel, Features, Image, Value
from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects
from datasets.keyhash import DuplicatedKeysError, InvalidKeyError

from .utils import require_pil



class 							_UpperCamelCase (						A						):

   '''simple docstring'''







   def   _snake_case    (  self  : Optional[Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						pa.array(TypedSequence([1, 2, 3]							)							)
         self.assertEqual(arr.type       ,  pa.intaa()							)

   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         with self.assertRaises(_lowerCamelCase							):
               __lowerCamelCase     :      str       						=						pa.array(TypedSequence([1, 2, 3]							)       ,  type=pa.intaa()							)

   def   _snake_case    (  self  : int							):






         '''simple docstring'''



         with self.assertRaises(_lowerCamelCase							):
               __lowerCamelCase     :      List[Any]       						=						pa.array(TypedSequence([1, 2, 3]       ,  try_type=Value("""bool"""							)       ,  type=Value("""int64"""							)							)							)

   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      List[Any]       						=						pa.array(TypedSequence([1, 2, 3]       ,  type=Value("""int32"""							)							)							)
         self.assertEqual(arr.type       ,  pa.intaa()							)

   def   _snake_case    (  self  : List[Any]							):






         '''simple docstring'''



         with self.assertRaises((TypeError, pa.lib.ArrowInvalid)							):
               __lowerCamelCase     :      Tuple       						=						pa.array(TypedSequence(["""foo""", """bar"""]       ,  type=Value("""int64"""							)							)							)

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






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						pa.array(TypedSequence([1, 2, 3]       ,  try_type=Value("""int32"""							)							)							)
         self.assertEqual(arr.type       ,  pa.intaa()							)

   def   _snake_case    (  self  : Optional[Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      List[Any]       						=						pa.array(TypedSequence(["""foo""", """bar"""]       ,  try_type=Value("""int64"""							)							)							)
         self.assertEqual(arr.type       ,  pa.string()							)

   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						pa.array(TypedSequence([[[1, 2, 3]]]       ,  type=ArrayaD((1, 3)       ,  """int64"""							)							)							)
         self.assertEqual(arr.type       ,  ArrayaDExtensionType((1, 3)       ,  """int64"""							)							)

   def   _snake_case    (  self  : str							):






         '''simple docstring'''



         with self.assertRaises((TypeError, pa.lib.ArrowInvalid)							):
               __lowerCamelCase     :      List[str]       						=						pa.array(TypedSequence(["""foo""", """bar"""]       ,  type=ArrayaD((1, 3)       ,  """int64"""							)							)							)

   def   _snake_case    (  self  : str							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[int]       						=						pa.array(TypedSequence([[[1, 2, 3]]]       ,  try_type=ArrayaD((1, 3)       ,  """int64"""							)							)							)
         self.assertEqual(arr.type       ,  ArrayaDExtensionType((1, 3)       ,  """int64"""							)							)

   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         __lowerCamelCase     :      Any       						=						pa.array(TypedSequence(["""foo""", """bar"""]       ,  try_type=ArrayaD((1, 3)       ,  """int64"""							)							)							)
         self.assertEqual(arr.type       ,  pa.string()							)


   @require_pil
   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         import PIL.Image

         __lowerCamelCase     :      Tuple       						=						PIL.Image.fromarray(np.arange(1_0       ,  dtype=np.uinta							).reshape(2       ,  5							)							)
         with patch(
             """datasets.arrow_writer.cast_to_python_objects"""       ,  side_effect=_lowerCamelCase							) as mock_cast_to_python_objects:
               __lowerCamelCase     :      int       						=						pa.array(TypedSequence([{"""path""": None, """bytes""": B"""image_bytes"""}, pil_image]       ,  type=Image()							)							)
               __lowerCamelCase     :      int       						=						mock_cast_to_python_objects.call_args_list[-1]
               self.assertIn("""optimize_list_casting"""       ,  _lowerCamelCase							)
               self.assertFalse(kwargs["""optimize_list_casting"""]							)





def   _UpperCAmelCase       (     UpperCAmelCase      :			Union[str, Any]						,	UpperCAmelCase      :			int      ):
      """simple docstring"""




      __lowerCamelCase     :      Dict       						=						pa.BufferReader(UpperCAmelCase      ) if isinstance(UpperCAmelCase						,	pa.Buffer      ) else pa.memory_map(UpperCAmelCase      )
      __lowerCamelCase     :      Optional[int]       						=						pa.ipc.open_stream(UpperCAmelCase      )
      __lowerCamelCase     :      pa.Table       						=						f.read_all()
      assert len(pa_table.to_batches()      ) == expected_num_chunks
      assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}
      del pa_table





@pytest.mark.parametrize("""writer_batch_size"""						,	[None, 1, 10]      )
@pytest.mark.parametrize(
    """fields"""						,	[None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			Any						,	UpperCAmelCase      :			Dict      ):
      """simple docstring"""




      __lowerCamelCase     :      Dict       						=						pa.BufferOutputStream()
      __lowerCamelCase     :      List[str]       						=						pa.schema(UpperCAmelCase      ) if fields else None
      with ArrowWriter(stream=UpperCAmelCase						,	schema=UpperCAmelCase						,	writer_batch_size=UpperCAmelCase      ) as writer:
            writer.write({"""col_1""": """foo""", """col_2""": 1}      )
            writer.write({"""col_1""": """bar""", """col_2""": 2}      )
            __lowerCamelCase     :      List[Any]       						=						writer.finalize()
      assert num_examples == 2
      assert num_bytes > 0
      if not fields:
            __lowerCamelCase     :      str       						=						{"""col_1""": pa.string(), """col_2""": pa.intaa()}
      assert writer._schema == pa.schema(UpperCAmelCase						,	metadata=writer._schema.metadata      )
      _check_output(output.getvalue()						,	expected_num_chunks=num_examples if writer_batch_size == 1 else 1      )





def   _UpperCAmelCase       (     ):
      """simple docstring"""




      __lowerCamelCase     :      Union[str, Any]       						=						pa.BufferOutputStream()
      __lowerCamelCase     :      str       						=						Features({"""labels""": ClassLabel(names=["""neg""", """pos"""]      )}      )
      with ArrowWriter(stream=UpperCAmelCase						,	features=UpperCAmelCase      ) as writer:
            writer.write({"""labels""": 0}      )
            writer.write({"""labels""": 1}      )
            __lowerCamelCase     :      Dict       						=						writer.finalize()
      assert num_examples == 2
      assert num_bytes > 0
      assert writer._schema == features.arrow_schema
      assert writer._schema.metadata == features.arrow_schema.metadata
      __lowerCamelCase     :      int       						=						pa.BufferReader(output.getvalue()      )
      __lowerCamelCase     :      Tuple       						=						pa.ipc.open_stream(UpperCAmelCase      )
      __lowerCamelCase     :      pa.Table       						=						f.read_all()
      __lowerCamelCase     :      Union[str, Any]       						=						pa_table.schema
      assert pa_table.num_rows == 2
      assert schema == features.arrow_schema
      assert schema.metadata == features.arrow_schema.metadata
      assert features == Features.from_arrow_schema(UpperCAmelCase      )





@pytest.mark.parametrize("""writer_batch_size"""						,	[None, 1, 10]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			Dict      ):
      """simple docstring"""




      __lowerCamelCase     :      Any       						=						pa.BufferOutputStream()
      with ArrowWriter(
          stream=UpperCAmelCase						,	writer_batch_size=UpperCAmelCase						,	hash_salt="""split_name"""						,	check_duplicates=UpperCAmelCase						,	) as writer:
            with pytest.raises(UpperCAmelCase      ):
                  writer.write({"""col_1""": """foo""", """col_2""": 1}						,	key=[1, 2]      )
                  __lowerCamelCase     :      Any       						=						writer.finalize()





@pytest.mark.parametrize("""writer_batch_size"""						,	[None, 2, 10]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			List[str]      ):
      """simple docstring"""




      __lowerCamelCase     :      List[Any]       						=						pa.BufferOutputStream()
      with ArrowWriter(
          stream=UpperCAmelCase						,	writer_batch_size=UpperCAmelCase						,	hash_salt="""split_name"""						,	check_duplicates=UpperCAmelCase						,	) as writer:
            with pytest.raises(UpperCAmelCase      ):
                  writer.write({"""col_1""": """foo""", """col_2""": 1}						,	key=10      )
                  writer.write({"""col_1""": """bar""", """col_2""": 2}						,	key=10      )
                  __lowerCamelCase     :      Any       						=						writer.finalize()





@pytest.mark.parametrize("""writer_batch_size"""						,	[None, 2, 10]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			List[Any]      ):
      """simple docstring"""




      __lowerCamelCase     :      Optional[int]       						=						pa.BufferOutputStream()
      with ArrowWriter(
          stream=UpperCAmelCase						,	writer_batch_size=UpperCAmelCase						,	hash_salt="""split_name"""						,	check_duplicates=UpperCAmelCase						,	) as writer:
            writer.write({"""col_1""": """foo""", """col_2""": 1}						,	key=1      )
            writer.write({"""col_1""": """bar""", """col_2""": 2}						,	key=2      )
            __lowerCamelCase     :      List[Any]       						=						writer.finalize()
      assert num_examples == 2
      assert num_bytes > 0
      _check_output(output.getvalue()						,	expected_num_chunks=num_examples if writer_batch_size == 1 else 1      )





@pytest.mark.parametrize("""writer_batch_size"""						,	[None, 1, 10]      )
@pytest.mark.parametrize(
    """fields"""						,	[None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			Optional[Any]						,	UpperCAmelCase      :			List[str]      ):
      """simple docstring"""




      __lowerCamelCase     :      int       						=						pa.BufferOutputStream()
      __lowerCamelCase     :      Any       						=						pa.schema(UpperCAmelCase      ) if fields else None
      with ArrowWriter(stream=UpperCAmelCase						,	schema=UpperCAmelCase						,	writer_batch_size=UpperCAmelCase      ) as writer:
            writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]}      )
            writer.write_batch({"""col_1""": [], """col_2""": []}      )
            __lowerCamelCase     :      Optional[int]       						=						writer.finalize()
      assert num_examples == 2
      assert num_bytes > 0
      if not fields:
            __lowerCamelCase     :      Dict       						=						{"""col_1""": pa.string(), """col_2""": pa.intaa()}
      assert writer._schema == pa.schema(UpperCAmelCase						,	metadata=writer._schema.metadata      )
      _check_output(output.getvalue()						,	expected_num_chunks=num_examples if writer_batch_size == 1 else 1      )





@pytest.mark.parametrize("""writer_batch_size"""						,	[None, 1, 10]      )
@pytest.mark.parametrize(
    """fields"""						,	[None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			Optional[int]						,	UpperCAmelCase      :			Optional[int]      ):
      """simple docstring"""




      __lowerCamelCase     :      str       						=						pa.BufferOutputStream()
      __lowerCamelCase     :      Optional[int]       						=						pa.schema(UpperCAmelCase      ) if fields else None
      with ArrowWriter(stream=UpperCAmelCase						,	schema=UpperCAmelCase						,	writer_batch_size=UpperCAmelCase      ) as writer:
            writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]}      )      )
            __lowerCamelCase     :      str       						=						writer.finalize()
      assert num_examples == 2
      assert num_bytes > 0
      if not fields:
            __lowerCamelCase     :      str       						=						{"""col_1""": pa.string(), """col_2""": pa.intaa()}
      assert writer._schema == pa.schema(UpperCAmelCase						,	metadata=writer._schema.metadata      )
      _check_output(output.getvalue()						,	expected_num_chunks=num_examples if writer_batch_size == 1 else 1      )





@pytest.mark.parametrize("""writer_batch_size"""						,	[None, 1, 10]      )
@pytest.mark.parametrize(
    """fields"""						,	[None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			List[Any]						,	UpperCAmelCase      :			List[str]      ):
      """simple docstring"""




      __lowerCamelCase     :      Any       						=						pa.BufferOutputStream()
      __lowerCamelCase     :      List[Any]       						=						pa.schema(UpperCAmelCase      ) if fields else None
      with ArrowWriter(stream=UpperCAmelCase						,	schema=UpperCAmelCase						,	writer_batch_size=UpperCAmelCase      ) as writer:
            writer.write_row(pa.Table.from_pydict({"""col_1""": ["""foo"""], """col_2""": [1]}      )      )
            writer.write_row(pa.Table.from_pydict({"""col_1""": ["""bar"""], """col_2""": [2]}      )      )
            __lowerCamelCase     :      Tuple       						=						writer.finalize()
      assert num_examples == 2
      assert num_bytes > 0
      if not fields:
            __lowerCamelCase     :      List[Any]       						=						{"""col_1""": pa.string(), """col_2""": pa.intaa()}
      assert writer._schema == pa.schema(UpperCAmelCase						,	metadata=writer._schema.metadata      )
      _check_output(output.getvalue()						,	expected_num_chunks=num_examples if writer_batch_size == 1 else 1      )





def   _UpperCAmelCase       (     ):
      """simple docstring"""




      with tempfile.TemporaryDirectory() as tmp_dir:
            __lowerCamelCase     :      Optional[Any]       						=						{"""col_1""": pa.string(), """col_2""": pa.intaa()}
            __lowerCamelCase     :      Union[str, Any]       						=						os.path.join(UpperCAmelCase						,	"""test.arrow"""      )
            with ArrowWriter(path=UpperCAmelCase						,	schema=pa.schema(UpperCAmelCase      )      ) as writer:
                  writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]}      )
                  __lowerCamelCase     :      Union[str, Any]       						=						writer.finalize()
            assert num_examples == 2
            assert num_bytes > 0
            assert writer._schema == pa.schema(UpperCAmelCase						,	metadata=writer._schema.metadata      )
            _check_output(UpperCAmelCase						,	1      )





def   _UpperCAmelCase       (     UpperCAmelCase      :			Dict      ):
      """simple docstring"""




      if pa.types.is_list(UpperCAmelCase      ):
            return get_base_dtype(arr_type.value_type      )
      else:
            return arr_type





def   _UpperCAmelCase       (     UpperCAmelCase      :			List[str]						,	UpperCAmelCase      :			int      ):
      """simple docstring"""




      if isinstance(lst[0]						,	UpperCAmelCase      ):
            change_first_primitive_element_in_list(lst[0]						,	UpperCAmelCase      )
      else:
            __lowerCamelCase     :      Tuple       						=						value





@pytest.mark.parametrize("""optimized_int_type, expected_dtype"""						,	[(None, pa.intaa()), (Value("""int32"""      ), pa.intaa())]      )
@pytest.mark.parametrize("""sequence"""						,	[[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			Tuple						,	UpperCAmelCase      :			str						,	UpperCAmelCase      :			Any      ):
      """simple docstring"""




      __lowerCamelCase     :      Tuple       						=						pa.array(TypedSequence(UpperCAmelCase						,	optimized_int_type=UpperCAmelCase      )      )
      assert get_base_dtype(arr.type      ) == expected_dtype





@pytest.mark.parametrize(
    """col, expected_dtype"""						,	[
        ("""attention_mask""", pa.inta()),
        ("""special_tokens_mask""", pa.inta()),
        ("""token_type_ids""", pa.inta()),
        ("""input_ids""", pa.intaa()),
        ("""other""", pa.intaa()),
    ]						,	)
@pytest.mark.parametrize("""sequence"""						,	[[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			Optional[Any]						,	UpperCAmelCase      :			Union[str, Any]						,	UpperCAmelCase      :			Optional[int]      ):
      """simple docstring"""




      __lowerCamelCase     :      int       						=						pa.array(OptimizedTypedSequence(UpperCAmelCase						,	col=UpperCAmelCase      )      )
      assert get_base_dtype(arr.type      ) == expected_dtype

      # not in range
      if col != "other":
            # avoids errors due to in-place modifications
            __lowerCamelCase     :      List[str]       						=						copy.deepcopy(UpperCAmelCase      )
            __lowerCamelCase     :      Optional[int]       						=						np.iinfo(expected_dtype.to_pandas_dtype()      ).max + 1
            change_first_primitive_element_in_list(UpperCAmelCase						,	UpperCAmelCase      )
            __lowerCamelCase     :      Optional[Any]       						=						pa.array(OptimizedTypedSequence(UpperCAmelCase						,	col=UpperCAmelCase      )      )
            assert get_base_dtype(arr.type      ) == pa.intaa()





@pytest.mark.parametrize("""raise_exception"""						,	[False, True]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			Optional[Any]						,	UpperCAmelCase      :			Dict      ):
      """simple docstring"""




      __lowerCamelCase     :      Dict       						=						str(tmp_path / """dataset-train.arrow"""      )
      try:
            with ArrowWriter(path=UpperCAmelCase      ) as writer:
                  if raise_exception:
                        raise pa.lib.ArrowInvalid()
                  else:
                        writer.stream.close()
      except pa.lib.ArrowInvalid:
            pass
      finally:
            assert writer.stream.closed





def   _UpperCAmelCase       (     UpperCAmelCase      :			Optional[int]      ):
      """simple docstring"""




      __lowerCamelCase     :      List[Any]       						=						"""mock://dataset-train.arrow"""
      with ArrowWriter(path=UpperCAmelCase						,	storage_options=mockfs.storage_options      ) as writer:
            assert isinstance(writer._fs						,	type(UpperCAmelCase      )      )
            assert writer._fs.storage_options == mockfs.storage_options
            writer.write({"""col_1""": """foo""", """col_2""": 1}      )
            writer.write({"""col_1""": """bar""", """col_2""": 2}      )
            __lowerCamelCase     :      Optional[Any]       						=						writer.finalize()
      assert num_examples == 2
      assert num_bytes > 0
      assert mockfs.exists(UpperCAmelCase      )





def   _UpperCAmelCase       (     ):
      """simple docstring"""




      __lowerCamelCase     :      str       						=						pa.BufferOutputStream()
      with ParquetWriter(stream=UpperCAmelCase      ) as writer:
            writer.write({"""col_1""": """foo""", """col_2""": 1}      )
            writer.write({"""col_1""": """bar""", """col_2""": 2}      )
            __lowerCamelCase     :      Union[str, Any]       						=						writer.finalize()
      assert num_examples == 2
      assert num_bytes > 0
      __lowerCamelCase     :      List[str]       						=						pa.BufferReader(output.getvalue()      )
      __lowerCamelCase     :      pa.Table       						=						pq.read_table(UpperCAmelCase      )
      assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}





@require_pil
@pytest.mark.parametrize("""embed_local_files"""						,	[False, True]      )
def   _UpperCAmelCase       (     UpperCAmelCase      :			Any						,	UpperCAmelCase      :			List[Any]      ):
      """simple docstring"""




      import PIL.Image

      __lowerCamelCase     :      Dict       						=						str(tmp_path / """test_image_rgb.jpg"""      )
      PIL.Image.fromarray(np.zeros((5, 5)						,	dtype=np.uinta      )      ).save(UpperCAmelCase						,	format="""png"""      )
      __lowerCamelCase     :      Tuple       						=						pa.BufferOutputStream()
      with ParquetWriter(
          stream=UpperCAmelCase						,	features=Features({"""image""": Image()}      )						,	embed_local_files=UpperCAmelCase      ) as writer:
            writer.write({"""image""": image_path}      )
            writer.finalize()
      __lowerCamelCase     :      Optional[int]       						=						pa.BufferReader(output.getvalue()      )
      __lowerCamelCase     :      pa.Table       						=						pq.read_table(UpperCAmelCase      )
      __lowerCamelCase     :      Optional[int]       						=						pa_table.to_pydict()
      if embed_local_files:
            assert isinstance(out["""image"""][0]["""path"""]						,	UpperCAmelCase      )
            with open(UpperCAmelCase						,	"""rb"""      ) as f:
                  assert out["image"][0]["bytes"] == f.read()
      else:
            assert out["image"][0]["path"] == image_path
            assert out["image"][0]["bytes"] is None





def   _UpperCAmelCase       (     ):
      """simple docstring"""




      __lowerCamelCase     :      int       						=						pa.schema([pa.field("""col_1"""						,	pa.string()						,	nullable=UpperCAmelCase      )]      )
      __lowerCamelCase     :      Dict       						=						pa.BufferOutputStream()
      with ArrowWriter(stream=UpperCAmelCase      ) as writer:
            writer._build_writer(inferred_schema=UpperCAmelCase      )
            assert writer._schema == pa.schema([pa.field("""col_1"""						,	pa.string()      )]      )







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


__UpperCamelCase    :						Union[str, Any]     =							{
    'configuration_layoutlmv2': ['LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LayoutLMv2Config'],
    'processing_layoutlmv2': ['LayoutLMv2Processor'],
    'tokenization_layoutlmv2': ['LayoutLMv2Tokenizer'],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCamelCase    :						List[str]     =							['LayoutLMv2TokenizerFast']

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCamelCase    :						List[str]     =							['LayoutLMv2FeatureExtractor']
    __UpperCamelCase    :						Union[str, Any]     =							['LayoutLMv2ImageProcessor']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCamelCase    :						Dict     =							[
        'LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST',
        'LayoutLMv2ForQuestionAnswering',
        'LayoutLMv2ForSequenceClassification',
        'LayoutLMv2ForTokenClassification',
        'LayoutLMv2Layer',
        'LayoutLMv2Model',
        'LayoutLMv2PreTrainedModel',
    ]

if TYPE_CHECKING:
    from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
    from .processing_layoutlmva import LayoutLMvaProcessor
    from .tokenization_layoutlmva import LayoutLMvaTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_layoutlmva import (
            LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
            LayoutLMvaForQuestionAnswering,
            LayoutLMvaForSequenceClassification,
            LayoutLMvaForTokenClassification,
            LayoutLMvaLayer,
            LayoutLMvaModel,
            LayoutLMvaPreTrainedModel,
        )
else:
    import sys

    __UpperCamelCase    :						Optional[Any]     =							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



