






from typing import Any, Callable, Dict, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


SCREAMING_SNAKE_CASE__     =       'CompVis/stable-diffusion-v1-1'
SCREAMING_SNAKE_CASE__     =       'CompVis/stable-diffusion-v1-2'
SCREAMING_SNAKE_CASE__     =       'CompVis/stable-diffusion-v1-3'
SCREAMING_SNAKE_CASE__     =       'CompVis/stable-diffusion-v1-4'






class     a_						(      lowerCamelCase    ):

  def __init__(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = True      ,		)  ->				int:



        """simple docstring"""






        super()._init_()

        UpperCamelCase      = StableDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = StableDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = StableDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = StableDiffusionPipeline(
            vae=_SCREAMING_SNAKE_CASE      ,		text_encoder=_SCREAMING_SNAKE_CASE      ,		tokenizer=_SCREAMING_SNAKE_CASE      ,		unet=_SCREAMING_SNAKE_CASE      ,		scheduler=_SCREAMING_SNAKE_CASE      ,		safety_checker=_SCREAMING_SNAKE_CASE      ,		feature_extractor=_SCREAMING_SNAKE_CASE      ,		requires_safety_checker=_SCREAMING_SNAKE_CASE      ,		)

        self.register_modules(pipelinea=self.pipea      ,		pipelinea=self.pipea      ,		pipelinea=self.pipea      ,		pipelinea=self.pipea				)

  @property
  def   A__						(				self				)  ->				Dict[str, Any]:



        """simple docstring"""






        return {k: getattr(self      ,		_SCREAMING_SNAKE_CASE				) for k in self.config.keys() if not k.startswith("""_"""				)}

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE = "auto"				)  ->				Any:



        """simple docstring"""






        if slice_size == "auto":
              # half the attention head size is usually a good trade-off between
              # speed and memory
              UpperCamelCase      = self.unet.config.attention_head_dim // 2
        self.unet.set_attention_slice(_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				Optional[int]:



        """simple docstring"""






        self.enable_attention_slicing(_SCREAMING_SNAKE_CASE				)

  @torch.no_grad()
  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 50      ,		_SCREAMING_SNAKE_CASE = 7.5      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		_SCREAMING_SNAKE_CASE = 0.0      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = "pil"      ,		_SCREAMING_SNAKE_CASE = True      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		**_SCREAMING_SNAKE_CASE      ,		)  ->				List[Any]:



        """simple docstring"""






        return self.pipea(
            prompt=_SCREAMING_SNAKE_CASE      ,		height=_SCREAMING_SNAKE_CASE      ,		width=_SCREAMING_SNAKE_CASE      ,		num_inference_steps=_SCREAMING_SNAKE_CASE      ,		guidance_scale=_SCREAMING_SNAKE_CASE      ,		negative_prompt=_SCREAMING_SNAKE_CASE      ,		num_images_per_prompt=_SCREAMING_SNAKE_CASE      ,		eta=_SCREAMING_SNAKE_CASE      ,		generator=_SCREAMING_SNAKE_CASE      ,		latents=_SCREAMING_SNAKE_CASE      ,		output_type=_SCREAMING_SNAKE_CASE      ,		return_dict=_SCREAMING_SNAKE_CASE      ,		callback=_SCREAMING_SNAKE_CASE      ,		callback_steps=_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE      ,		)

  @torch.no_grad()
  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 50      ,		_SCREAMING_SNAKE_CASE = 7.5      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		_SCREAMING_SNAKE_CASE = 0.0      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = "pil"      ,		_SCREAMING_SNAKE_CASE = True      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		**_SCREAMING_SNAKE_CASE      ,		)  ->				str:



        """simple docstring"""






        return self.pipea(
            prompt=_SCREAMING_SNAKE_CASE      ,		height=_SCREAMING_SNAKE_CASE      ,		width=_SCREAMING_SNAKE_CASE      ,		num_inference_steps=_SCREAMING_SNAKE_CASE      ,		guidance_scale=_SCREAMING_SNAKE_CASE      ,		negative_prompt=_SCREAMING_SNAKE_CASE      ,		num_images_per_prompt=_SCREAMING_SNAKE_CASE      ,		eta=_SCREAMING_SNAKE_CASE      ,		generator=_SCREAMING_SNAKE_CASE      ,		latents=_SCREAMING_SNAKE_CASE      ,		output_type=_SCREAMING_SNAKE_CASE      ,		return_dict=_SCREAMING_SNAKE_CASE      ,		callback=_SCREAMING_SNAKE_CASE      ,		callback_steps=_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE      ,		)

  @torch.no_grad()
  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 50      ,		_SCREAMING_SNAKE_CASE = 7.5      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		_SCREAMING_SNAKE_CASE = 0.0      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = "pil"      ,		_SCREAMING_SNAKE_CASE = True      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		**_SCREAMING_SNAKE_CASE      ,		)  ->				Optional[Any]:



        """simple docstring"""






        return self.pipea(
            prompt=_SCREAMING_SNAKE_CASE      ,		height=_SCREAMING_SNAKE_CASE      ,		width=_SCREAMING_SNAKE_CASE      ,		num_inference_steps=_SCREAMING_SNAKE_CASE      ,		guidance_scale=_SCREAMING_SNAKE_CASE      ,		negative_prompt=_SCREAMING_SNAKE_CASE      ,		num_images_per_prompt=_SCREAMING_SNAKE_CASE      ,		eta=_SCREAMING_SNAKE_CASE      ,		generator=_SCREAMING_SNAKE_CASE      ,		latents=_SCREAMING_SNAKE_CASE      ,		output_type=_SCREAMING_SNAKE_CASE      ,		return_dict=_SCREAMING_SNAKE_CASE      ,		callback=_SCREAMING_SNAKE_CASE      ,		callback_steps=_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE      ,		)

  @torch.no_grad()
  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 50      ,		_SCREAMING_SNAKE_CASE = 7.5      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		_SCREAMING_SNAKE_CASE = 0.0      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = "pil"      ,		_SCREAMING_SNAKE_CASE = True      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		**_SCREAMING_SNAKE_CASE      ,		)  ->				Union[str, Any]:



        """simple docstring"""






        return self.pipea(
            prompt=_SCREAMING_SNAKE_CASE      ,		height=_SCREAMING_SNAKE_CASE      ,		width=_SCREAMING_SNAKE_CASE      ,		num_inference_steps=_SCREAMING_SNAKE_CASE      ,		guidance_scale=_SCREAMING_SNAKE_CASE      ,		negative_prompt=_SCREAMING_SNAKE_CASE      ,		num_images_per_prompt=_SCREAMING_SNAKE_CASE      ,		eta=_SCREAMING_SNAKE_CASE      ,		generator=_SCREAMING_SNAKE_CASE      ,		latents=_SCREAMING_SNAKE_CASE      ,		output_type=_SCREAMING_SNAKE_CASE      ,		return_dict=_SCREAMING_SNAKE_CASE      ,		callback=_SCREAMING_SNAKE_CASE      ,		callback_steps=_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE      ,		)


  @torch.no_grad()
  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 512      ,		_SCREAMING_SNAKE_CASE = 50      ,		_SCREAMING_SNAKE_CASE = 7.5      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		_SCREAMING_SNAKE_CASE = 0.0      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = "pil"      ,		_SCREAMING_SNAKE_CASE = True      ,		_SCREAMING_SNAKE_CASE = None      ,		_SCREAMING_SNAKE_CASE = 1      ,		**_SCREAMING_SNAKE_CASE      ,		)  ->				int:



        """simple docstring"""






        UpperCamelCase      = """cuda""" if torch.cuda.is_available() else """cpu"""
        self.to(_SCREAMING_SNAKE_CASE				)

        # Checks if the height and width are divisible by 8 or not
        if height % 8 != 0 or width % 8 != 0:
              raise ValueError(F"`height` and `width` must be divisible by 8 but are {height} and {width}."				)

        # Get first result from Stable Diffusion Checkpoint v1.1
        UpperCamelCase      = self.textaimg_sda_a(
            prompt=_SCREAMING_SNAKE_CASE      ,		height=_SCREAMING_SNAKE_CASE      ,		width=_SCREAMING_SNAKE_CASE      ,		num_inference_steps=_SCREAMING_SNAKE_CASE      ,		guidance_scale=_SCREAMING_SNAKE_CASE      ,		negative_prompt=_SCREAMING_SNAKE_CASE      ,		num_images_per_prompt=_SCREAMING_SNAKE_CASE      ,		eta=_SCREAMING_SNAKE_CASE      ,		generator=_SCREAMING_SNAKE_CASE      ,		latents=_SCREAMING_SNAKE_CASE      ,		output_type=_SCREAMING_SNAKE_CASE      ,		return_dict=_SCREAMING_SNAKE_CASE      ,		callback=_SCREAMING_SNAKE_CASE      ,		callback_steps=_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE      ,		)

        # Get first result from Stable Diffusion Checkpoint v1.2
        UpperCamelCase      = self.textaimg_sda_a(
            prompt=_SCREAMING_SNAKE_CASE      ,		height=_SCREAMING_SNAKE_CASE      ,		width=_SCREAMING_SNAKE_CASE      ,		num_inference_steps=_SCREAMING_SNAKE_CASE      ,		guidance_scale=_SCREAMING_SNAKE_CASE      ,		negative_prompt=_SCREAMING_SNAKE_CASE      ,		num_images_per_prompt=_SCREAMING_SNAKE_CASE      ,		eta=_SCREAMING_SNAKE_CASE      ,		generator=_SCREAMING_SNAKE_CASE      ,		latents=_SCREAMING_SNAKE_CASE      ,		output_type=_SCREAMING_SNAKE_CASE      ,		return_dict=_SCREAMING_SNAKE_CASE      ,		callback=_SCREAMING_SNAKE_CASE      ,		callback_steps=_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE      ,		)

        # Get first result from Stable Diffusion Checkpoint v1.3
        UpperCamelCase      = self.textaimg_sda_a(
            prompt=_SCREAMING_SNAKE_CASE      ,		height=_SCREAMING_SNAKE_CASE      ,		width=_SCREAMING_SNAKE_CASE      ,		num_inference_steps=_SCREAMING_SNAKE_CASE      ,		guidance_scale=_SCREAMING_SNAKE_CASE      ,		negative_prompt=_SCREAMING_SNAKE_CASE      ,		num_images_per_prompt=_SCREAMING_SNAKE_CASE      ,		eta=_SCREAMING_SNAKE_CASE      ,		generator=_SCREAMING_SNAKE_CASE      ,		latents=_SCREAMING_SNAKE_CASE      ,		output_type=_SCREAMING_SNAKE_CASE      ,		return_dict=_SCREAMING_SNAKE_CASE      ,		callback=_SCREAMING_SNAKE_CASE      ,		callback_steps=_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE      ,		)

        # Get first result from Stable Diffusion Checkpoint v1.4
        UpperCamelCase      = self.textaimg_sda_a(
            prompt=_SCREAMING_SNAKE_CASE      ,		height=_SCREAMING_SNAKE_CASE      ,		width=_SCREAMING_SNAKE_CASE      ,		num_inference_steps=_SCREAMING_SNAKE_CASE      ,		guidance_scale=_SCREAMING_SNAKE_CASE      ,		negative_prompt=_SCREAMING_SNAKE_CASE      ,		num_images_per_prompt=_SCREAMING_SNAKE_CASE      ,		eta=_SCREAMING_SNAKE_CASE      ,		generator=_SCREAMING_SNAKE_CASE      ,		latents=_SCREAMING_SNAKE_CASE      ,		output_type=_SCREAMING_SNAKE_CASE      ,		return_dict=_SCREAMING_SNAKE_CASE      ,		callback=_SCREAMING_SNAKE_CASE      ,		callback_steps=_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE      ,		)

        # Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
        return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]				)








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







