






'''simple docstring'''


import contextlib
from multiprocessing import Pool, RLock

from tqdm.auto import tqdm

from ..utils import experimental, logging


lowerCamelCase_				: List[str]    	=							logging.get_logger(__name__)
class    _SCREAMING_SNAKE_CASE							:


			'''simple docstring'''





			__a							:							List[Any]					     =					None







@experimental
def 	__magic_name__( _A						,      _A						,      _A						,      _A						,      _A						,      _A						,      _A					):
						'''simple docstring'''





						if ParallelBackendConfig.backend_name is None:
												return _map_with_multiprocessing_pool(
												    _A						,      _A						,      _A						,      _A						,      _A						,      _A						,      _A					)

						return _map_with_joblib(_A						,      _A						,      _A						,      _A						,      _A						,      _A						,      _A					)







def 	__magic_name__( _A						,      _A						,      _A						,      _A						,      _A						,      _A						,      _A					):
						'''simple docstring'''





						UpperCamelCase__         = num_proc if num_proc <= len(_A					) else len(_A					)
						UpperCamelCase__         = []  # We organize the splits ourselve (contiguous splits)
						for index in range(_A					):
												UpperCamelCase__         = len(_A					) // num_proc
												UpperCamelCase__         = len(_A					) % num_proc
												UpperCamelCase__         = div * index + min(_A						,      _A					)
												UpperCamelCase__         = start + div + (1 if index < mod else 0)
												split_kwds.append((function, iterable[start:end], types, index, disable_tqdm, desc)					)

						if len(_A					) != sum(len(i[1]					) for i in split_kwds					):
												raise ValueError(
												    f"Error dividing inputs iterable among processes. "
												    f"Total number of objects {len(_A					)}, "
												    f"length: {sum(len(i[1]					) for i in split_kwds					)}"					)

						logger.info(
						    f"Spawning {num_proc} processes for {len(_A					)} objects in slices of {[len(i[1]					) for i in split_kwds]}"					)
						UpperCamelCase__    ,   UpperCamelCase__         = None, None
						if not disable_tqdm:
												UpperCamelCase__    ,   UpperCamelCase__         = (RLock(),), tqdm.set_lock
						with Pool(_A						,      initargs=_A						,      initializer=_A					) as pool:
												UpperCamelCase__         = pool.map(_A						,      _A					)
						logger.info(f"Finished {num_proc} processes"					)
						UpperCamelCase__         = [obj for proc_res in mapped for obj in proc_res]
						logger.info(f"Unpacked {len(_A					)} objects"					)

						return mapped







def 	__magic_name__( _A						,      _A						,      _A						,      _A						,      _A						,      _A						,      _A					):
						'''simple docstring'''





						import joblib

						with joblib.parallel_backend(ParallelBackendConfig.backend_name						,      n_jobs=_A					):
												return joblib.Parallel()(
												    joblib.delayed(_A					)((function, obj, types, None, True, None)					) for obj in iterable					)







@experimental
@contextlib.contextmanager
def 	__magic_name__( _A					):
						'''simple docstring'''





						UpperCamelCase__         = backend_name

						if backend_name == "spark":
												from joblibspark import register_spark

												register_spark()

												# TODO: call create_cache_and_write_probe if "download" in steps
												# TODO: raise NotImplementedError when Dataset.map etc is called

						try:
												yield
						finally:
												UpperCamelCase__         = None








'''simple docstring'''


from typing import TYPE_CHECKING

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


lowerCamelCase_				: Tuple    	=							{
    '''configuration_layoutlmv3''': [
        '''LAYOUTLMV3_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''LayoutLMv3Config''',
        '''LayoutLMv3OnnxConfig''',
    ],
    '''processing_layoutlmv3''': ['''LayoutLMv3Processor'''],
    '''tokenization_layoutlmv3''': ['''LayoutLMv3Tokenizer'''],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_				: Tuple    	=							['''LayoutLMv3TokenizerFast''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_				: Union[str, Any]    	=							[
					    '''LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''LayoutLMv3ForQuestionAnswering''',
					    '''LayoutLMv3ForSequenceClassification''',
					    '''LayoutLMv3ForTokenClassification''',
					    '''LayoutLMv3Model''',
					    '''LayoutLMv3PreTrainedModel''',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_				: Optional[Any]    	=							[
					    '''TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TFLayoutLMv3ForQuestionAnswering''',
					    '''TFLayoutLMv3ForSequenceClassification''',
					    '''TFLayoutLMv3ForTokenClassification''',
					    '''TFLayoutLMv3Model''',
					    '''TFLayoutLMv3PreTrainedModel''',
					]

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_				: Optional[Any]    	=							['''LayoutLMv3FeatureExtractor''']
					lowerCamelCase_				: Dict    	=							['''LayoutLMv3ImageProcessor''']


if TYPE_CHECKING:
					from .configuration_layoutlmva import (
					    LAYOUTLMV3_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    LayoutLMvaConfig,
					    LayoutLMvaOnnxConfig,
					)
					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_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_layoutlmva import (
										    LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
										    LayoutLMvaForQuestionAnswering,
										    LayoutLMvaForSequenceClassification,
										    LayoutLMvaForTokenClassification,
										    LayoutLMvaModel,
										    LayoutLMvaPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_layoutlmva import (
										    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFLayoutLMvaForQuestionAnswering,
										    TFLayoutLMvaForSequenceClassification,
										    TFLayoutLMvaForTokenClassification,
										    TFLayoutLMvaModel,
										    TFLayoutLMvaPreTrainedModel,
										)

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

else:
					import sys

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