



from __future__ import annotations

import requests

lowercase_	       =			set(
    '''approved_at_utc approved_by author_flair_background_color
author_flair_css_class author_flair_richtext author_flair_template_id author_fullname
author_premium can_mod_post category clicked content_categories created_utc downs
edited gilded gildings hidden hide_score is_created_from_ads_ui is_meta
is_original_content is_reddit_media_domain is_video link_flair_css_class
link_flair_richtext link_flair_text link_flair_text_color media_embed mod_reason_title
name permalink pwls quarantine saved score secure_media secure_media_embed selftext
subreddit subreddit_name_prefixed subreddit_type thumbnail title top_awarded_type
total_awards_received ups upvote_ratio url user_reports'''.split()
)






def 					__lowerCAmelCase		(  __lowerCamelCase	:    str				,   __lowerCamelCase	:    int = 1				,   __lowerCamelCase	:    str = "new"				,   __lowerCamelCase	:    list | None = None	)  ->						dict:
					__lowerCAmelCase	   =wanted_data or []
					if invalid_search_terms := ", ".join(sorted(set(__lowerCamelCase	) - valid_terms	)	):
										__lowerCAmelCase	   =f"""Invalid search term: {invalid_search_terms}"""
										raise ValueError(__lowerCamelCase	)
					__lowerCAmelCase	   =requests.get(
					    f"""https://reddit.com/r/{subreddit}/{age}.json?limit={limit}"""				,   headers={"""User-agent""": """A random string"""}				,   )
					if response.status_code == 429:
										raise requests.HTTPError

					__lowerCAmelCase	   =response.json()
					if not wanted_data:
										return {id_: data["data"]["children"][id_] for id_ in range(__lowerCamelCase	)}

					__lowerCAmelCase	   ={}
					for id_ in range(__lowerCamelCase	):
										__lowerCAmelCase	   ={
										    item: data["""data"""]["""children"""][id_]["""data"""][item] for item in wanted_data
										}
					return data_dict


if __name__ == "__main__":
				# If you get Error 429, that means you are rate limited.Try after some time
				print(get_subreddit_data('''learnpython''', wanted_data=['''title''', '''url''', '''selftext''']))









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






def 					__lowerCAmelCase		(  __lowerCamelCase	:    Any	)  ->						Any:  # picklable for multiprocessing
					return i + 1






@dataclass
class 						__a :
	SCREAMING_SNAKE_CASE       =       42
	SCREAMING_SNAKE_CASE       =       42






