




'''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			:							int  ):  # picklable for multiprocessing
    return x.sum()





def 		snake_case_							(_a			:							Tuple  ):  # picklable for multiprocessing
    return i + 1


@dataclass
class     _a						:
       __a       :  int
       __a       :  str






class     _a						(			__a				):
       def 					A   (			self		:			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(lowercase     ,       lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase       )     ,       lowercase       )

           UpperCAmelCase     =	2
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       num_proc=lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       num_proc=lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       num_proc=lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       num_proc=lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       num_proc=lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       num_proc=lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       num_proc=lowercase       )     ,       lowercase       )
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       num_proc=lowercase       )     ,       lowercase       )

           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(lowercase       ),
               '''b''': np.zeros(3       ).astype(lowercase       ),
               '''c''': np.ones(2       ).astype(lowercase       ),
           }
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       map_numpy=lowercase       )     ,       lowercase       )
           self.assertEqual(
               {k: v.tolist() for k, v in map_nested(lowercase     ,       lowercase     ,       map_numpy=lowercase       ).items()}     ,       {k: v.tolist() for k, v in expected_map_nested_sna_int.items()}     ,       )
           self.assertEqual(map_nested(lowercase     ,       lowercase     ,       map_numpy=lowercase     ,       num_proc=lowercase       )     ,       lowercase       )
           self.assertEqual(
               {k: v.tolist() for k, v in map_nested(lowercase     ,       lowercase     ,       map_numpy=lowercase     ,       num_proc=lowercase       ).items()}     ,       {k: v.tolist() for k, v in expected_map_nested_sna_int.items()}     ,       )
           with self.assertRaises(lowercase       ):  # can't pickle a local lambda
               map_nested(lambda lowercase       : x + 1     ,       lowercase     ,       num_proc=lowercase       )
       def 					A   (			self		:			str       ):



           '''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(lowercase     ,       lowercase     ,       lowercase       )       )     ,       lowercase       )







       def 					A   (			self		:			str       ):



           '''simple docstring'''

           class     _a						:
                  __a       :  int            =      """bar"""






           UpperCAmelCase     =	Foo()
           self.assertEqual(foo.my_attr     ,       '''bar'''       )
           with temporary_assignment(lowercase     ,       '''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),
        (1_6, 1_6, 1_6),
        (1_6, 1_7, 1_6),
        (1_7, 1_6, 1_6),
    ]					,     )
def 		snake_case_							(_a			:							Any					,     _a			:							Union[str, Any]					,     _a			:							int  ):
    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(_a  )}
        UpperCAmelCase     =	map_nested(lambda _a  : x + 1_0					,     _a					,     num_proc=_a					,     parallel_min_length=1_6  )
        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     _a						(			__a				):
       @require_tf
       def 					A   (			self		:			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(lowercase       ).numpy()

           with temp_seed(42     ,       set_tensorflow=lowercase       ):
               UpperCAmelCase     =	gen_random_output()
           with temp_seed(42     ,       set_tensorflow=lowercase       ):
               UpperCAmelCase     =	gen_random_output()
           UpperCAmelCase     =	gen_random_output()

           np.testing.assert_equal(lowercase     ,       lowercase       )
           self.assertGreater(np.abs(outa - outa       ).sum()     ,       0       )
       @require_torch
       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           import torch

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

           with temp_seed(42     ,       set_pytorch=lowercase       ):
               UpperCAmelCase     =	gen_random_output()
           with temp_seed(42     ,       set_pytorch=lowercase       ):
               UpperCAmelCase     =	gen_random_output()
           UpperCAmelCase     =	gen_random_output()

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







       def 					A   (			self		:			Any       ):



           '''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(lowercase     ,       lowercase       )
           self.assertGreater(np.abs(outa - outa       ).sum()     ,       0       )






@pytest.mark.parametrize('''input_data'''					,     [{}]  )
def 		snake_case_							(_a			:							Optional[Any]  ):
    UpperCAmelCase     =	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			:							Dict					,     _a			:							List[str]  ):
    UpperCAmelCase     =	NestedDataStructure(_a  ).flatten()
    assert output == expected_output





def 		snake_case_							():
    UpperCAmelCase     =	A(x=1					,     y='''foobar'''  )
    UpperCAmelCase     =	{'''x''': 1, '''y''': '''foobar'''}
    assert asdict(_a  ) == expected_output

    UpperCAmelCase     =	{'''a''': {'''b''': A(x=1_0					,     y='''foo'''  )}, '''c''': [A(x=2_0					,     y='''bar'''  )]}
    UpperCAmelCase     =	{'''a''': {'''b''': {'''x''': 1_0, '''y''': '''foo'''}}, '''c''': [{'''x''': 2_0, '''y''': '''bar'''}]}
    assert asdict(_a  ) == expected_output

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





def 		snake_case_							(_a			:							str  ):
    return text.split()





def 		snake_case_							(_a			:							Any  ):
    yield (time.time(), content)
    time.sleep(2  )
    yield (time.time(), content)







def 		snake_case_							():
    with Pool(2  ) as pool:
        UpperCAmelCase     =	list(iflatmap_unordered(_a					,     _split_text					,     kwargs_iterable=[{'''text''': '''hello there'''}] * 1_0  )  )
        assert out.count('''hello'''  ) == 1_0
        assert out.count('''there'''  ) == 1_0
        assert len(_a  ) == 2_0

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

    # check that we get items as fast as possible
    with Pool(2  ) as pool:
        UpperCAmelCase     =	[]
        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

import requests





def 		snake_case_							(_a			:							str  ):
    UpperCAmelCase     =	F"https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty"
    return requests.get(_a  ).json()





def 		snake_case_							(_a			:							int = 1_0  ):
    UpperCAmelCase     =	'''https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty'''
    UpperCAmelCase     =	requests.get(_a  ).json()[:max_stories]
    return [get_hackernews_story(_a  ) for story_id in story_ids]





def 		snake_case_							(_a			:							int = 1_0  ):
    UpperCAmelCase     =	hackernews_top_stories(_a  )
    return "\n".join('''* [{title}]({url})'''.format(**_a  ) for story in stories  )


if __name__ == "__main__":
   print(hackernews_top_stories_as_markdown())




