



import random
import unittest

from torch.utils.data import BatchSampler, DataLoader, IterableDataset

from accelerate import Accelerator
from accelerate.data_loader import (
    BatchSamplerShard,
    DataLoaderDispatcher,
    DataLoaderShard,
    IterableDatasetShard,
    SkipBatchSampler,
    SkipDataLoader,
    skip_first_batches,
)
class 				_snake_case			(					__a):




    def __init__(						self					:						str,					__lowercase					:						Dict=0.01,					__lowercase					:						Optional[Any]=1000						):
       lowercase__					  =				p_stop
       lowercase__					  =				max_length




    def __iter__(						self					:						Tuple						):
       lowercase__					  =				0
       lowercase__					  =				False
       while not stop and count < self.max_length:
          yield count
          count += 1
          lowercase__					  =				random.random() < self.p_stop
class 				_snake_case			(					unittest.TestCase):




    def 							A__      (						self					:						List[Any],					__lowercase					:						List[Any],					__lowercase					:						List[str],					__lowercase					:						Optional[Any]=False,					__lowercase					:						List[Any]=True						):
       lowercase__					  =				[
           BatchSamplerShard(lowerCAmelCase_,					2,					lowerCAmelCase_,					split_batches=lowerCAmelCase_,					even_batches=lowerCAmelCase_						)
           for i in range(2						)
       ]
       lowercase__					  =				[list(lowerCAmelCase_						) for batch_sampler_shard in batch_sampler_shards]
       if not split_batches:
          self.assertListEqual([len(lowerCAmelCase_						) for shard in batch_sampler_shards],					[len(lowerCAmelCase_						) for e in expected]						)
       self.assertListEqual(lowerCAmelCase_,					lowerCAmelCase_						)




    def 							A__      (						self					:						int						):
       lowercase__					  =				BatchSampler(range(24						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(24						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       # Expected shouldn't change
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)

       # Check the shards when the dataset is a round multiple of batch size but not total batch size.
       lowercase__					  =				BatchSampler(range(21						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17], [0, 1, 2]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(21						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)

       # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
       # num_processes batch.
       lowercase__					  =				BatchSampler(range(22						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 0, 1]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(22						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)

       # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
       # num_processes batch.
       lowercase__					  =				BatchSampler(range(20						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 0]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17], [1, 2, 3]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(20						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)

       # Check the shards when the dataset is very small.
       lowercase__					  =				BatchSampler(range(2						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[[[0, 1, 0]], [[1, 0, 1]]]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(2						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[[], []]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_						)




    def 							A__      (						self					:						Any						):
       lowercase__					  =				BatchSampler(range(24						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(24						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       # Expected shouldn't change
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is not a round multiple of batch size.
       lowercase__					  =				BatchSampler(range(22						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [0, 1]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(22						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is not a round multiple of batch size or num_processes.
       lowercase__					  =				BatchSampler(range(21						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 0]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [1, 2]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(21						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is very small.
       lowercase__					  =				BatchSampler(range(2						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[[[0, 1]], [[0, 1]]]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(2						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[[], []]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_						)




    def 							A__      (						self					:						Any						):
       lowercase__					  =				BatchSampler(range(24						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(24						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       # Expected shouldn't change
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is a round multiple of batch size but not total batch size.
       lowercase__					  =				BatchSampler(range(21						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(21						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
       # num_processes batch.
       lowercase__					  =				BatchSampler(range(22						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(22						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
       # num_processes batch.
       lowercase__					  =				BatchSampler(range(20						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(20						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
           [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is very small.
       lowercase__					  =				BatchSampler(range(2						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[[[0, 1]], []]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(2						),					batch_size=3,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[[], []]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						)




    def 							A__      (						self					:						Tuple						):
       lowercase__					  =				BatchSampler(range(24						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(24						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       # Expected shouldn't change
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is not a round multiple of batch size.
       lowercase__					  =				BatchSampler(range(22						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(22						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is not a round multiple of batch size or num_processes.
       lowercase__					  =				BatchSampler(range(21						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(21						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[
           [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
           [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
       ]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       # Check the shards when the dataset is very small.
       lowercase__					  =				BatchSampler(range(2						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[[[0, 1]], []]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_,					even_batches=lowerCAmelCase_						)

       lowercase__					  =				BatchSampler(range(2						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				[[], []]
       self.check_batch_sampler_shards(lowerCAmelCase_,					lowerCAmelCase_,					split_batches=lowerCAmelCase_,					even_batches=lowerCAmelCase_						)




    def 							A__      (						self					:						Optional[int]						):
       lowercase__					  =				[[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]]
       lowercase__					  =				[BatchSamplerShard(lowerCAmelCase_,					2,					lowerCAmelCase_,					even_batches=lowerCAmelCase_						) for i in range(2						)]

       self.assertEqual(len(batch_sampler_shards[0]						),					3						)
       self.assertEqual(len(batch_sampler_shards[1]						),					2						)

       self.assertListEqual(list(batch_sampler_shards[0]						),					[[0, 1, 2], [5, 6, 7, 8], [12, 13]]						)
       self.assertListEqual(list(batch_sampler_shards[1]						),					[[3, 4], [9, 10, 11]]						)




    def 							A__      (						self					:						Optional[int],					__lowercase					:						List[Any],					__lowercase					:						Optional[int],					__lowercase					:						str,					__lowercase					:						str=False,					__lowercase					:						List[str]=2,					__lowercase					:						Optional[int]=False						):
       random.seed(lowerCAmelCase_						)
       lowercase__					  =				list(lowerCAmelCase_						)

       lowercase__					  =				[
           IterableDatasetShard(
               lowerCAmelCase_,					batch_size=lowerCAmelCase_,					drop_last=lowerCAmelCase_,					num_processes=lowerCAmelCase_,					process_index=lowerCAmelCase_,					split_batches=lowerCAmelCase_,					)
           for i in range(lowerCAmelCase_						)
       ]
       lowercase__					  =				[]
       for iterable_dataset_shard in iterable_dataset_shards:
          # Since our random iterable dataset will be... random... we need to use a seed to get reproducible results.
          random.seed(lowerCAmelCase_						)
          iterable_dataset_lists.append(list(lowerCAmelCase_						)						)

       lowercase__					  =				batch_size // num_processes if split_batches else batch_size
       # All iterable dataset shard should have the same length, a round multiple of shard_batch_size
       lowercase__					  =				iterable_dataset_lists[0]
       for l in iterable_dataset_lists[1:]:
          self.assertEqual(len(lowerCAmelCase_						),					len(lowerCAmelCase_						)						)
          self.assertTrue(len(lowerCAmelCase_						) % shard_batch_size == 0						)

       lowercase__					  =				[]
       for idx in range(0,					len(lowerCAmelCase_						),					lowerCAmelCase_						):
          for l in iterable_dataset_lists:
             observed += l[idx : idx + shard_batch_size]

       if not drop_last:
          while len(lowerCAmelCase_						) < len(lowerCAmelCase_						):
             reference += reference
       self.assertListEqual(lowerCAmelCase_,					reference[: len(lowerCAmelCase_						)]						)




    def 							A__      (						self					:						str						):
       lowercase__					  =				42
       lowercase__					  =				RandomIterableDataset()

       self.check_iterable_dataset_shards(lowerCAmelCase_,					lowerCAmelCase_,					batch_size=4,					drop_last=lowerCAmelCase_,					split_batches=lowerCAmelCase_						)
       self.check_iterable_dataset_shards(lowerCAmelCase_,					lowerCAmelCase_,					batch_size=4,					drop_last=lowerCAmelCase_,					split_batches=lowerCAmelCase_						)
       self.check_iterable_dataset_shards(lowerCAmelCase_,					lowerCAmelCase_,					batch_size=4,					drop_last=lowerCAmelCase_,					split_batches=lowerCAmelCase_						)
       self.check_iterable_dataset_shards(lowerCAmelCase_,					lowerCAmelCase_,					batch_size=4,					drop_last=lowerCAmelCase_,					split_batches=lowerCAmelCase_						)

       # Edge case with a very small dataset
       lowercase__					  =				RandomIterableDataset(max_length=2						)

       self.check_iterable_dataset_shards(lowerCAmelCase_,					lowerCAmelCase_,					batch_size=4,					drop_last=lowerCAmelCase_,					split_batches=lowerCAmelCase_						)
       self.check_iterable_dataset_shards(lowerCAmelCase_,					lowerCAmelCase_,					batch_size=4,					drop_last=lowerCAmelCase_,					split_batches=lowerCAmelCase_						)
       self.check_iterable_dataset_shards(lowerCAmelCase_,					lowerCAmelCase_,					batch_size=4,					drop_last=lowerCAmelCase_,					split_batches=lowerCAmelCase_						)
       self.check_iterable_dataset_shards(lowerCAmelCase_,					lowerCAmelCase_,					batch_size=4,					drop_last=lowerCAmelCase_,					split_batches=lowerCAmelCase_						)




    def 							A__      (						self					:						Tuple						):
       lowercase__					  =				BatchSampler(range(16						),					batch_size=4,					drop_last=lowerCAmelCase_						)
       lowercase__					  =				SkipBatchSampler(lowerCAmelCase_,					2						)
       self.assertListEqual(list(lowerCAmelCase_						),					[[8, 9, 10, 11], [12, 13, 14, 15]]						)




    def 							A__      (						self					:						Optional[int]						):
       lowercase__					  =				SkipDataLoader(list(range(16						)						),					batch_size=4,					skip_batches=2						)
       self.assertListEqual([t.tolist() for t in dataloader],					[[8, 9, 10, 11], [12, 13, 14, 15]]						)




    def 							A__      (						self					:						Union[str, Any]						):
       lowercase__					  =				DataLoader(list(range(16						)						),					batch_size=4						)
       lowercase__					  =				skip_first_batches(lowerCAmelCase_,					num_batches=2						)
       self.assertListEqual([t.tolist() for t in new_dataloader],					[[8, 9, 10, 11], [12, 13, 14, 15]]						)




    def 							A__      (						self					:						str						):
       lowercase__					  =				DataLoaderShard(list(range(16						)						),					batch_size=4						)
       for idx, _ in enumerate(lowerCAmelCase_						):
          self.assertEqual(dataloader.end_of_dataloader,					idx == 3						)

       # Test it also works on the second iteration
       for idx, _ in enumerate(lowerCAmelCase_						):
          self.assertEqual(dataloader.end_of_dataloader,					idx == 3						)




    def 							A__      (						self					:						Any						):
       Accelerator()
       lowercase__					  =				DataLoaderDispatcher(range(16						),					batch_size=4						)
       for idx, _ in enumerate(lowerCAmelCase_						):
          self.assertEqual(dataloader.end_of_dataloader,					idx == 3						)

       # Test it also works on the second iteration
       for idx, _ in enumerate(lowerCAmelCase_						):
          self.assertEqual(dataloader.end_of_dataloader,					idx == 3						)









# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase_								=     {
    """configuration_xmod""": [
        """XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XmodConfig""",
        """XmodOnnxConfig""",
    ],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase_								=     [
							    """XMOD_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """XmodForCausalLM""",
							    """XmodForMaskedLM""",
							    """XmodForMultipleChoice""",
							    """XmodForQuestionAnswering""",
							    """XmodForSequenceClassification""",
							    """XmodForTokenClassification""",
							    """XmodModel""",
							    """XmodPreTrainedModel""",
							]

if TYPE_CHECKING:
							from .configuration_xmod import XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP, XmodConfig, XmodOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_xmod import (
														    XMOD_PRETRAINED_MODEL_ARCHIVE_LIST,
														    XmodForCausalLM,
														    XmodForMaskedLM,
														    XmodForMultipleChoice,
														    XmodForQuestionAnswering,
														    XmodForSequenceClassification,
														    XmodForTokenClassification,
														    XmodModel,
														    XmodPreTrainedModel,
														)

else:
							import sys

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




