


from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching
def 				__lowerCamelCase						( ):




      """simple docstring"""





      import os as original_os
      from os import path as original_path
      from os import rename as original_rename
      from os.path import dirname as original_dirname
      from os.path import join as original_join

      assert _test_patching.os is original_os
      assert _test_patching.path is original_path
      assert _test_patching.join is original_join

      assert _test_patching.renamed_os is original_os
      assert _test_patching.renamed_path is original_path
      assert _test_patching.renamed_join is original_join

      a						:Optional[int] 							=       '''__test_patch_submodule_mock__'''
      with patch_submodule(_test_patching ,  '''os.path.join''' ,  UpperCAmelCase_						):
            # Every way to access os.path.join must be patched, and the rest must stay untouched

            # check os.path.join
            assert isinstance(_test_patching.os ,  _PatchedModuleObj						)
            assert isinstance(_test_patching.os.path ,  _PatchedModuleObj						)
            assert _test_patching.os.path.join is mock

            # check path.join
            assert isinstance(_test_patching.path ,  _PatchedModuleObj						)
            assert _test_patching.path.join is mock

            # check join
            assert _test_patching.join is mock

            # check that the other attributes are untouched
            assert _test_patching.os.rename is original_rename
            assert _test_patching.path.dirname is original_dirname
            assert _test_patching.os.path.dirname is original_dirname

            # Even renamed modules or objects must be patched

            # check renamed_os.path.join
            assert isinstance(_test_patching.renamed_os ,  _PatchedModuleObj						)
            assert isinstance(_test_patching.renamed_os.path ,  _PatchedModuleObj						)
            assert _test_patching.renamed_os.path.join is mock

            # check renamed_path.join
            assert isinstance(_test_patching.renamed_path ,  _PatchedModuleObj						)
            assert _test_patching.renamed_path.join is mock

            # check renamed_join
            assert _test_patching.renamed_join is mock

            # check that the other attributes are untouched
            assert _test_patching.renamed_os.rename is original_rename
            assert _test_patching.renamed_path.dirname is original_dirname
            assert _test_patching.renamed_os.path.dirname is original_dirname

      # check that everthing is back to normal when the patch is over

      assert _test_patching.os is original_os
      assert _test_patching.path is original_path
      assert _test_patching.join is original_join

      assert _test_patching.renamed_os is original_os
      assert _test_patching.renamed_path is original_path
      assert _test_patching.renamed_join is original_join
def 				__lowerCamelCase						( ):




      """simple docstring"""





      assert _test_patching.open is open

      a						:Dict 							=       '''__test_patch_submodule_builtin_mock__'''
      # _test_patching has "open" in its globals
      assert _test_patching.open is open
      with patch_submodule(_test_patching ,  '''open''' ,  UpperCAmelCase_						):
            assert _test_patching.open is mock

      # check that everthing is back to normal when the patch is over

      assert _test_patching.open is open
def 				__lowerCamelCase						( ):




      """simple docstring"""





      a						:Any 							=       '''__test_patch_submodule_missing_mock__'''
      with patch_submodule(_test_patching ,  '''pandas.read_csv''' ,  UpperCAmelCase_						):
            pass
def 				__lowerCamelCase						( ):




      """simple docstring"""





      a						:Any 							=       '''__test_patch_submodule_missing_builtin_mock__'''
      # _test_patching doesn't have "len" in its globals
      assert getattr(_test_patching ,  '''len''' ,  UpperCAmelCase_						) is None
      with patch_submodule(_test_patching ,  '''len''' ,  UpperCAmelCase_						):
            assert _test_patching.len is mock
      assert _test_patching.len is len
def 				__lowerCamelCase						( ):




      """simple docstring"""





      a						:Tuple 							=       '''__test_patch_submodule_start_and_stop_mock__'''
      a						:Any 							=       patch_submodule(_test_patching ,  '''open''' ,  UpperCAmelCase_						)
      assert _test_patching.open is open
      patch.start()
      assert _test_patching.open is mock
      patch.stop()
      assert _test_patching.open is open
