from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__lowercase											=      {
    "configuration_convbert": ["CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ConvBertConfig", "ConvBertOnnxConfig"],
    "tokenization_convbert": ["ConvBertTokenizer"],
}

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowercase											=      ["ConvBertTokenizerFast"]

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowercase											=      [
				    "CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "ConvBertForMaskedLM",
				    "ConvBertForMultipleChoice",
				    "ConvBertForQuestionAnswering",
				    "ConvBertForSequenceClassification",
				    "ConvBertForTokenClassification",
				    "ConvBertLayer",
				    "ConvBertModel",
				    "ConvBertPreTrainedModel",
				    "load_tf_weights_in_convbert",
				]


try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowercase											=      [
				    "TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "TFConvBertForMaskedLM",
				    "TFConvBertForMultipleChoice",
				    "TFConvBertForQuestionAnswering",
				    "TFConvBertForSequenceClassification",
				    "TFConvBertForTokenClassification",
				    "TFConvBertLayer",
				    "TFConvBertModel",
				    "TFConvBertPreTrainedModel",
				]


if TYPE_CHECKING:
				from .configuration_convbert import CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvBertConfig, ConvBertOnnxConfig
				from .tokenization_convbert import ConvBertTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_convbert_fast import ConvBertTokenizerFast

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_convbert import (
								    CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    ConvBertForMaskedLM,
								    ConvBertForMultipleChoice,
								    ConvBertForQuestionAnswering,
								    ConvBertForSequenceClassification,
								    ConvBertForTokenClassification,
								    ConvBertLayer,
								    ConvBertModel,
								    ConvBertPreTrainedModel,
								    load_tf_weights_in_convbert,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_convbert import (
								    TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFConvBertForMaskedLM,
								    TFConvBertForMultipleChoice,
								    TFConvBertForQuestionAnswering,
								    TFConvBertForSequenceClassification,
								    TFConvBertForTokenClassification,
								    TFConvBertLayer,
								    TFConvBertModel,
								    TFConvBertPreTrainedModel,
								)


else:
				import sys

				__lowercase											=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






def lowerCamelCase						(     SCREAMING_SNAKE_CASE			):
    '''simple docstring'''







    __UpperCamelCase  :Optional[int]    						=	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			):
    '''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'''			)

    __UpperCamelCase  :list[list[int]]    						=	[]
    for current_row_idx in range(SCREAMING_SNAKE_CASE			):
        __UpperCamelCase  :List[Any]    						=	populate_current_row(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			)
        triangle.append(SCREAMING_SNAKE_CASE			)
    return triangle



def lowerCamelCase						(     SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			):
    '''simple docstring'''







    __UpperCamelCase  :int    						=	[-1] * (current_row_idx + 1)
    # first and last elements of current row are equal to 1
    __UpperCamelCase						, __UpperCamelCase  :int    						=	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						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    ):
    '''simple docstring'''







    __UpperCamelCase  :Dict    						=	triangle[current_row_idx - 1][current_col_idx - 1]
    __UpperCamelCase  :List[Any]    						=	triangle[current_row_idx - 1][current_col_idx]
    __UpperCamelCase  :List[Any]    						=	above_to_left_elt + above_to_right_elt



def lowerCamelCase						(     SCREAMING_SNAKE_CASE			):
    '''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'''			)

    __UpperCamelCase  :list[list[int]]    						=	[[1]]

    for row_index in range(1						,    SCREAMING_SNAKE_CASE			):
        __UpperCamelCase  :Optional[Any]    						=	[0] + result[-1] + [0]
        __UpperCamelCase  :Any    						=	row_index + 1
        # Calculate the number of distinct elements in a row
        __UpperCamelCase  :Optional[Any]    						=	sum(divmod(SCREAMING_SNAKE_CASE						,    2			)			)
        __UpperCamelCase  :Union[str, Any]    						=	[
            temp_row[i - 1] + temp_row[i] for i in range(1						,    distinct_elements + 1			)
        ]
        __UpperCamelCase  :List[Any]    						=	row_first_half[: (row_index + 1) // 2]
        row_second_half.reverse()
        __UpperCamelCase  :List[str]    						=	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						,    SCREAMING_SNAKE_CASE			) -> None:
        __UpperCamelCase  :List[str]    						=	f"""{func.__name__}({value})"""
        __UpperCamelCase  :Optional[int]    						=	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()





