





"""simple docstring"""





def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				int ):


							'''simple docstring'''







							__lowerCamelCase   :   Union[str, Any]       =generate_pascal_triangle(SCREAMING_SNAKE_CASE )
							for row_idx in range(SCREAMING_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 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				int ):


							'''simple docstring'''







							if not isinstance(SCREAMING_SNAKE_CASE     ,    SCREAMING_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''' )

							__lowerCamelCase   :   list[list[int]]       =[]
							for current_row_idx in range(SCREAMING_SNAKE_CASE ):
														__lowerCamelCase   :   Optional[int]       =populate_current_row(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE )
														triangle.append(SCREAMING_SNAKE_CASE )
							return triangle



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				list[list[int]]     ,    SCREAMING_SNAKE_CASE							:				int ):


							'''simple docstring'''







							__lowerCamelCase   :   Tuple       =[-1] * (current_row_idx + 1)
							# first and last elements of current row are equal to 1
							__lowerCamelCase     ,    __lowerCamelCase   :   Tuple       =1, 1
							for current_col_idx in range(1     ,    SCREAMING_SNAKE_CASE ):
														calculate_current_element(
														    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE )
							return current_row



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				list[list[int]]     ,    SCREAMING_SNAKE_CASE							:				list[int]     ,    SCREAMING_SNAKE_CASE							:				int     ,    SCREAMING_SNAKE_CASE							:				int     ,    ):


							'''simple docstring'''







							__lowerCamelCase   :   Any       =triangle[current_row_idx - 1][current_col_idx - 1]
							__lowerCamelCase   :   Dict       =triangle[current_row_idx - 1][current_col_idx]
							__lowerCamelCase   :   Optional[Any]       =above_to_left_elt + above_to_right_elt



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				int ):


							'''simple docstring'''







							if not isinstance(SCREAMING_SNAKE_CASE     ,    SCREAMING_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''' )

							__lowerCamelCase   :   list[list[int]]       =[[1]]

							for row_index in range(1     ,    SCREAMING_SNAKE_CASE ):
														__lowerCamelCase   :   Union[str, Any]       =[0] + result[-1] + [0]
														__lowerCamelCase   :   Any       =row_index + 1
														# Calculate the number of distinct elements in a row
														__lowerCamelCase   :   Optional[Any]       =sum(divmod(SCREAMING_SNAKE_CASE     ,    2 ) )
														__lowerCamelCase   :   str       =[
														    temp_row[i - 1] + temp_row[i] for i in range(1     ,    distinct_elements + 1 )
														]
														__lowerCamelCase   :   int       =row_first_half[: (row_index + 1) // 2]
														row_second_half.reverse()
														__lowerCamelCase   :   List[Any]       =row_first_half + row_second_half
														result.append(SCREAMING_SNAKE_CASE )

							return result



def 					lowerCAmelCase_      (   ):


							'''simple docstring'''







							from collections.abc import Callable
							from timeit import timeit

							def benchmark_a_function(SCREAMING_SNAKE_CASE							:				Callable     ,    SCREAMING_SNAKE_CASE							:				int ) -> None:
														__lowerCamelCase   :   Union[str, Any]       =F'{func.__name__}({value})'
														__lowerCamelCase   :   List[Any]       =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(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE )
														print()


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							benchmark()











"""simple docstring"""





import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
							from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
							from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
							from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


_UpperCamelCase					      =   DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

_UpperCamelCase					      =   'main'
# Default branch name
_UpperCamelCase					      =   'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
_UpperCamelCase					      =   'aaaaaaa'
# This commit does not exist, so we should 404.

_UpperCamelCase					      =   'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
_UpperCamelCase					      =   '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'



@contextlib.contextmanager
def 					lowerCAmelCase_      (   ):


							'''simple docstring'''







							print('''Welcome!''' )
							yield
							print('''Bye!''' )



@contextlib.contextmanager
def 					lowerCAmelCase_      (   ):


							'''simple docstring'''







							print('''Bonjour!''' )
							yield
							print('''Au revoir!''' )
class 		SCREAMING_SNAKE_CASE_				(     unittest.TestCase ):
				"""simple docstring"""




				def        __lowercase	(  self	:str      ):
											# If the spec is missing, importlib would not be able to import the module dynamically.
											assert transformers.__spec__ is not None
											assert importlib.util.find_spec('''transformers'''      ) is not None

class 		SCREAMING_SNAKE_CASE_				(     unittest.TestCase ):
				"""simple docstring"""




				@unittest.mock.patch('''sys.stdout'''    ,     new_callable=io.StringIO      )
				def        __lowercase	(  self	:str    ,     __lowercase	:str      ):
											with ContextManagers([]      ):
																		print('''Transformers are awesome!'''      )
											# The print statement adds a new line at the end of the output
											self.assertEqual(mock_stdout.getvalue()    ,     '''Transformers are awesome!\n'''      )




				@unittest.mock.patch('''sys.stdout'''    ,     new_callable=io.StringIO      )
				def        __lowercase	(  self	:Any    ,     __lowercase	:Tuple      ):
											with ContextManagers([context_en()]      ):
																		print('''Transformers are awesome!'''      )
											# The output should be wrapped with an English welcome and goodbye
											self.assertEqual(mock_stdout.getvalue()    ,     '''Welcome!\nTransformers are awesome!\nBye!\n'''      )




				@unittest.mock.patch('''sys.stdout'''    ,     new_callable=io.StringIO      )
				def        __lowercase	(  self	:List[Any]    ,     __lowercase	:Optional[Any]      ):
											with ContextManagers([context_fr(), context_en()]      ):
																		print('''Transformers are awesome!'''      )
											# The output should be wrapped with an English and French welcome and goodbye
											self.assertEqual(mock_stdout.getvalue()    ,     '''Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n'''      )




				@require_torch
				def        __lowercase	(  self	:Tuple      ):
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''', '''next_sentence_label''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''start_positions''', '''end_positions''']      )
											class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
															"""simple docstring"""
															pass

											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )




				@require_tf
				def        __lowercase	(  self	:str      ):
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''', '''next_sentence_label''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''start_positions''', '''end_positions''']      )
											class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
															"""simple docstring"""
															pass

											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )




				@require_flax
				def        __lowercase	(  self	:str      ):
											# Flax models don't have labels
											self.assertEqual(find_labels(__lowercase      )    ,     []      )
											self.assertEqual(find_labels(__lowercase      )    ,     []      )
											self.assertEqual(find_labels(__lowercase      )    ,     []      )
											class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
															"""simple docstring"""
															pass

											self.assertEqual(find_labels(__lowercase      )    ,     []      )




