





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     SCREAMING_SNAKE_CASE       (UpperCAmelCase				):


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Union[str, Any]	)->       List[str]:





     """simple docstring"""







     lowercase__           =  pa.array(TypedSequence([1, 2, 3]	)	)
     self.assertEqual(arr.type      ,					pa.intaa()	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[Any]	)->       Any:





     """simple docstring"""







     with self.assertRaises(a	):
       lowercase__           =  pa.array(TypedSequence([1, 2, 3]	)      ,					type=pa.intaa()	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[str]	)->       Union[str, Any]:





     """simple docstring"""







     with self.assertRaises(a	):
       lowercase__           =  pa.array(TypedSequence([1, 2, 3]      ,					try_type=Value('bool'	)      ,					type=Value('int64'	)	)	)


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





     """simple docstring"""







     lowercase__           =  pa.array(TypedSequence([1, 2, 3]      ,					type=Value('int32'	)	)	)
     self.assertEqual(arr.type      ,					pa.intaa()	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    int	)->       List[Any]:





     """simple docstring"""







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


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Dict	)->       int:





     """simple docstring"""







     lowercase__           =  pa.array(TypedSequence([1, 2, 3]      ,					try_type=Value('int32'	)	)	)
     self.assertEqual(arr.type      ,					pa.intaa()	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[int]	)->       List[str]:





     """simple docstring"""







     lowercase__           =  pa.array(TypedSequence(['foo', 'bar']      ,					try_type=Value('int64'	)	)	)
     self.assertEqual(arr.type      ,					pa.string()	)


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





     """simple docstring"""







     lowercase__           =  pa.array(TypedSequence([[[1, 2, 3]]]      ,					type=ArrayaD((1, 3)      ,					'int64'	)	)	)
     self.assertEqual(arr.type      ,					ArrayaDExtensionType((1, 3)      ,					'int64'	)	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[str]	)->       List[Any]:





     """simple docstring"""







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


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Dict	)->       Union[str, Any]:





     """simple docstring"""







     lowercase__           =  pa.array(TypedSequence([[[1, 2, 3]]]      ,					try_type=ArrayaD((1, 3)      ,					'int64'	)	)	)
     self.assertEqual(arr.type      ,					ArrayaDExtensionType((1, 3)      ,					'int64'	)	)


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





     """simple docstring"""







     lowercase__           =  pa.array(TypedSequence(['foo', 'bar']      ,					try_type=ArrayaD((1, 3)      ,					'int64'	)	)	)
     self.assertEqual(arr.type      ,					pa.string()	)


   @require_pil
   def 	SCREAMING_SNAKE_CASE_							(   self      :    Tuple	)->       List[Any]:





     """simple docstring"""







     import PIL.Image

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






def 					__UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Tuple:
  lowercase__           =  pa.BufferReader(_SCREAMING_SNAKE_CASE		) if isinstance(_SCREAMING_SNAKE_CASE		,						pa.Buffer		) else pa.memory_map(_SCREAMING_SNAKE_CASE		)
  lowercase__           =  pa.ipc.open_stream(_SCREAMING_SNAKE_CASE		)
  lowercase__           =  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  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Optional[int]:
  lowercase__           =  pa.BufferOutputStream()
  lowercase__           =  pa.schema(_SCREAMING_SNAKE_CASE		) if fields else None
  with ArrowWriter(stream=_SCREAMING_SNAKE_CASE		,						schema=_SCREAMING_SNAKE_CASE		,						writer_batch_size=_SCREAMING_SNAKE_CASE		) as writer:
    writer.write({'col_1': 'foo', 'col_2': 1}		)
    writer.write({'col_1': 'bar', 'col_2': 2}		)
    lowercase__      ,   lowercase__           =  writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  if not fields:
    lowercase__           =  {'col_1': pa.string(), 'col_2': pa.intaa()}
  assert writer._schema == pa.schema(_SCREAMING_SNAKE_CASE		,						metadata=writer._schema.metadata		)
  _check_output(output.getvalue()		,						expected_num_chunks=num_examples if writer_batch_size == 1 else 1		)




