



"""simple docstring"""





from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow


if is_tf_available():
					import numpy as np
					import tensorflow as tf

					from transformers import TFCamembertModel



@require_tf
@require_sentencepiece
@require_tokenizers
class    _lowerCAmelCase    (				unittest.TestCase		):





		"""simple docstring"""






		@slow
		def    UpperCAmelCase__							(					self   ) ->						Optional[Any]:







								'''simple docstring'''

								snake_case_   : List[str]						=			TFCamembertModel.from_pretrained("""jplu/tf-camembert-base"""   )

								snake_case_   : int						=			tf.convert_to_tensor(
								    [[5, 1_2_1, 1_1, 6_6_0, 1_6, 7_3_0, 2_5_5_4_3, 1_1_0, 8_3, 6]]							,    dtype=tf.intaa							,    )  # J'aime le camembert !"

								snake_case_   : str						=			model(_lowercase   )["""last_hidden_state"""]
								snake_case_   : int						=			tf.TensorShape((1, 1_0, 7_6_8)   )
								self.assertEqual(output.shape							,    _lowercase   )
								# compare the actual values for a slice.
								snake_case_   : str						=			tf.convert_to_tensor(
								    [[[-0.0254, 0.0235, 0.1027], [0.0606, -0.1811, -0.0418], [-0.1561, -0.1127, 0.2687]]]							,    dtype=tf.floataa							,    )
								# camembert = torch.hub.load('pytorch/fairseq', 'camembert.v0')
								# camembert.eval()
								# expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach()

								self.assertTrue(np.allclose(output[:, :3, :3].numpy()							,    expected_slice.numpy()							,    atol=1E-4   )   )






"""simple docstring"""





def 	__lowerCAmelCase						(		__UpperCamelCase      :			int					, __UpperCamelCase      :			int    ):


						'''simple docstring'''






						snake_case_   : Any						=			1  # To kept the Calculated Value
						# Since C(n, k) = C(n, n-k)
						if k > (n - k):
												snake_case_   : Optional[int]						=			n - k
						# Calculate C(n,k)
						for i in range(__UpperCamelCase    ):
												result *= n - i
												result //= i + 1
						return result
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int    ):


						'''simple docstring'''






						return binomial_coefficient(2 * node_count					, __UpperCamelCase    ) // (node_count + 1)
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int    ):


						'''simple docstring'''






						if n < 0:
												raise ValueError("""factorial() not defined for negative values"""    )
						snake_case_   : Optional[int]						=			1
						for i in range(1					, n + 1    ):
												result *= i
						return result
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int    ):


						'''simple docstring'''






						return catalan_number(__UpperCamelCase    ) * factorial(__UpperCamelCase    )


if __name__ == "__main__":
					__lowerCAmelCase       :					Optional[Any]      					=					int(input('''Enter the number of nodes: ''').strip() or 0)
					if node_count <= 0:
										raise ValueError('''We need some nodes to work with.''')
					print(
					    F'''Given {node_count} nodes, there are {binary_tree_count(node_count)} '''
					    F'''binary trees and {catalan_number(node_count)} binary search trees.'''
					)

