




'''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'''







import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


class     _a						(			__a							,							unittest.TestCase				):
       __a       :  Tuple            =      ShapEPipeline
       __a       :  Tuple            =      ["""prompt"""]
       __a       :  Tuple            =      ["""prompt"""]
       __a       :  str            =      [
           """num_images_per_prompt""",
           """num_inference_steps""",
           """generator""",
           """latents""",
           """guidance_scale""",
           """frame_size""",
           """output_type""",
           """return_dict""",
       ]
       __a       :  Union[str, Any]            =      False
       @property
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           return 32
       @property
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           return 32
       @property
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           return self.time_input_dim * 4
       @property
       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           return 8
       @property
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )
           return tokenizer
       @property
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           torch.manual_seed(0       )
           UpperCAmelCase     =	CLIPTextConfig(
               bos_token_id=0     ,       eos_token_id=2     ,       hidden_size=self.text_embedder_hidden_size     ,       projection_dim=self.text_embedder_hidden_size     ,       intermediate_size=37     ,       layer_norm_eps=1E-05     ,       num_attention_heads=4     ,       num_hidden_layers=5     ,       pad_token_id=1     ,       vocab_size=1_000     ,       )
           return CLIPTextModelWithProjection(lowercase       )
       @property
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           torch.manual_seed(0       )

           UpperCAmelCase     =	{
               '''num_attention_heads''': 2,
               '''attention_head_dim''': 16,
               '''embedding_dim''': self.time_input_dim,
               '''num_embeddings''': 32,
               '''embedding_proj_dim''': self.text_embedder_hidden_size,
               '''time_embed_dim''': self.time_embed_dim,
               '''num_layers''': 1,
               '''clip_embed_dim''': self.time_input_dim * 2,
               '''additional_embeddings''': 0,
               '''time_embed_act_fn''': '''gelu''',
               '''norm_in_type''': '''layer''',
               '''encoder_hid_proj_type''': None,
               '''added_emb_type''': None,
           }

           UpperCAmelCase     =	PriorTransformer(**lowercase       )
           return model
       @property
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           torch.manual_seed(0       )

           UpperCAmelCase     =	{
               '''param_shapes''': (
                   (self.renderer_dim, 93),
                   (self.renderer_dim, 8),
                   (self.renderer_dim, 8),
                   (self.renderer_dim, 8),
               ),
               '''d_latent''': self.time_input_dim,
               '''d_hidden''': self.renderer_dim,
               '''n_output''': 12,
               '''background''': (
                   0.1,
                   0.1,
                   0.1,
               ),
           }
           UpperCAmelCase     =	ShapERenderer(**lowercase       )
           return model
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.dummy_prior
           UpperCAmelCase     =	self.dummy_text_encoder
           UpperCAmelCase     =	self.dummy_tokenizer
           UpperCAmelCase     =	self.dummy_renderer

           UpperCAmelCase     =	HeunDiscreteScheduler(
               beta_schedule='''exp'''     ,       num_train_timesteps=1_024     ,       prediction_type='''sample'''     ,       use_karras_sigmas=lowercase     ,       clip_sample=lowercase     ,       clip_sample_range=1.0     ,       )
           UpperCAmelCase     =	{
               '''prior''': prior,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''renderer''': renderer,
               '''scheduler''': scheduler,
           }

           return components
       def 					A   (			self		:			Dict     ,       lowercase		:			Optional[int]     ,       lowercase		:			Optional[int]=0       ):



           '''simple docstring'''

           if str(lowercase       ).startswith('''mps'''       ):
               UpperCAmelCase     =	torch.manual_seed(lowercase       )
           else:
               UpperCAmelCase     =	torch.Generator(device=lowercase       ).manual_seed(lowercase       )
           UpperCAmelCase     =	{
               '''prompt''': '''horse''',
               '''generator''': generator,
               '''num_inference_steps''': 1,
               '''frame_size''': 32,
               '''output_type''': '''np''',
           }
           return inputs
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           UpperCAmelCase     =	'''cpu'''

           UpperCAmelCase     =	self.get_dummy_components()

           UpperCAmelCase     =	self.pipeline_class(**lowercase       )
           UpperCAmelCase     =	pipe.to(lowercase       )

           pipe.set_progress_bar_config(disable=lowercase       )

           UpperCAmelCase     =	pipe(**self.get_dummy_inputs(lowercase       )       )
           UpperCAmelCase     =	output.images[0]
           UpperCAmelCase     =	image[0, -3:, -3:, -1]

           assert image.shape == (20, 32, 32, 3)

           UpperCAmelCase     =	np.array(
               [
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
               ]       )

           assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2
       def 					A   (			self		:			int       ):



           '''simple docstring'''

           self._test_inference_batch_consistent(batch_sizes=[1, 2]       )
       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           UpperCAmelCase     =	torch_device == '''cpu'''
           UpperCAmelCase     =	True

           self._test_inference_batch_single_identical(
               batch_size=2     ,       test_max_difference=lowercase     ,       relax_max_difference=lowercase     ,       )







       def 					A   (			self		:			Any       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_dummy_components()
           UpperCAmelCase     =	self.pipeline_class(**lowercase       )
           UpperCAmelCase     =	pipe.to(lowercase       )
           pipe.set_progress_bar_config(disable=lowercase       )

           UpperCAmelCase     =	1
           UpperCAmelCase     =	2

           UpperCAmelCase     =	self.get_dummy_inputs(lowercase       )

           for key in inputs.keys():
               if key in self.batch_params:
                   UpperCAmelCase     =	batch_size * [inputs[key]]

           UpperCAmelCase     =	pipe(**lowercase     ,       num_images_per_prompt=lowercase       )[0]

           assert images.shape[0] == batch_size * num_images_per_prompt






@slow
@require_torch_gpu
class     _a						(			unittest.TestCase				):
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()







       def 					A   (			self		:			int       ):



           '''simple docstring'''

           UpperCAmelCase     =	load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/shap_e/test_shap_e_np_out.npy'''       )
           UpperCAmelCase     =	ShapEPipeline.from_pretrained('''openai/shap-e'''       )
           UpperCAmelCase     =	pipe.to(lowercase       )
           pipe.set_progress_bar_config(disable=lowercase       )

           UpperCAmelCase     =	torch.Generator(device=lowercase       ).manual_seed(0       )

           UpperCAmelCase     =	pipe(
               '''a shark'''     ,       generator=lowercase     ,       guidance_scale=15.0     ,       num_inference_steps=64     ,       frame_size=64     ,       output_type='''np'''     ,       ).images[0]

           assert images.shape == (20, 64, 64, 3)

           assert_mean_pixel_difference(lowercase     ,       lowercase       )




