





import time
from dataclasses import dataclass
from multiprocessing import Pool
from unittest import TestCase
from unittest.mock import patch

import multiprocess
import numpy as np
import pytest

from datasets.utils.py_utils import (
    NestedDataStructure,
    asdict,
    iflatmap_unordered,
    map_nested,
    temp_seed,
    temporary_assignment,
    zip_dict,
)

from .utils import require_tf, require_torch






def      lowerCamelCase__      (__lowerCamelCase						):  # picklable for multiprocessing
     return x.sum()






def      lowerCamelCase__      (__lowerCamelCase						):  # picklable for multiprocessing
     return i + 1





@dataclass
class       lowerCAmelCase__:






       '''simple docstring'''


       __snake_case			      =     4_2
       __snake_case			      =     4_2





class       lowerCAmelCase__(			a_     ):






       '''simple docstring'''


       def      UpperCamelCase_      (   self				)      ->  Tuple:
            _SCREAMING_SNAKE_CASE							:						Tuple         =				{}
            _SCREAMING_SNAKE_CASE							:						Union[str, Any]         =				[]
            _SCREAMING_SNAKE_CASE							:						Optional[int]         =				1
            _SCREAMING_SNAKE_CASE							:						Tuple         =				[1, 2]
            _SCREAMING_SNAKE_CASE							:						Dict         =				{"a": 1, "b": 2}
            _SCREAMING_SNAKE_CASE							:						int         =				{"a": [1, 2], "b": [3, 4]}
            _SCREAMING_SNAKE_CASE							:						int         =				{"a": {"1": 1}, "b": 2}
            _SCREAMING_SNAKE_CASE							:						Optional[Any]         =				{"a": 1, "b": 2, "c": 3, "d": 4}
            _SCREAMING_SNAKE_CASE							:						Any         =				{}
            _SCREAMING_SNAKE_CASE							:						Optional[int]         =				[]
            _SCREAMING_SNAKE_CASE							:						Optional[int]         =				2
            _SCREAMING_SNAKE_CASE							:						Optional[int]         =				[2, 3]
            _SCREAMING_SNAKE_CASE							:						List[str]         =				{"a": 2, "b": 3}
            _SCREAMING_SNAKE_CASE							:						int         =				{"a": [2, 3], "b": [4, 5]}
            _SCREAMING_SNAKE_CASE							:						Optional[int]         =				{"a": {"1": 2}, "b": 3}
            _SCREAMING_SNAKE_CASE							:						Union[str, Any]         =				{"a": 2, "b": 3, "c": 4, "d": 5}
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)

            _SCREAMING_SNAKE_CASE							:						List[str]         =				2
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)

            _SCREAMING_SNAKE_CASE							:						Any         =				{"a": np.eye(2				), "b": np.zeros(3				), "c": np.ones(2				)}
            _SCREAMING_SNAKE_CASE							:						str         =				{"a": 2, "b": 0, "c": 2}
            _SCREAMING_SNAKE_CASE							:						List[Any]         =				{
                "a": np.eye(2				).astype(__SCREAMING_SNAKE_CASE				),
                "b": np.zeros(3				).astype(__SCREAMING_SNAKE_CASE				),
                "c": np.ones(2				).astype(__SCREAMING_SNAKE_CASE				),
            }
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    map_numpy=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(
                {k: v.tolist() for k, v in map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    map_numpy=__SCREAMING_SNAKE_CASE				).items()}     ,    {k: v.tolist() for k, v in expected_map_nested_sna_int.items()}     ,    )
            self.assertEqual(map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    map_numpy=__SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)     ,    __SCREAMING_SNAKE_CASE				)
            self.assertEqual(
                {k: v.tolist() for k, v in map_nested(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    map_numpy=__SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				).items()}     ,    {k: v.tolist() for k, v in expected_map_nested_sna_int.items()}     ,    )
            with self.assertRaises(__SCREAMING_SNAKE_CASE				):  # can't pickle a local lambda
                 map_nested(lambda __lowerCamelCase				: x + 1     ,    __SCREAMING_SNAKE_CASE     ,    num_proc=__SCREAMING_SNAKE_CASE				)




       def      UpperCamelCase_      (   self				)      ->  Any:
            _SCREAMING_SNAKE_CASE							:						int         =				{"a": 1, "b": 2}
            _SCREAMING_SNAKE_CASE							:						Dict         =				{"a": 3, "b": 4}
            _SCREAMING_SNAKE_CASE							:						Optional[Any]         =				{"a": 5, "b": 6}
            _SCREAMING_SNAKE_CASE							:						Optional[int]         =				sorted([("a", (1, 3, 5)), ("b", (2, 4, 6))]				)
            self.assertEqual(sorted(zip_dict(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)				)     ,    __SCREAMING_SNAKE_CASE				)







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





            class       lowerCAmelCase__:






                   '''simple docstring'''


                   __snake_case			      =     'bar'
            _SCREAMING_SNAKE_CASE							:						Optional[int]         =				Foo()
            self.assertEqual(foo.my_attr     ,    "bar"				)
            with temporary_assignment(__SCREAMING_SNAKE_CASE     ,    "my_attr"     ,    "BAR"				):
                 self.assertEqual(foo.my_attr     ,    "BAR"				)
            self.assertEqual(foo.my_attr     ,    "bar"				)






