



'''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 	lowerCAmelCase_(    SCREAMING_SNAKE_CASE_						,			unittest.TestCase					):
  '''simple docstring'''




  __lowercase							:				str           =				ShapEPipeline
  __lowercase							:				int           =				['''prompt''']
  __lowercase							:				str           =				['''prompt''']
  __lowercase							:				str           =				[
      '''num_images_per_prompt''',
      '''num_inference_steps''',
      '''generator''',
      '''latents''',
      '''guidance_scale''',
      '''frame_size''',
      '''output_type''',
      '''return_dict''',
  ]
  __lowercase							:				Optional[int]           =				False




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Tuple:
      return 32




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Union[str, Any]:
      return 32




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Optional[int]:
      return self.time_input_dim * 4




  @property
  def 							UpperCAmelCase_     (   self				)   ->		List[Any]:
      return 8




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Dict:
      lowerCAmelCase__			:  Tuple											= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)
      return tokenizer




  @property
  def 							UpperCAmelCase_     (   self				)   ->		str:
      torch.manual_seed(0				)
      lowerCAmelCase__			:  Union[str, Any]											= 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=1000  ,)
      return CLIPTextModelWithProjection(__UpperCAmelCase				)




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Tuple:
      torch.manual_seed(0				)

      lowerCAmelCase__			:  Optional[Any]											= {
          """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,
      }

      lowerCAmelCase__			:  int											= PriorTransformer(**__UpperCAmelCase				)
      return model




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Any:
      torch.manual_seed(0				)

      lowerCAmelCase__			:  str											= {
          """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,
          ),
      }
      lowerCAmelCase__			:  Dict											= ShapERenderer(**__UpperCAmelCase				)
      return model




  def 							UpperCAmelCase_     (   self				)   ->		List[Any]:
      lowerCAmelCase__			:  Union[str, Any]											= self.dummy_prior
      lowerCAmelCase__			:  Any											= self.dummy_text_encoder
      lowerCAmelCase__			:  Union[str, Any]											= self.dummy_tokenizer
      lowerCAmelCase__			:  str											= self.dummy_renderer

      lowerCAmelCase__			:  Dict											= HeunDiscreteScheduler(
          beta_schedule="""exp"""  ,num_train_timesteps=1024  ,prediction_type="""sample"""  ,use_karras_sigmas=__UpperCAmelCase  ,clip_sample=__UpperCAmelCase  ,clip_sample_range=1.0  ,)
      lowerCAmelCase__			:  List[Any]											= {
          """prior""": prior,
          """text_encoder""": text_encoder,
          """tokenizer""": tokenizer,
          """renderer""": renderer,
          """scheduler""": scheduler,
      }

      return components




  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase  ,__UpperCAmelCase=0				)   ->		Tuple:
      if str(__UpperCAmelCase				).startswith("""mps"""				):
          lowerCAmelCase__			:  Optional[int]											= torch.manual_seed(__UpperCAmelCase				)
      else:
          lowerCAmelCase__			:  Any											= torch.Generator(device=__UpperCAmelCase				).manual_seed(__UpperCAmelCase				)
      lowerCAmelCase__			:  str											= {
          """prompt""": """horse""",
          """generator""": generator,
          """num_inference_steps""": 1,
          """frame_size""": 32,
          """output_type""": """np""",
      }
      return inputs




  def 							UpperCAmelCase_     (   self				)   ->		Optional[Any]:
      lowerCAmelCase__			:  List[str]											= """cpu"""

      lowerCAmelCase__			:  Tuple											= self.get_dummy_components()

      lowerCAmelCase__			:  int											= self.pipeline_class(**__UpperCAmelCase				)
      lowerCAmelCase__			:  Dict											= pipe.to(__UpperCAmelCase				)

      pipe.set_progress_bar_config(disable=__UpperCAmelCase				)

      lowerCAmelCase__			:  int											= pipe(**self.get_dummy_inputs(__UpperCAmelCase				)				)
      lowerCAmelCase__			:  str											= output.images[0]
      lowerCAmelCase__			:  List[str]											= image[0, -3:, -3:, -1]

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

      lowerCAmelCase__			:  List[str]											= np.array(
          [
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
          ]				)

      assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2




  def 							UpperCAmelCase_     (   self				)   ->		Union[str, Any]:
      # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
      self._test_inference_batch_consistent(batch_sizes=[1, 2]				)




  def 							UpperCAmelCase_     (   self				)   ->		str:
      lowerCAmelCase__			:  Any											= torch_device == """cpu"""
      lowerCAmelCase__			:  Optional[int]											= True

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






  def 							UpperCAmelCase_     (   self				)   ->		Dict:
      lowerCAmelCase__			:  Any											= self.get_dummy_components()
      lowerCAmelCase__			:  str											= self.pipeline_class(**__UpperCAmelCase				)
      lowerCAmelCase__			:  Optional[int]											= pipe.to(__UpperCAmelCase				)
      pipe.set_progress_bar_config(disable=__UpperCAmelCase				)

      lowerCAmelCase__			:  Optional[Any]											= 1
      lowerCAmelCase__			:  List[Any]											= 2

      lowerCAmelCase__			:  Dict											= self.get_dummy_inputs(__UpperCAmelCase				)

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

      lowerCAmelCase__			:  Tuple											= pipe(**__UpperCAmelCase  ,num_images_per_prompt=__UpperCAmelCase				)[0]

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







@slow
@require_torch_gpu
class 	lowerCAmelCase_(    unittest.TestCase					):
  '''simple docstring'''




  def 							UpperCAmelCase_     (   self				)   ->		int:
      # clean up the VRAM after each test
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()






  def 							UpperCAmelCase_     (   self				)   ->		List[Any]:
      lowerCAmelCase__			:  str											= load_numpy(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
          """/shap_e/test_shap_e_np_out.npy"""				)
      lowerCAmelCase__			:  Optional[Any]											= ShapEPipeline.from_pretrained("""openai/shap-e"""				)
      lowerCAmelCase__			:  Union[str, Any]											= pipe.to(__UpperCAmelCase				)
      pipe.set_progress_bar_config(disable=__UpperCAmelCase				)

      lowerCAmelCase__			:  Any											= torch.Generator(device=__UpperCAmelCase				).manual_seed(0				)

      lowerCAmelCase__			:  str											= pipe(
          """a shark"""  ,generator=__UpperCAmelCase  ,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(__UpperCAmelCase  ,__UpperCAmelCase				)







'''simple docstring'''





import os
def        _SCREAMING_SNAKE_CASE  (	UpperCamelCase      ):



    """simple docstring"""





    lowerCAmelCase__			:  List[str]											= len(grid[0]      )
    lowerCAmelCase__			:  int											= len(UpperCamelCase      )

    lowerCAmelCase__			:  Optional[int]											= 0
    lowerCAmelCase__			:  Tuple											= 0
    lowerCAmelCase__			:  Optional[Any]											= 0

    # Check vertically, horizontally, diagonally at the same time (only works
    # for nxn grid)
    for i in range(UpperCamelCase      ):
        for j in range(n_rows - 3      ):
            lowerCAmelCase__			:  str											= grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
            lowerCAmelCase__			:  Optional[int]											= grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]

            # Left-to-right diagonal (\) product
            if i < n_columns - 3:
                lowerCAmelCase__			:  Optional[int]											= (
                    grid[i][j]
                    * grid[i + 1][j + 1]
                    * grid[i + 2][j + 2]
                    * grid[i + 3][j + 3]
                )

            # Right-to-left diagonal(/) product
            if i > 2:
                lowerCAmelCase__			:  Tuple											= (
                    grid[i][j]
                    * grid[i - 1][j + 1]
                    * grid[i - 2][j + 2]
                    * grid[i - 3][j + 3]
                )

            lowerCAmelCase__			:  Dict											= max(
                UpperCamelCase							,   UpperCamelCase							,   UpperCamelCase							,   UpperCamelCase      )
            if max_product > largest:
                lowerCAmelCase__			:  Any											= max_product

    return largest
def        _SCREAMING_SNAKE_CASE  (	):



    """simple docstring"""





    lowerCAmelCase__			:  List[str]											= []
    with open(os.path.dirname(UpperCamelCase      ) + """/grid.txt"""      ) as file:
        for line in file:
            grid.append(line.strip("""\n"""      ).split(""" """      )      )

    lowerCAmelCase__			:  Dict											= [[int(UpperCamelCase      ) for i in grid[j]] for j in range(len(UpperCamelCase      )      )]

    return largest_product(UpperCamelCase      )


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