class 						__a (     SCREAMING_SNAKE_CASE				):



	def 		UpperCamelCase							(						self							:    List[Any])->							Tuple:
						__lowerCAmelCase	   ={}
						__lowerCAmelCase	   =[]
						__lowerCAmelCase	   =1
						__lowerCAmelCase	   =[1, 2]
						__lowerCAmelCase	   ={"""a""": 1, """b""": 2}
						__lowerCAmelCase	   ={"""a""": [1, 2], """b""": [3, 4]}
						__lowerCAmelCase	   ={"""a""": {"""1""": 1}, """b""": 2}
						__lowerCAmelCase	   ={"""a""": 1, """b""": 2, """c""": 3, """d""": 4}
						__lowerCAmelCase	   ={}
						__lowerCAmelCase	   =[]
						__lowerCAmelCase	   =2
						__lowerCAmelCase	   =[2, 3]
						__lowerCAmelCase	   ={"""a""": 2, """b""": 3}
						__lowerCAmelCase	   ={"""a""": [2, 3], """b""": [4, 5]}
						__lowerCAmelCase	   ={"""a""": {"""1""": 2}, """b""": 3}
						__lowerCAmelCase	   ={"""a""": 2, """b""": 3, """c""": 4, """d""": 5}
						self.assertEqual(map_nested(snake_case_				,	snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_)				,	snake_case_)

						__lowerCAmelCase	   =2
						self.assertEqual(map_nested(snake_case_				,	snake_case_				,	num_proc=snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_				,	num_proc=snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_				,	num_proc=snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_				,	num_proc=snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_				,	num_proc=snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_				,	num_proc=snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_				,	num_proc=snake_case_)				,	snake_case_)
						self.assertEqual(map_nested(snake_case_				,	snake_case_				,	num_proc=snake_case_)				,	snake_case_)

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



	def 		UpperCamelCase							(						self							:    Any)->							int:
						__lowerCAmelCase	   ={"""a""": 1, """b""": 2}
						__lowerCAmelCase	   ={"""a""": 3, """b""": 4}
						__lowerCAmelCase	   ={"""a""": 5, """b""": 6}
						__lowerCAmelCase	   =sorted([("""a""", (1, 3, 5)), ("""b""", (2, 4, 6))])
						self.assertEqual(sorted(zip_dict(snake_case_				,	snake_case_				,	snake_case_))				,	snake_case_)



	def 		UpperCamelCase							(						self							:    Optional[Any])->							Optional[int]:






						class 						__a :
							SCREAMING_SNAKE_CASE       =       "bar"


						__lowerCAmelCase	   =Foo()
						self.assertEqual(foo.my_attr				,	"""bar""")
						with temporary_assignment(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	:    List[str]				,   __lowerCamelCase	:    Any				,   __lowerCamelCase	:    Dict	)  ->						Union[str, Any]:
					with patch("""datasets.utils.py_utils._single_map_nested"""	) as mock_single_map_nested, patch(
					    """datasets.parallel.parallel.Pool"""	) as mock_multiprocessing_pool:
										__lowerCAmelCase	   ={f"""{i}""": i for i in range(__lowerCamelCase	)}
										__lowerCAmelCase	   =map_nested(lambda __lowerCamelCase	: x + 10				,   __lowerCamelCase				,   num_proc=__lowerCamelCase				,   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 						__a (     SCREAMING_SNAKE_CASE				):



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

						__lowerCAmelCase	   =layers.Dense(2)

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

						with temp_seed(42				,	set_tensorflow=snake_case_):
											__lowerCAmelCase	   =gen_random_output()
						with temp_seed(42				,	set_tensorflow=snake_case_):
											__lowerCAmelCase	   =gen_random_output()
						__lowerCAmelCase	   =gen_random_output()

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



	@require_torch
	def 		UpperCamelCase							(						self							:    Dict)->							Dict:
						import torch

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

						with temp_seed(42				,	set_pytorch=snake_case_):
											__lowerCAmelCase	   =gen_random_output()
						with temp_seed(42				,	set_pytorch=snake_case_):
											__lowerCAmelCase	   =gen_random_output()
						__lowerCAmelCase	   =gen_random_output()

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



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

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

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






@pytest.mark.parametrize("""input_data"""				,   [{}]	)
def 					__lowerCAmelCase		(  __lowerCamelCase	:    List[str]	)  ->						List[str]:
					__lowerCAmelCase	   =NestedDataStructure(__lowerCamelCase	).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	:    List[Any]				,   __lowerCamelCase	:    int	)  ->						List[str]:
					__lowerCAmelCase	   =NestedDataStructure(__lowerCamelCase	).flatten()
					assert output == expected_output






def 					__lowerCAmelCase		(  )  ->						int:
					__lowerCAmelCase	   =A(x=1				,   y="""foobar"""	)
					__lowerCAmelCase	   ={"""x""": 1, """y""": """foobar"""}
					assert asdict(__lowerCamelCase	) == expected_output

					__lowerCAmelCase	   ={"""a""": {"""b""": A(x=10				,   y="""foo"""	)}, """c""": [A(x=20				,   y="""bar"""	)]}
					__lowerCAmelCase	   ={"""a""": {"""b""": {"""x""": 10, """y""": """foo"""}}, """c""": [{"""x""": 20, """y""": """bar"""}]}
					assert asdict(__lowerCamelCase	) == expected_output

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






def 					__lowerCAmelCase		(  __lowerCamelCase	:    str	)  ->						Dict:
					return text.split()






def 					__lowerCAmelCase		(  __lowerCamelCase	:    List[Any]	)  ->						Any:
					yield (time.time(), content)
					time.sleep(2	)
					yield (time.time(), content)






def 					__lowerCAmelCase		(  )  ->						Any:
					with Pool(2	) as pool:
										__lowerCAmelCase	   =list(iflatmap_unordered(__lowerCamelCase				,   _split_text				,   kwargs_iterable=[{"""text""": """hello there"""}] * 10	)	)
										assert out.count("""hello"""	) == 10
										assert out.count("""there"""	) == 10
										assert len(__lowerCamelCase	) == 20

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

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