@pytest.mark.parametrize(
    "iterable_length, num_proc, expected_num_proc",							[
        (1, None, 1),
        (1, 1, 1),
        (2, None, 1),
        (2, 1, 1),
        (2, 2, 1),
        (2, 3, 1),
        (3, 2, 1),
        (16, 16, 16),
        (16, 17, 16),
        (17, 16, 16),
    ],							)
def      lowerCamelCase__      (__lowerCamelCase,							__lowerCamelCase,							__lowerCamelCase						):


     with patch("datasets.utils.py_utils._single_map_nested"						) as mock_single_map_nested, patch(
         "datasets.parallel.parallel.Pool"						) as mock_multiprocessing_pool:
          _SCREAMING_SNAKE_CASE							:						Tuple         =				{f"""{i}""": i for i in range(_A						)}
          _SCREAMING_SNAKE_CASE							:						str         =				map_nested(lambda __lowerCamelCase						: x + 10,							_A,							num_proc=_A,							parallel_min_length=16						)
          if expected_num_proc == 1:
               assert mock_single_map_nested.called
               assert not mock_multiprocessing_pool.called
          else:
               assert not mock_single_map_nested.called
               assert mock_multiprocessing_pool.called
               assert mock_multiprocessing_pool.call_args[0][0] == expected_num_proc





class       lowerCAmelCase__(			a_     ):






       '''simple docstring'''


       @require_tf
       def      UpperCamelCase_      (   self				)      ->  Optional[int]:
            import tensorflow as tf
            from tensorflow.keras import layers

            _SCREAMING_SNAKE_CASE							:						Union[str, Any]         =				layers.Dense(2				)

            def gen_random_output():
                 _SCREAMING_SNAKE_CASE							:						Optional[Any]         =				tf.random.uniform((1, 3)				)
                 return model(__SCREAMING_SNAKE_CASE				).numpy()

            with temp_seed(4_2     ,    set_tensorflow=__SCREAMING_SNAKE_CASE				):
                 _SCREAMING_SNAKE_CASE							:						Dict         =				gen_random_output()
            with temp_seed(4_2     ,    set_tensorflow=__SCREAMING_SNAKE_CASE				):
                 _SCREAMING_SNAKE_CASE							:						int         =				gen_random_output()
            _SCREAMING_SNAKE_CASE							:						int         =				gen_random_output()

            np.testing.assert_equal(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)
            self.assertGreater(np.abs(outa - outa				).sum()     ,    0				)




       @require_torch
       def      UpperCamelCase_      (   self				)      ->  Tuple:
            import torch

            def gen_random_output():
                 _SCREAMING_SNAKE_CASE							:						Union[str, Any]         =				torch.nn.Linear(3     ,    2				)
                 _SCREAMING_SNAKE_CASE							:						List[str]         =				torch.rand(1     ,    3				)
                 return model(__SCREAMING_SNAKE_CASE				).detach().numpy()

            with temp_seed(4_2     ,    set_pytorch=__SCREAMING_SNAKE_CASE				):
                 _SCREAMING_SNAKE_CASE							:						Optional[Any]         =				gen_random_output()
            with temp_seed(4_2     ,    set_pytorch=__SCREAMING_SNAKE_CASE				):
                 _SCREAMING_SNAKE_CASE							:						Union[str, Any]         =				gen_random_output()
            _SCREAMING_SNAKE_CASE							:						Union[str, Any]         =				gen_random_output()

            np.testing.assert_equal(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)
            self.assertGreater(np.abs(outa - outa				).sum()     ,    0				)







       def      UpperCamelCase_      (   self				)      ->  Union[str, Any]:
            def gen_random_output():
                 return np.random.rand(1     ,    3				)

            with temp_seed(4_2				):
                 _SCREAMING_SNAKE_CASE							:						Optional[int]         =				gen_random_output()
            with temp_seed(4_2				):
                 _SCREAMING_SNAKE_CASE							:						int         =				gen_random_output()
            _SCREAMING_SNAKE_CASE							:						Dict         =				gen_random_output()

            np.testing.assert_equal(__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE				)
            self.assertGreater(np.abs(outa - outa				).sum()     ,    0				)






