



"""simple docstring"""






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 	snake_case_  (				A_ :		Tuple						):  # picklable for multiprocessing


       '''simple docstring'''





       return x.sum()






def 	snake_case_  (				A_ :		List[str]						):  # picklable for multiprocessing


       '''simple docstring'''





       return i + 1






@dataclass
class 	__snake_case	:
  snake_case__    :       int
  snake_case__    :       str






class 	__snake_case	(     UpperCAmelCase__):




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			{}
         _lowerCamelCase						:    Optional[Any]         =			[]
         _lowerCamelCase						:    Tuple         =			1
         _lowerCamelCase						:    int         =			[1, 2]
         _lowerCamelCase						:    int         =			{"""a""": 1, """b""": 2}
         _lowerCamelCase						:    Union[str, Any]         =			{"""a""": [1, 2], """b""": [3, 4]}
         _lowerCamelCase						:    Any         =			{"""a""": {"""1""": 1}, """b""": 2}
         _lowerCamelCase						:    Tuple         =			{"""a""": 1, """b""": 2, """c""": 3, """d""": 4}
         _lowerCamelCase						:    int         =			{}
         _lowerCamelCase						:    Optional[int]         =			[]
         _lowerCamelCase						:    Dict         =			2
         _lowerCamelCase						:    List[Any]         =			[2, 3]
         _lowerCamelCase						:    List[str]         =			{"""a""": 2, """b""": 3}
         _lowerCamelCase						:    Optional[int]         =			{"""a""": [2, 3], """b""": [4, 5]}
         _lowerCamelCase						:    List[str]         =			{"""a""": {"""1""": 2}, """b""": 3}
         _lowerCamelCase						:    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		)

         _lowerCamelCase						:    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		)

         _lowerCamelCase						:    Tuple         =			{"""a""": np.eye(2		), """b""": np.zeros(3		), """c""": np.ones(2		)}
         _lowerCamelCase						:    Optional[int]         =			{"""a""": 2, """b""": 0, """c""": 2}
         _lowerCamelCase						:    Tuple         =			{
             """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 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			{"""a""": 1, """b""": 2}
         _lowerCamelCase						:    Tuple         =			{"""a""": 3, """b""": 4}
         _lowerCamelCase						:    Any         =			{"""a""": 5, """b""": 6}
         _lowerCamelCase						:    List[Any]         =			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 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]		):






         """simple docstring"""






         class 	__snake_case	:
           snake_case__    :       List[str]        =						'bar'


         _lowerCamelCase						:    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 	snake_case_  (				A_ :		Dict,    A_ :		Union[str, Any],    A_ :		Optional[int]						):


       '''simple docstring'''





       with patch('''datasets.utils.py_utils._single_map_nested'''						) as mock_single_map_nested, patch(
           '''datasets.parallel.parallel.Pool'''						) as mock_multiprocessing_pool:
              _lowerCamelCase						:    Optional[Any]         =			{F'''{i}''': i for i in range(A_						)}
              _lowerCamelCase						:    List[str]         =			map_nested(lambda A_						: 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 	__snake_case	(     UpperCAmelCase__):




  @require_tf
  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






         """simple docstring"""






         import tensorflow as tf
         from tensorflow.keras import layers

         _lowerCamelCase						:    Optional[Any]         =			layers.Dense(2		)

         def gen_random_output():
                _lowerCamelCase						:    Any         =			tf.random.uniform((1, 3)		)
                return model(_SCREAMING_SNAKE_CASE		).numpy()

         with temp_seed(4_2						, set_tensorflow=_SCREAMING_SNAKE_CASE		):
                _lowerCamelCase						:    List[Any]         =			gen_random_output()
         with temp_seed(4_2						, set_tensorflow=_SCREAMING_SNAKE_CASE		):
                _lowerCamelCase						:    Tuple         =			gen_random_output()
         _lowerCamelCase						:    Optional[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 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         import torch

         def gen_random_output():
                _lowerCamelCase						:    Any         =			torch.nn.Linear(3						, 2		)
                _lowerCamelCase						:    int         =			torch.rand(1						, 3		)
                return model(_SCREAMING_SNAKE_CASE		).detach().numpy()

         with temp_seed(4_2						, set_pytorch=_SCREAMING_SNAKE_CASE		):
                _lowerCamelCase						:    List[str]         =			gen_random_output()
         with temp_seed(4_2						, set_pytorch=_SCREAMING_SNAKE_CASE		):
                _lowerCamelCase						:    Any         =			gen_random_output()
         _lowerCamelCase						:    List[str]         =			gen_random_output()

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




  def 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         def gen_random_output():
                return np.random.rand(1						, 3		)

         with temp_seed(4_2		):
                _lowerCamelCase						:    Tuple         =			gen_random_output()
         with temp_seed(4_2		):
                _lowerCamelCase						:    Union[str, Any]         =			gen_random_output()
         _lowerCamelCase						:    List[str]         =			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 	snake_case_  (				A_ :		List[Any]						):


       '''simple docstring'''





       _lowerCamelCase						:    int         =			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 	snake_case_  (				A_ :		Optional[Any],    A_ :		str						):


       '''simple docstring'''





       _lowerCamelCase						:    Optional[Any]         =			NestedDataStructure(A_						).flatten()
       assert output == expected_output






def 	snake_case_  (				):


       '''simple docstring'''





       _lowerCamelCase						:    Optional[Any]         =			A(x=1,    y='''foobar'''						)
       _lowerCamelCase						:    Dict         =			{"""x""": 1, """y""": """foobar"""}
       assert asdict(A_						) == expected_output

       _lowerCamelCase						:    Dict         =			{"""a""": {"""b""": A(x=10,    y='''foo'''						)}, """c""": [A(x=20,    y='''bar'''						)]}
       _lowerCamelCase						:    Any         =			{"""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 	snake_case_  (				A_ :		str						):


       '''simple docstring'''





       return text.split()






def 	snake_case_  (				A_ :		str						):


       '''simple docstring'''





       yield (time.time(), content)
       time.sleep(2						)
       yield (time.time(), content)







def 	snake_case_  (				):


       '''simple docstring'''





       with Pool(2						) as pool:
              _lowerCamelCase						:    Optional[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:
              _lowerCamelCase						:    Any         =			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:
              _lowerCamelCase						:    Any         =			[]
              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







"""simple docstring"""






from __future__ import annotations

from itertools import permutations
from random import randint
from timeit import repeat






def 	snake_case_  (				):


       '''simple docstring'''





       _lowerCamelCase						:    Optional[Any]         =			[randint(-10_00,    10_00						) for i in range(10						)]
       _lowerCamelCase						:    Tuple         =			randint(-50_00,    50_00						)
       return (arr, r)


lowerCAmelCase__      =    make_dataset()






def 	snake_case_  (				A_ :		list[int],    A_ :		int						):


       '''simple docstring'''





       for triplet in permutations(A_,    3						):
              if sum(A_						) == target:
                     return tuple(sorted(A_						)						)
       return (0, 0, 0)






def 	snake_case_  (				A_ :		list[int],    A_ :		int						):


       '''simple docstring'''





       arr.sort()
       _lowerCamelCase						:    Optional[Any]         =			len(A_						)
       for i in range(n - 1						):
              _lowerCamelCase      ,   _lowerCamelCase						:    int         =			i + 1, n - 1
              while left < right:
                     if arr[i] + arr[left] + arr[right] == target:
                            return (arr[i], arr[left], arr[right])
                     elif arr[i] + arr[left] + arr[right] < target:
                            left += 1
                     elif arr[i] + arr[left] + arr[right] > target:
                            right -= 1
       return (0, 0, 0)






def 	snake_case_  (				):


       '''simple docstring'''





       _lowerCamelCase						:    Tuple         =			'''
from __main__ import dataset, triplet_sum1, triplet_sum2
'''
       _lowerCamelCase						:    List[Any]         =			'''
triplet_sum1(*dataset)
'''
       _lowerCamelCase						:    str         =			'''
triplet_sum2(*dataset)
'''
       _lowerCamelCase						:    Optional[int]         =			repeat(setup=A_,    stmt=A_,    repeat=5,    number=1_00_00						)
       _lowerCamelCase						:    Union[str, Any]         =			repeat(setup=A_,    stmt=A_,    repeat=5,    number=1_00_00						)
       return (min(A_						), min(A_						))


if __name__ == "__main__":
   from doctest import testmod

   testmod()
   lowerCAmelCase__      =    solution_times()
   print(F"""The time for naive implementation is {times[0]}.""")
   print(F"""The time for optimized implementation is {times[1]}.""")


