





'''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    a__							(							lowercase   :	Optional[int] )						->						Union[str, Any]:  # picklable for multiprocessing





     """simple docstring"""

     return x.sum()







def    a__							(							lowercase   :	Union[str, Any] )						->						List[Any]:  # picklable for multiprocessing





     """simple docstring"""

     return i + 1
@dataclass
class 							__lowerCAmelCase	:






       """simple docstring"""
       _snake_case      :	int
       _snake_case      :	str

class 							__lowerCAmelCase	(       __magic_name__					):






       """simple docstring"""





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

            '''simple docstring'''




            _UpperCamelCase							       =			{}
            _UpperCamelCase							       =			[]
            _UpperCamelCase							       =			1
            _UpperCamelCase							       =			[1, 2]
            _UpperCamelCase							       =			{'''a''': 1, '''b''': 2}
            _UpperCamelCase							       =			{'''a''': [1, 2], '''b''': [3, 4]}
            _UpperCamelCase							       =			{'''a''': {'''1''': 1}, '''b''': 2}
            _UpperCamelCase							       =			{'''a''': 1, '''b''': 2, '''c''': 3, '''d''': 4}
            _UpperCamelCase							       =			{}
            _UpperCamelCase							       =			[]
            _UpperCamelCase							       =			2
            _UpperCamelCase							       =			[2, 3]
            _UpperCamelCase							       =			{'''a''': 2, '''b''': 3}
            _UpperCamelCase							       =			{'''a''': [2, 3], '''b''': [4, 5]}
            _UpperCamelCase							       =			{'''a''': {'''1''': 2}, '''b''': 3}
            _UpperCamelCase							       =			{'''a''': 2, '''b''': 3, '''c''': 4, '''d''': 5}
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__	)			,					lowerCAmelCase__	)

            _UpperCamelCase							       =			2
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)			,					lowerCAmelCase__	)

            _UpperCamelCase							       =			{'''a''': np.eye(2	), '''b''': np.zeros(3	), '''c''': np.ones(2	)}
            _UpperCamelCase							       =			{'''a''': 2, '''b''': 0, '''c''': 2}
            _UpperCamelCase							       =			{
                '''a''': np.eye(2	).astype(lowerCAmelCase__	),
                '''b''': np.zeros(3	).astype(lowerCAmelCase__	),
                '''c''': np.ones(2	).astype(lowerCAmelCase__	),
            }
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					map_numpy=lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(
                {k: v.tolist() for k, v in map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					map_numpy=lowerCAmelCase__	).items()}			,					{k: v.tolist() for k, v in expected_map_nested_sna_int.items()}			,					)
            self.assertEqual(map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					map_numpy=lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)			,					lowerCAmelCase__	)
            self.assertEqual(
                {k: v.tolist() for k, v in map_nested(lowerCAmelCase__			,					lowerCAmelCase__			,					map_numpy=lowerCAmelCase__			,					num_proc=lowerCAmelCase__	).items()}			,					{k: v.tolist() for k, v in expected_map_nested_sna_int.items()}			,					)
            with self.assertRaises(lowerCAmelCase__	):  # can't pickle a local lambda
                 map_nested(lambda lowerCAmelCase__	: x + 1			,					lowerCAmelCase__			,					num_proc=lowerCAmelCase__	)





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

            '''simple docstring'''




            _UpperCamelCase							       =			{'''a''': 1, '''b''': 2}
            _UpperCamelCase							       =			{'''a''': 3, '''b''': 4}
            _UpperCamelCase							       =			{'''a''': 5, '''b''': 6}
            _UpperCamelCase							       =			sorted([('''a''', (1, 3, 5)), ('''b''', (2, 4, 6))]	)
            self.assertEqual(sorted(zip_dict(lowerCAmelCase__			,					lowerCAmelCase__			,					lowerCAmelCase__	)	)			,					lowerCAmelCase__	)







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

            '''simple docstring'''




            class 							__lowerCAmelCase	:






                   """simple docstring"""
                   _snake_case      :	Optional[Any]									=       'bar'

            _UpperCamelCase							       =			Foo()
            self.assertEqual(foo.my_attr			,					'''bar'''	)
            with temporary_assignment(lowerCAmelCase__			,					'''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    a__							(							lowercase   :	Dict,   lowercase   :	Any,   lowercase   :	List[str] )						->						List[Any]:





     """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:
          _UpperCamelCase							       =			{F"""{i}""": i for i in range(lowercase )}
          _UpperCamelCase							       =			map_nested(lambda lowercase : x + 10,   lowercase,   num_proc=lowercase,   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	(       __magic_name__					):






       """simple docstring"""





       @require_tf
       def snake_case__		(				self  :						Union[str, Any]	)       ->	int:

            '''simple docstring'''




            import tensorflow as tf
            from tensorflow.keras import layers

            _UpperCamelCase							       =			layers.Dense(2	)

            def gen_random_output():
                 _UpperCamelCase							       =			tf.random.uniform((1, 3)	)
                 return model(lowerCAmelCase__	).numpy()

            with temp_seed(42			,					set_tensorflow=lowerCAmelCase__	):
                 _UpperCamelCase							       =			gen_random_output()
            with temp_seed(42			,					set_tensorflow=lowerCAmelCase__	):
                 _UpperCamelCase							       =			gen_random_output()
            _UpperCamelCase							       =			gen_random_output()

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





       @require_torch
       def snake_case__		(				self  :						Dict	)       ->	Optional[int]:

            '''simple docstring'''




            import torch

            def gen_random_output():
                 _UpperCamelCase							       =			torch.nn.Linear(3			,					2	)
                 _UpperCamelCase							       =			torch.rand(1			,					3	)
                 return model(lowerCAmelCase__	).detach().numpy()

            with temp_seed(42			,					set_pytorch=lowerCAmelCase__	):
                 _UpperCamelCase							       =			gen_random_output()
            with temp_seed(42			,					set_pytorch=lowerCAmelCase__	):
                 _UpperCamelCase							       =			gen_random_output()
            _UpperCamelCase							       =			gen_random_output()

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







       def snake_case__		(				self  :						Optional[int]	)       ->	Dict:

            '''simple docstring'''




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

            with temp_seed(42	):
                 _UpperCamelCase							       =			gen_random_output()
            with temp_seed(42	):
                 _UpperCamelCase							       =			gen_random_output()
            _UpperCamelCase							       =			gen_random_output()

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







@pytest.mark.parametrize('''input_data''',   [{}] )
def    a__							(							lowercase   :	List[str] )						->						Any:





     """simple docstring"""

     _UpperCamelCase							       =			NestedDataStructure(lowercase ).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    a__							(							lowercase   :	str,   lowercase   :	Any )						->						str:





     """simple docstring"""

     _UpperCamelCase							       =			NestedDataStructure(lowercase ).flatten()
     assert output == expected_output







def    a__							(							)						->						Optional[int]:





     """simple docstring"""

     _UpperCamelCase							       =			A(x=1,   y='''foobar''' )
     _UpperCamelCase							       =			{'''x''': 1, '''y''': '''foobar'''}
     assert asdict(lowercase ) == expected_output

     _UpperCamelCase							       =			{'''a''': {'''b''': A(x=10,   y='''foo''' )}, '''c''': [A(x=20,   y='''bar''' )]}
     _UpperCamelCase							       =			{'''a''': {'''b''': {'''x''': 10, '''y''': '''foo'''}}, '''c''': [{'''x''': 20, '''y''': '''bar'''}]}
     assert asdict(lowercase ) == expected_output

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







def    a__							(							lowercase   :	str )						->						str:





     """simple docstring"""

     return text.split()







def    a__							(							lowercase   :	List[str] )						->						List[Any]:





     """simple docstring"""

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







def    a__							(							)						->						str:





     """simple docstring"""

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

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

     # check that we get items as fast as possible
     with Pool(2 ) as pool:
          _UpperCamelCase							       =			[]
          for yield_time, content in iflatmap_unordered(
              lowercase,   _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(lowercase )
          assert out.count('''a''' ) == 2
          assert out.count('''b''' ) == 2
          assert len(lowercase ) == 4










'''simple docstring'''

def    a__							(							lowercase   :	str )						->						int:





     """simple docstring"""

     assert column_title.isupper()
     _UpperCamelCase							       =			0
     _UpperCamelCase							       =			len(lowercase ) - 1
     _UpperCamelCase							       =			0

     while index >= 0:
          _UpperCamelCase							       =			(ord(column_title[index] ) - 64) * pow(26,   lowercase )
          answer += value
          power += 1
          index -= 1

     return answer


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

   testmod()