def 				__lowerCamelCase						( ):




      """simple docstring"""





      from os import rename as original_rename
      from os.path import dirname as original_dirname
      from os.path import join as original_join

      a						:Dict 							=       '''__test_patch_submodule_successive_join__'''
      a						:List[str] 							=       '''__test_patch_submodule_successive_dirname__'''
      a						:Any 							=       '''__test_patch_submodule_successive_rename__'''
      assert _test_patching.os.path.join is original_join
      assert _test_patching.os.path.dirname is original_dirname
      assert _test_patching.os.rename is original_rename

      with patch_submodule(_test_patching ,  '''os.path.join''' ,  UpperCAmelCase_						):
            with patch_submodule(_test_patching ,  '''os.rename''' ,  UpperCAmelCase_						):
                  with patch_submodule(_test_patching ,  '''os.path.dirname''' ,  UpperCAmelCase_						):
                        assert _test_patching.os.path.join is mock_join
                        assert _test_patching.os.path.dirname is mock_dirname
                        assert _test_patching.os.rename is mock_rename

    # try another order
      with patch_submodule(_test_patching ,  '''os.rename''' ,  UpperCAmelCase_						):
            with patch_submodule(_test_patching ,  '''os.path.join''' ,  UpperCAmelCase_						):
                  with patch_submodule(_test_patching ,  '''os.path.dirname''' ,  UpperCAmelCase_						):
                        assert _test_patching.os.path.join is mock_join
                        assert _test_patching.os.path.dirname is mock_dirname
                        assert _test_patching.os.rename is mock_rename

      assert _test_patching.os.path.join is original_join
      assert _test_patching.os.path.dirname is original_dirname
      assert _test_patching.os.rename is original_rename






def 				__lowerCamelCase						( ):




      """simple docstring"""





      a						:Tuple 							=       '''__test_patch_submodule_doesnt_exist_mock__'''
      with patch_submodule(_test_patching ,  '''__module_that_doesn_exist__.__attribute_that_doesn_exist__''' ,  UpperCAmelCase_						):
            pass
      with patch_submodule(_test_patching ,  '''os.__attribute_that_doesn_exist__''' ,  UpperCAmelCase_						):
            pass










from __future__ import annotations

from itertools import permutations
from random import randint
from timeit import repeat
def 		UpperCamelCase	(   )	->     tuple[list[int], int]:
   UpperCamelCase    :  int							=	[randint(-1000       ,     1000	) for i in range(10	)]
   UpperCamelCase    :  Dict							=	randint(-5000       ,     5000	)
   return (arr, r)


__UpperCAmelCase          =       make_dataset()
def 		UpperCamelCase	(   snake_case__       :    list[int]       ,     snake_case__       :    int	)	->     tuple[int, ...]:
   for triplet in permutations(snake_case__       ,     3	):
      if sum(snake_case__	) == target:
         return tuple(sorted(snake_case__	)	)
   return (0, 0, 0)
def 		UpperCamelCase	(   snake_case__       :    list[int]       ,     snake_case__       :    int	)	->     tuple[int, int, int]:
   arr.sort()
   UpperCamelCase    :  List[str]							=	len(snake_case__	)
   for i in range(n - 1	):
      UpperCamelCase	,     UpperCamelCase    :  Optional[Any]							=	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 		UpperCamelCase	(   )	->     tuple[float, float]:
   UpperCamelCase    :  Any							=	'\nfrom __main__ import dataset, triplet_sum1, triplet_sum2\n'
   UpperCamelCase    :  Optional[Any]							=	'\ntriplet_sum1(*dataset)\n'
   UpperCamelCase    :  Dict							=	'\ntriplet_sum2(*dataset)\n'
   UpperCamelCase    :  Optional[int]							=	repeat(setup=snake_case__       ,     stmt=snake_case__       ,     repeat=5       ,     number=10000	)
   UpperCamelCase    :  Any							=	repeat(setup=snake_case__       ,     stmt=snake_case__       ,     repeat=5       ,     number=10000	)
   return (min(snake_case__	), min(snake_case__	))


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

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