def 					__UpperCamelCase  ()    ->       Any:
  lowercase__           =  pa.BufferOutputStream()
  lowercase__           =  Features({'labels': ClassLabel(names=['neg', 'pos']		)}		)
  with ArrowWriter(stream=_SCREAMING_SNAKE_CASE		,						features=_SCREAMING_SNAKE_CASE		) as writer:
    writer.write({'labels': 0}		)
    writer.write({'labels': 1}		)
    lowercase__      ,   lowercase__           =  writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  assert writer._schema == features.arrow_schema
  assert writer._schema.metadata == features.arrow_schema.metadata
  lowercase__           =  pa.BufferReader(output.getvalue()		)
  lowercase__           =  pa.ipc.open_stream(_SCREAMING_SNAKE_CASE		)
  lowercase__           =  f.read_all()
  lowercase__           =  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(_SCREAMING_SNAKE_CASE		)




@pytest.mark.parametrize('writer_batch_size'		,						[None, 1, 10]		)
def 					__UpperCamelCase  (_SCREAMING_SNAKE_CASE		)    ->       Optional[int]:
  lowercase__           =  pa.BufferOutputStream()
  with ArrowWriter(
      stream=_SCREAMING_SNAKE_CASE		,						writer_batch_size=_SCREAMING_SNAKE_CASE		,						hash_salt='split_name'		,						check_duplicates=_SCREAMING_SNAKE_CASE		,						) as writer:
    with pytest.raises(_SCREAMING_SNAKE_CASE		):
      writer.write({'col_1': 'foo', 'col_2': 1}		,						key=[1, 2]		)
      lowercase__      ,   lowercase__           =  writer.finalize()




@pytest.mark.parametrize('writer_batch_size'		,						[None, 2, 10]		)
def 					__UpperCamelCase  (_SCREAMING_SNAKE_CASE		)    ->       Tuple:
  lowercase__           =  pa.BufferOutputStream()
  with ArrowWriter(
      stream=_SCREAMING_SNAKE_CASE		,						writer_batch_size=_SCREAMING_SNAKE_CASE		,						hash_salt='split_name'		,						check_duplicates=_SCREAMING_SNAKE_CASE		,						) as writer:
    with pytest.raises(_SCREAMING_SNAKE_CASE		):
      writer.write({'col_1': 'foo', 'col_2': 1}		,						key=10		)
      writer.write({'col_1': 'bar', 'col_2': 2}		,						key=10		)
      lowercase__      ,   lowercase__           =  writer.finalize()




