



def 					__lowerCAmelCase		(  __lowerCamelCase	:    int	)  ->						None:
					__lowerCAmelCase	   =generate_pascal_triangle(__lowerCamelCase	)
					for row_idx in range(__lowerCamelCase	):
										# 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		(  __lowerCamelCase	:    int	)  ->						list[list[int]]:

					if not isinstance(__lowerCamelCase				,   __lowerCamelCase	):
										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	   =[]
					for current_row_idx in range(__lowerCamelCase	):
										__lowerCAmelCase	   =populate_current_row(__lowerCamelCase				,   __lowerCamelCase	)
										triangle.append(__lowerCamelCase	)
					return triangle






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






def 					__lowerCAmelCase		(  __lowerCamelCase	:    list[list[int]]				,   __lowerCamelCase	:    list[int]				,   __lowerCamelCase	:    int				,   __lowerCamelCase	:    int				,   )  ->						None:
					__lowerCAmelCase	   =triangle[current_row_idx - 1][current_col_idx - 1]
					__lowerCAmelCase	   =triangle[current_row_idx - 1][current_col_idx]
					__lowerCAmelCase	   =above_to_left_elt + above_to_right_elt






def 					__lowerCAmelCase		(  __lowerCamelCase	:    int	)  ->						list[list[int]]:

					if not isinstance(__lowerCamelCase				,   __lowerCamelCase	):
										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	   =[[1]]

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

					return result






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

					def benchmark_a_function(__lowerCamelCase	:    Callable				,   __lowerCamelCase	:    int	) -> None:
										__lowerCAmelCase	   =f"""{func.__name__}({value})"""
										__lowerCAmelCase	   =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(__lowerCamelCase				,   __lowerCamelCase	)
										print()


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				benchmark()









import json
import os
import subprocess
import unittest
from ast import literal_eval

import pytest
from parameterized import parameterized, parameterized_class

from . import is_sagemaker_available


if is_sagemaker_available():
				from sagemaker import Session, TrainingJobAnalytics
				from sagemaker.huggingface import HuggingFace






@pytest.mark.skipif(
    literal_eval(os.getenv("TEST_SAGEMAKER"	,    "False"				)				) is not True	,    reason="Skipping test because should only be run when releasing minor transformers version"	,    )
@pytest.mark.usefixtures("sm_env"				)
@parameterized_class(
    [
        {
            "framework": "pytorch",
            "script": "run_glue.py",
            "model_name_or_path": "distilbert-base-cased",
            "instance_type": "ml.p3.16xlarge",
            "results": {"train_runtime": 650, "eval_accuracy": 0.7, "eval_loss": 0.6},
        },
        {
            "framework": "pytorch",
            "script": "run_ddp.py",
            "model_name_or_path": "distilbert-base-cased",
            "instance_type": "ml.p3.16xlarge",
            "results": {"train_runtime": 600, "eval_accuracy": 0.7, "eval_loss": 0.6},
        },
        {
            "framework": "tensorflow",
            "script": "run_tf_dist.py",
            "model_name_or_path": "distilbert-base-cased",
            "instance_type": "ml.p3.16xlarge",
            "results": {"train_runtime": 600, "eval_accuracy": 0.6, "eval_loss": 0.7},
        },
    ]				)
class 						__a (     unittest.TestCase				):



	def 		UpperCamelCase							(						self							:    Dict)->							Any:
						if self.framework == "pytorch":
											subprocess.run(
											    F"""cp ./examples/pytorch/text-classification/run_glue.py {self.env.test_path}/run_glue.py""".split()				,	encoding="""utf-8"""				,	check=snake_case_				,	)
						assert hasattr(self				,	"""env""")



	def 		UpperCamelCase							(						self							:    Dict				,	snake_case_							:    str)->							Dict:
						__lowerCAmelCase	   =F"""{self.env.base_job_name}-{instance_count}-{'ddp' if 'ddp' in self.script else 'smd'}"""
						# distributed data settings
						__lowerCAmelCase	   ={"""smdistributed""": {"""dataparallel""": {"""enabled""": True}}} if self.script != """run_ddp.py""" else None

						# creates estimator
						return HuggingFace(
						    entry_point=self.script				,	source_dir=self.env.test_path				,	role=self.env.role				,	image_uri=self.env.image_uri				,	base_job_name=snake_case_				,	instance_count=snake_case_				,	instance_type=self.instance_type				,	debugger_hook_config=snake_case_				,	hyperparameters={**self.env.distributed_hyperparameters, """model_name_or_path""": self.model_name_or_path}				,	metric_definitions=self.env.metric_definitions				,	distribution=snake_case_				,	py_version="""py36"""				,	)



	def 		UpperCamelCase							(						self							:    int				,	snake_case_							:    List[Any])->							int:
						TrainingJobAnalytics(snake_case_).export_csv(F"""{self.env.test_path}/{job_name}_metrics.csv""")



	@parameterized.expand([(2,)])
	def 		UpperCamelCase							(						self							:    Any				,	snake_case_							:    Dict)->							Optional[Any]:
						# create estimator
						__lowerCAmelCase	   =self.create_estimator(snake_case_)

						# run training
						estimator.fit()

						# result dataframe
						__lowerCAmelCase	   =TrainingJobAnalytics(estimator.latest_training_job.name).dataframe()

						# extract kpis
						__lowerCAmelCase	   =list(result_metrics_df[result_metrics_df.metric_name == """eval_accuracy"""]["""value"""])
						__lowerCAmelCase	   =list(result_metrics_df[result_metrics_df.metric_name == """eval_loss"""]["""value"""])
						# get train time from SageMaker job, this includes starting, preprocessing, stopping
						__lowerCAmelCase	   =(
						    Session().describe_training_job(estimator.latest_training_job.name).get("""TrainingTimeInSeconds"""				,	99_99_99)
						)

						# assert kpis
						assert train_runtime <= self.results["train_runtime"]
						assert all(t >= self.results["""eval_accuracy"""] for t in eval_accuracy)
						assert all(t <= self.results["""eval_loss"""] for t in eval_loss)

						# dump tests result into json file to share in PR
						with open(F"""{estimator.latest_training_job.name}.json"""				,	"""w""") as outfile:
											json.dump({"""train_time""": train_runtime, """eval_accuracy""": eval_accuracy, """eval_loss""": eval_loss}				,	snake_case_)




