'''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     __UpperCAmelCase       ( __a						,       unittest.TestCase		):
  __A :				Dict											= ShapEPipeline
  __A :				Optional[int]											= ['prompt']
  __A :				Tuple											= ['prompt']
  __A :				List[str]											= [
      'num_images_per_prompt',
      'num_inference_steps',
      'generator',
      'latents',
      'guidance_scale',
      'frame_size',
      'output_type',
      'return_dict',
  ]
  __A :				List[Any]											= False





  @property
  def 						UpperCAmelCase_	(	self ):
     return 32





  @property
  def 						UpperCAmelCase_	(	self ):
     return 32





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





  @property
  def 						UpperCAmelCase_	(	self ):
     return 8





  @property
  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )
     return tokenizer





  @property
  def 						UpperCAmelCase_	(	self ):
     torch.manual_seed(0 )
     lowerCAmelCase_			=      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(_lowerCamelCase )





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

     lowerCAmelCase_			=      {
         '''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_			=      PriorTransformer(**_lowerCamelCase )
     return model





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

     lowerCAmelCase_			=      {
         '''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_			=      ShapERenderer(**_lowerCamelCase )
     return model





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.dummy_prior
     lowerCAmelCase_			=      self.dummy_text_encoder
     lowerCAmelCase_			=      self.dummy_tokenizer
     lowerCAmelCase_			=      self.dummy_renderer

     lowerCAmelCase_			=      HeunDiscreteScheduler(
         beta_schedule='''exp'''    ,     num_train_timesteps=1024    ,     prediction_type='''sample'''    ,     use_karras_sigmas=_lowerCamelCase    ,     clip_sample=_lowerCamelCase    ,     clip_sample_range=1.0    ,     )
     lowerCAmelCase_			=      {
         '''prior''': prior,
         '''text_encoder''': text_encoder,
         '''tokenizer''': tokenizer,
         '''renderer''': renderer,
         '''scheduler''': scheduler,
     }

     return components





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





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      '''cpu'''

     lowerCAmelCase_			=      self.get_dummy_components()

     lowerCAmelCase_			=      self.pipeline_class(**_lowerCamelCase )
     lowerCAmelCase_			=      pipe.to(_lowerCamelCase )

     pipe.set_progress_bar_config(disable=_lowerCamelCase )

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

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

     lowerCAmelCase_			=      np.array(
         [
             0.00_03_92_16,
             0.00_03_92_16,
             0.00_03_92_16,
             0.00_03_92_16,
             0.00_03_92_16,
             0.00_03_92_16,
             0.00_03_92_16,
             0.00_03_92_16,
             0.00_03_92_16,
         ] )

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





  def 						UpperCAmelCase_	(	self ):
     # 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 ):
     lowerCAmelCase_			=      torch_device == '''cpu'''
     lowerCAmelCase_			=      True

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







  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.get_dummy_components()
     lowerCAmelCase_			=      self.pipeline_class(**_lowerCamelCase )
     lowerCAmelCase_			=      pipe.to(_lowerCamelCase )
     pipe.set_progress_bar_config(disable=_lowerCamelCase )

     lowerCAmelCase_			=      1
     lowerCAmelCase_			=      2

     lowerCAmelCase_			=      self.get_dummy_inputs(_lowerCamelCase )

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

     lowerCAmelCase_			=      pipe(**_lowerCamelCase    ,     num_images_per_prompt=_lowerCamelCase )[0]

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






@slow
@require_torch_gpu
class     __UpperCAmelCase       ( unittest.TestCase		):





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







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

     lowerCAmelCase_			=      torch.Generator(device=_lowerCamelCase ).manual_seed(0 )

     lowerCAmelCase_			=      pipe(
         '''a shark'''    ,     generator=_lowerCamelCase    ,     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(_lowerCamelCase    ,     _lowerCamelCase )






'''simple docstring'''

import os



def snake_case_      (					__snake_case  :							List[Any])			->					str:
   lowerCAmelCase_			=      len(grid[0])
   lowerCAmelCase_			=      len(__snake_case)

   lowerCAmelCase_			=      0
   lowerCAmelCase_			=      0
   lowerCAmelCase_			=      0

   # Check vertically, horizontally, diagonally at the same time (only works
   # for nxn grid)
   for i in range(__snake_case):
      for j in range(n_rows - 3):
         lowerCAmelCase_			=      grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
         lowerCAmelCase_			=      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_			=      (
                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_			=      (
                grid[i][j]
                * grid[i - 1][j + 1]
                * grid[i - 2][j + 2]
                * grid[i - 3][j + 3]
            )

         lowerCAmelCase_			=      max(
             __snake_case	,   __snake_case	,   __snake_case	,   __snake_case)
         if max_product > largest:
            lowerCAmelCase_			=      max_product

   return largest



def snake_case_      (					)			->					List[Any]:
   lowerCAmelCase_			=      []
   with open(os.path.dirname(__snake_case) + '''/grid.txt''') as file:
      for line in file:
         grid.append(line.strip('''\n''').split(''' '''))

   lowerCAmelCase_			=      [[int(__snake_case) for i in grid[j]] for j in range(len(__snake_case))]

   return largest_product(__snake_case)


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





