





'''simple docstring'''







def    __UpperCamelCase	(	a    : Optional[Any]     ) ->None:
 snake_case				=			generate_pascal_triangle(__snake_case     )
 for row_idx in range(__snake_case     ):
  # Print left spaces
  for _ in range(num_rows - row_idx - 1     ):
   print(end=''' '''     )
  # Print row values
  for col_idx in range(row_idx + 1     ):
   if col_idx != row_idx:
    print(triangle[row_idx][col_idx]					,   end=''' '''     )
   else:
    print(triangle[row_idx][col_idx]					,   end=''''''     )
  print()

def    __UpperCamelCase	(	a    : int     ) ->list[list[int]]:





 if not isinstance(__snake_case					,   __snake_case     ):
  raise TypeError('''The input value of \'num_rows\' should be \'int\''''     )

 if num_rows == 0:
  return []
 elif num_rows < 0:
  raise ValueError(
      '''The input value of \'num_rows\' should be greater than or equal to 0'''     )

 snake_case				=			[]
 for current_row_idx in range(__snake_case     ):
  snake_case				=			populate_current_row(__snake_case					,   __snake_case     )
  triangle.append(__snake_case     )
 return triangle

def    __UpperCamelCase	(	a    : Any					,   a    : str     ) ->list[int]:
 snake_case				=			[-1] * (current_row_idx + 1)
 # first and last elements of current row are equal to 1
 snake_case				,		snake_case				=			1, 1
 for current_col_idx in range(1					,   __snake_case     ):
  calculate_current_element(
      __snake_case					,   __snake_case					,   __snake_case					,   __snake_case     )
 return current_row

def    __UpperCamelCase	(	a    : Dict					,   a    : Union[str, Any]					,   a    : Tuple					,   a    : List[str]					,   ) ->None:
 snake_case				=			triangle[current_row_idx - 1][current_col_idx - 1]
 snake_case				=			triangle[current_row_idx - 1][current_col_idx]
 snake_case				=			above_to_left_elt + above_to_right_elt

def    __UpperCamelCase	(	a    : Tuple     ) ->list[list[int]]:





 if not isinstance(__snake_case					,   __snake_case     ):
  raise TypeError('''The input value of \'num_rows\' should be \'int\''''     )

 if num_rows == 0:
  return []
 elif num_rows < 0:
  raise ValueError(
      '''The input value of \'num_rows\' should be greater than or equal to 0'''     )

 snake_case				=			[[1]]

 for row_index in range(1					,   __snake_case     ):
  snake_case				=			[0] + result[-1] + [0]
  snake_case				=			row_index + 1
  # Calculate the number of distinct elements in a row
  snake_case				=			sum(divmod(__snake_case					,   2     )     )
  snake_case				=			[
      temp_row[i - 1] + temp_row[i] for i in range(1					,   distinct_elements + 1     )
  ]
  snake_case				=			row_first_half[: (row_index + 1) // 2]
  row_second_half.reverse()
  snake_case				=			row_first_half + row_second_half
  result.append(__snake_case     )

 return result

def    __UpperCamelCase	(	) ->None:
 from collections.abc import Callable
 from timeit import timeit

 def benchmark_a_function(a    : str					,   a    : int     ) -> None:
  snake_case				=			f"""{func.__name__}({value})"""
  snake_case				=			timeit(f"""__main__.{call}"""					,   setup='''import __main__'''     )
  # print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
  print(f"""{call:38} -- {timing:.4f} seconds"""     )

 for value in range(15     ):  # (1, 7, 14):
  for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
   benchmark_a_function(__snake_case					,   __snake_case     )
  print()


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   benchmark()








'''simple docstring'''







from ...utils import is_note_seq_available, is_transformers_available, is_torch_available
from ...utils import OptionalDependencyNotAvailable


try:
   if not (is_transformers_available() and is_torch_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
   from .notes_encoder import SpectrogramNotesEncoder
   from .continous_encoder import SpectrogramContEncoder
   from .pipeline_spectrogram_diffusion import (
       SpectrogramContEncoder,
       SpectrogramDiffusionPipeline,
       TaFilmDecoder,
   )

try:
   if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from ...utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
   from .midi_utils import MidiProcessor