@pytest.mark.parametrize('writer_batch_size'		,						[None, 2, 10]		)
def 					__UpperCamelCase  (_SCREAMING_SNAKE_CASE		)    ->       Tuple:
  lowercase__           =  pa.BufferOutputStream()
  with ArrowWriter(
      stream=_SCREAMING_SNAKE_CASE		,						writer_batch_size=_SCREAMING_SNAKE_CASE		,						hash_salt='split_name'		,						check_duplicates=_SCREAMING_SNAKE_CASE		,						) as writer:
    writer.write({'col_1': 'foo', 'col_2': 1}		,						key=1		)
    writer.write({'col_1': 'bar', 'col_2': 2}		,						key=2		)
    lowercase__      ,   lowercase__           =  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  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Dict:
  lowercase__           =  pa.BufferOutputStream()
  lowercase__           =  pa.schema(_SCREAMING_SNAKE_CASE		) if fields else None
  with ArrowWriter(stream=_SCREAMING_SNAKE_CASE		,						schema=_SCREAMING_SNAKE_CASE		,						writer_batch_size=_SCREAMING_SNAKE_CASE		) as writer:
    writer.write_batch({'col_1': ['foo', 'bar'], 'col_2': [1, 2]}		)
    writer.write_batch({'col_1': [], 'col_2': []}		)
    lowercase__      ,   lowercase__           =  writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  if not fields:
    lowercase__           =  {'col_1': pa.string(), 'col_2': pa.intaa()}
  assert writer._schema == pa.schema(_SCREAMING_SNAKE_CASE		,						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  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Optional[int]:
  lowercase__           =  pa.BufferOutputStream()
  lowercase__           =  pa.schema(_SCREAMING_SNAKE_CASE		) if fields else None
  with ArrowWriter(stream=_SCREAMING_SNAKE_CASE		,						schema=_SCREAMING_SNAKE_CASE		,						writer_batch_size=_SCREAMING_SNAKE_CASE		) as writer:
    writer.write_table(pa.Table.from_pydict({'col_1': ['foo', 'bar'], 'col_2': [1, 2]}		)		)
    lowercase__      ,   lowercase__           =  writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  if not fields:
    lowercase__           =  {'col_1': pa.string(), 'col_2': pa.intaa()}
  assert writer._schema == pa.schema(_SCREAMING_SNAKE_CASE		,						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  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Optional[int]:
  lowercase__           =  pa.BufferOutputStream()
  lowercase__           =  pa.schema(_SCREAMING_SNAKE_CASE		) if fields else None
  with ArrowWriter(stream=_SCREAMING_SNAKE_CASE		,						schema=_SCREAMING_SNAKE_CASE		,						writer_batch_size=_SCREAMING_SNAKE_CASE		) 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]}		)		)
    lowercase__      ,   lowercase__           =  writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  if not fields:
    lowercase__           =  {'col_1': pa.string(), 'col_2': pa.intaa()}
  assert writer._schema == pa.schema(_SCREAMING_SNAKE_CASE		,						metadata=writer._schema.metadata		)
  _check_output(output.getvalue()		,						expected_num_chunks=num_examples if writer_batch_size == 1 else 1		)




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




def 					__UpperCamelCase  (_SCREAMING_SNAKE_CASE		)    ->       Any:
  if pa.types.is_list(_SCREAMING_SNAKE_CASE		):
    return get_base_dtype(arr_type.value_type		)
  else:
    return arr_type




def 					__UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Tuple:
  if isinstance(lst[0]		,						_SCREAMING_SNAKE_CASE		):
    change_first_primitive_element_in_list(lst[0]		,						_SCREAMING_SNAKE_CASE		)
  else:
    lowercase__           =  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  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Optional[int]:
  lowercase__           =  pa.array(TypedSequence(_SCREAMING_SNAKE_CASE		,						optimized_int_type=_SCREAMING_SNAKE_CASE		)		)
  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  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Union[str, Any]:
  # in range
  lowercase__           =  pa.array(OptimizedTypedSequence(_SCREAMING_SNAKE_CASE		,						col=_SCREAMING_SNAKE_CASE		)		)
  assert get_base_dtype(arr.type		) == expected_dtype

  # not in range
  if col != "other":
    # avoids errors due to in-place modifications
    lowercase__           =  copy.deepcopy(_SCREAMING_SNAKE_CASE		)
    lowercase__           =  np.iinfo(expected_dtype.to_pandas_dtype()		).max + 1
    change_first_primitive_element_in_list(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)
    lowercase__           =  pa.array(OptimizedTypedSequence(_SCREAMING_SNAKE_CASE		,						col=_SCREAMING_SNAKE_CASE		)		)
    assert get_base_dtype(arr.type		) == pa.intaa()




@pytest.mark.parametrize('raise_exception'		,						[False, True]		)
def 					__UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Tuple:
  lowercase__           =  str(tmp_path / 'dataset-train.arrow'		)
  try:
    with ArrowWriter(path=_SCREAMING_SNAKE_CASE		) 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  (_SCREAMING_SNAKE_CASE		)    ->       Optional[int]:
  lowercase__           =  'mock://dataset-train.arrow'
  with ArrowWriter(path=_SCREAMING_SNAKE_CASE		,						storage_options=mockfs.storage_options		) as writer:
    assert isinstance(writer._fs		,						type(_SCREAMING_SNAKE_CASE		)		)
    assert writer._fs.storage_options == mockfs.storage_options
    writer.write({'col_1': 'foo', 'col_2': 1}		)
    writer.write({'col_1': 'bar', 'col_2': 2}		)
    lowercase__      ,   lowercase__           =  writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  assert mockfs.exists(_SCREAMING_SNAKE_CASE		)




