




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       A   (		a__   ):







							def __init__(  self	:  Union[str, Any]							,      lowerCAmelCase_	:  Any=0.0_1							,      lowerCAmelCase_	:  List[str]=10_00 )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    p_stop
														_a     					=    max_length







							def __iter__(  self	:  Optional[Any] )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    0
														_a     					=    False
														while not stop and count < self.max_length:
																					yield count
																					count += 1
																					_a     					=    random.random() < self.p_stop



class       A   (		unittest.TestCase   ):







							def        __lowerCAmelCase      (  self	:  List[str]							,      lowerCAmelCase_	:  int							,      lowerCAmelCase_	:  int							,      lowerCAmelCase_	:  str=False							,      lowerCAmelCase_	:  List[Any]=True )      ->							Optional[int]:


														"""simple docstring"""


														_a     					=    [
														    BatchSamplerShard(_lowerCamelCase							,      2							,      _lowerCamelCase							,      split_batches=_lowerCamelCase							,      even_batches=_lowerCamelCase )
														    for i in range(2 )
														]
														_a     					=    [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        __lowerCAmelCase      (  self	:  List[str] )      ->							Tuple:


														"""simple docstring"""


														_a     					=    BatchSampler(range(24 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    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.
														_a     					=    BatchSampler(range(21 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(21 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(22 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(22 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(20 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(20 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(2 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [[[0, 1, 0]], [[1, 0, 1]]]
														self.check_batch_sampler_shards(_lowerCamelCase							,      _lowerCamelCase )

														_a     					=    BatchSampler(range(2 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [[], []]
														self.check_batch_sampler_shards(_lowerCamelCase							,      _lowerCamelCase )







							def        __lowerCAmelCase      (  self	:  str )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    BatchSampler(range(24 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    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.
														_a     					=    BatchSampler(range(22 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(22 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(21 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(21 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(2 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [[[0, 1]], [[0, 1]]]
														self.check_batch_sampler_shards(_lowerCamelCase							,      _lowerCamelCase							,      split_batches=_lowerCamelCase )

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







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    BatchSampler(range(24 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    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.
														_a     					=    BatchSampler(range(21 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(21 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(22 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(22 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(20 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(20 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(2 )							,      batch_size=3							,      drop_last=_lowerCamelCase )
														_a     					=    [[[0, 1]], []]
														self.check_batch_sampler_shards(_lowerCamelCase							,      _lowerCamelCase							,      even_batches=_lowerCamelCase )

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







							def        __lowerCAmelCase      (  self	:  Dict )      ->							int:


														"""simple docstring"""


														_a     					=    BatchSampler(range(24 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    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.
														_a     					=    BatchSampler(range(22 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(22 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(21 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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 )

														_a     					=    BatchSampler(range(21 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [
														    [[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.
														_a     					=    BatchSampler(range(2 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    [[[0, 1]], []]
														self.check_batch_sampler_shards(_lowerCamelCase							,      _lowerCamelCase							,      split_batches=_lowerCamelCase							,      even_batches=_lowerCamelCase )

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







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							List[Any]:


														"""simple docstring"""


														_a     					=    [[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]]
														_a     					=    [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        __lowerCAmelCase      (  self	:  List[str]							,      lowerCAmelCase_	:  Optional[int]							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  List[str]							,      lowerCAmelCase_	:  Any=False							,      lowerCAmelCase_	:  int=2							,      lowerCAmelCase_	:  Union[str, Any]=False )      ->							List[str]:


														"""simple docstring"""


														random.seed(_lowerCamelCase )
														_a     					=    list(_lowerCamelCase )

														_a     					=    [
														    IterableDatasetShard(
														        _lowerCamelCase							,      batch_size=_lowerCamelCase							,      drop_last=_lowerCamelCase							,      num_processes=_lowerCamelCase							,      process_index=_lowerCamelCase							,      split_batches=_lowerCamelCase							,      )
														    for i in range(_lowerCamelCase )
														]
														_a     					=    []
														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 ) )

														_a     					=    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
														_a     					=    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 )

														_a     					=    []
														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        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Any:


														"""simple docstring"""


														_a     					=    42
														_a     					=    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
														_a     					=    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        __lowerCAmelCase      (  self	:  List[str] )      ->							List[Any]:


														"""simple docstring"""


														_a     					=    BatchSampler(range(16 )							,      batch_size=4							,      drop_last=_lowerCamelCase )
														_a     					=    SkipBatchSampler(_lowerCamelCase							,      2 )
														self.assertListEqual(list(_lowerCamelCase )							,      [[8, 9, 10, 11], [12, 13, 14, 15]] )







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


														"""simple docstring"""


														_a     					=    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        __lowerCAmelCase      (  self	:  List[Any] )      ->							Any:


														"""simple docstring"""


														_a     					=    DataLoader(list(range(16 ) )							,      batch_size=4 )
														_a     					=    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        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Dict:


														"""simple docstring"""


														_a     					=    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        __lowerCAmelCase      (  self	:  Tuple )      ->							Dict:


														"""simple docstring"""


														Accelerator()
														_a     					=    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 )







'''simple docstring'''


from .configuration_bert_masked import MaskedBertConfig
from .modeling_bert_masked import (
    MaskedBertForMultipleChoice,
    MaskedBertForQuestionAnswering,
    MaskedBertForSequenceClassification,
    MaskedBertForTokenClassification,
    MaskedBertModel,
)
from .modules import *