def    lowercase__			(				__UpperCamelCase   )->			Tuple:  # picklable for multiprocessing
      return i + 1






@dataclass
class     a_						:
  lowercase							=				42
  lowercase							=				42






class     a_						(      lowerCamelCase    ):

  def   A__						(				self				)  ->				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(_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				)

        UpperCamelCase      = 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				)

        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(_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 _SCREAMING_SNAKE_CASE				: x + 1      ,		_SCREAMING_SNAKE_CASE      ,		num_proc=_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				Dict:



        """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(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)				)      ,		_SCREAMING_SNAKE_CASE				)


  def   A__						(				self				)  ->				List[str]:



        """simple docstring"""






        class     a_						:
          lowercase							=				"""bar"""


        UpperCamelCase      = 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    lowercase__			(				__UpperCamelCase		,						__UpperCamelCase		,						__UpperCamelCase   )->			List[str]:
      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(__UpperCamelCase   )}
            UpperCamelCase      = map_nested(lambda __UpperCamelCase   : x + 10		,						__UpperCamelCase		,						num_proc=__UpperCamelCase		,						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_						(      lowerCamelCase    ):

  @require_tf
  def   A__						(				self				)  ->				Any:



        """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(_SCREAMING_SNAKE_CASE				).numpy()

        with temp_seed(42      ,		set_tensorflow=_SCREAMING_SNAKE_CASE				):
              UpperCamelCase      = gen_random_output()
        with temp_seed(42      ,		set_tensorflow=_SCREAMING_SNAKE_CASE				):
              UpperCamelCase      = gen_random_output()
        UpperCamelCase      = gen_random_output()

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

  @require_torch
  def   A__						(				self				)  ->				int:



        """simple docstring"""






        import torch

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

        with temp_seed(42      ,		set_pytorch=_SCREAMING_SNAKE_CASE				):
              UpperCamelCase      = gen_random_output()
        with temp_seed(42      ,		set_pytorch=_SCREAMING_SNAKE_CASE				):
              UpperCamelCase      = gen_random_output()
        UpperCamelCase      = gen_random_output()

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


  def   A__						(				self				)  ->				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(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
        self.assertGreater(np.abs(outa - outa				).sum()      ,		0				)







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







def    lowercase__			(				)->			Union[str, Any]:
      UpperCamelCase      = A(x=1		,						y="""foobar"""   )
      UpperCamelCase      = {"""x""": 1, """y""": """foobar"""}
      assert asdict(__UpperCamelCase   ) == 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(__UpperCamelCase   ) == expected_output

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







def    lowercase__			(				__UpperCamelCase   )->			List[Any]:
      return text.split()







def    lowercase__			(				__UpperCamelCase   )->			List[str]:
      yield (time.time(), content)
      time.sleep(2   )
      yield (time.time(), content)







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

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

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