def 					__UpperCamelCase  ()    ->       Dict:
  lowercase__           =  pa.BufferOutputStream()
  with ParquetWriter(stream=_SCREAMING_SNAKE_CASE		) as writer:
    writer.write({'col_1': 'foo', 'col_2': 1}		)
    writer.write({'col_1': 'bar', 'col_2': 2}		)
    lowercase__      ,   lowercase__           =  writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  lowercase__           =  pa.BufferReader(output.getvalue()		)
  lowercase__           =  pq.read_table(_SCREAMING_SNAKE_CASE		)
  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  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       List[Any]:
  import PIL.Image

  lowercase__           =  str(tmp_path / 'test_image_rgb.jpg'		)
  PIL.Image.fromarray(np.zeros((5, 5)		,						dtype=np.uinta		)		).save(_SCREAMING_SNAKE_CASE		,						format='png'		)
  lowercase__           =  pa.BufferOutputStream()
  with ParquetWriter(
      stream=_SCREAMING_SNAKE_CASE		,						features=Features({'image': Image()}		)		,						embed_local_files=_SCREAMING_SNAKE_CASE		) as writer:
    writer.write({'image': image_path}		)
    writer.finalize()
  lowercase__           =  pa.BufferReader(output.getvalue()		)
  lowercase__           =  pq.read_table(_SCREAMING_SNAKE_CASE		)
  lowercase__           =  pa_table.to_pydict()
  if embed_local_files:
    assert isinstance(out['image'][0]['path']		,						_SCREAMING_SNAKE_CASE		)
    with open(_SCREAMING_SNAKE_CASE		,						'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  ()    ->       str:
  lowercase__           =  pa.schema([pa.field('col_1'		,						pa.string()		,						nullable=_SCREAMING_SNAKE_CASE		)]		)
  lowercase__           =  pa.BufferOutputStream()
  with ArrowWriter(stream=_SCREAMING_SNAKE_CASE		) as writer:
    writer._build_writer(inferred_schema=_SCREAMING_SNAKE_CASE		)
    assert writer._schema == pa.schema([pa.field('col_1'		,						pa.string()		)]		)









from typing import TYPE_CHECKING

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


lowercase_          =		{
    """configuration_efficientformer""": [
        """EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """EfficientFormerConfig""",
    ]
}

try:
      if not is_vision_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_          =		["""EfficientFormerImageProcessor"""]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_          =		[
          """EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """EfficientFormerForImageClassification""",
          """EfficientFormerForImageClassificationWithTeacher""",
          """EfficientFormerModel""",
          """EfficientFormerPreTrainedModel""",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_          =		[
          """TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """TFEfficientFormerForImageClassification""",
          """TFEfficientFormerForImageClassificationWithTeacher""",
          """TFEfficientFormerModel""",
          """TFEfficientFormerPreTrainedModel""",
      ]

if TYPE_CHECKING:
      from .configuration_efficientformer import EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, EfficientFormerConfig

      try:
            if not is_vision_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .image_processing_efficientformer import EfficientFormerImageProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_efficientformer import (
                EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                EfficientFormerForImageClassification,
                EfficientFormerForImageClassificationWithTeacher,
                EfficientFormerModel,
                EfficientFormerPreTrainedModel,
            )
      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_efficientformer import (
                TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFEfficientFormerForImageClassification,
                TFEfficientFormerForImageClassificationWithTeacher,
                TFEfficientFormerModel,
                TFEfficientFormerPreTrainedModel,
            )

else:
      import sys

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