@pytest.mark.parametrize("input_data",							[{}]						)
def      lowerCamelCase__      (__lowerCamelCase						):
     _SCREAMING_SNAKE_CASE							:						str         =				NestedDataStructure(_A						).data
     assert output_data == input_data






@pytest.mark.parametrize(
    "data, expected_output",							[
        ({}, []),
        ([], []),
        ("foo", ["foo"]),
        (["foo", "bar"], ["foo", "bar"]),
        ([["foo", "bar"]], ["foo", "bar"]),
        ([[["foo"], ["bar"]]], ["foo", "bar"]),
        ([[["foo"], "bar"]], ["foo", "bar"]),
        ({"a": 1, "b": 2}, [1, 2]),
        ({"a": [1, 2], "b": [3, 4]}, [1, 2, 3, 4]),
        ({"a": [[1, 2]], "b": [[3, 4]]}, [1, 2, 3, 4]),
        ({"a": [[1, 2]], "b": [3, 4]}, [1, 2, 3, 4]),
        ({"a": [[[1], [2]]], "b": [[[3], [4]]]}, [1, 2, 3, 4]),
        ({"a": [[[1], [2]]], "b": [[3, 4]]}, [1, 2, 3, 4]),
        ({"a": [[[1], [2]]], "b": [3, 4]}, [1, 2, 3, 4]),
        ({"a": [[[1], [2]]], "b": [3, [4]]}, [1, 2, 3, 4]),
        ({"a": {"1": 1}, "b": 2}, [1, 2]),
        ({"a": {"1": [1]}, "b": 2}, [1, 2]),
        ({"a": {"1": [1]}, "b": [2]}, [1, 2]),
    ],							)
def      lowerCamelCase__      (__lowerCamelCase,							__lowerCamelCase						):
     _SCREAMING_SNAKE_CASE							:						Optional[Any]         =				NestedDataStructure(_A						).flatten()
     assert output == expected_output






def      lowerCamelCase__      ():
     _SCREAMING_SNAKE_CASE							:						Dict         =				A(x=1,							y="foobar"						)
     _SCREAMING_SNAKE_CASE							:						int         =				{"x": 1, "y": "foobar"}
     assert asdict(_A						) == expected_output

     _SCREAMING_SNAKE_CASE							:						Optional[Any]         =				{"a": {"b": A(x=10,							y="foo"						)}, "c": [A(x=20,							y="bar"						)]}
     _SCREAMING_SNAKE_CASE							:						Dict         =				{"a": {"b": {"x": 10, "y": "foo"}}, "c": [{"x": 20, "y": "bar"}]}
     assert asdict(_A						) == expected_output

     with pytest.raises(_A						):
          asdict([1, A(x=10,							y="foo"						)]						)






def      lowerCamelCase__      (__lowerCamelCase						):
     return text.split()






def      lowerCamelCase__      (__lowerCamelCase						):
     yield (time.time(), content)
     time.sleep(2						)
     yield (time.time(), content)






def      lowerCamelCase__      ():


     with Pool(2						) as pool:
          _SCREAMING_SNAKE_CASE							:						int         =				list(iflatmap_unordered(_A,							_split_text,							kwargs_iterable=[{"text": "hello there"}] * 10						)						)
          assert out.count("hello"						) == 10
          assert out.count("there"						) == 10
          assert len(_A						) == 20

     # check multiprocess from pathos (uses dill for pickling)
     with multiprocess.Pool(2						) as pool:
          _SCREAMING_SNAKE_CASE							:						str         =				list(iflatmap_unordered(_A,							_split_text,							kwargs_iterable=[{"text": "hello there"}] * 10						)						)
          assert out.count("hello"						) == 10
          assert out.count("there"						) == 10
          assert len(_A						) == 20

     # check that we get items as fast as possible
     with Pool(2						) as pool:
          _SCREAMING_SNAKE_CASE							:						str         =				[]
          for yield_time, content in iflatmap_unordered(
              _A,							_aseconds_generator_of_aitems_with_timing,							kwargs_iterable=[{"content": "a"}, {"content": "b"}]						):
               assert yield_time < time.time() + 0.1, "we should each item directly after it was yielded"
               out.append(_A						)
          assert out.count("a"						) == 2
          assert out.count("b"						) == 2
          assert len(_A						) == 4
def 	__A		(      _A				,					_A       ):



 """simple docstring"""


 return x if y == 0 else greatest_common_divisor(_A				,					x % y       )



def 	__A		(      _A				,					_A       ):



 """simple docstring"""


 return (x * y) // greatest_common_divisor(_A				,					_A       )



def 	__A		(      _A = 20       ):



 """simple docstring"""


 __a							=	1
 for i in range(1				,					n + 1       ):
  __a							=	lcm(_A				,					_A       )
 return g


if __name__ == "__main__":
  print(f'''{solution() = }''')


