


'''simple docstring'''
def       a				(      __a			, __a       )  ->     Dict:



					'''simple docstring'''






					return (pointa[0] - pointa[0]) ** 2 + (pointa[1] - pointa[1]) ** 2


def       a				(      __a			, __a=0       )  ->     Optional[Any]:



					'''simple docstring'''






					return sorted(__a			, key=lambda __a       : x[column]       )


def       a				(      __a			, __a			, __a=float('''inf'''       )       )  ->     Optional[int]:



					'''simple docstring'''






					for i in range(points_counts - 1       ):
										for j in range(i + 1			, __a       ):
															UpperCamelCase__       :Dict							 =			euclidean_distance_sqr(points[i]			, points[j]       )
															if current_dis < min_dis:
																				UpperCamelCase__       :Optional[Any]							 =			current_dis
					return min_dis


def       a				(      __a			, __a			, __a=float('''inf'''       )       )  ->     Dict:



					'''simple docstring'''






					for i in range(min(6			, points_counts - 1       )			, __a       ):
										for j in range(max(0			, i - 6       )			, __a       ):
															UpperCamelCase__       :Union[str, Any]							 =			euclidean_distance_sqr(points[i]			, points[j]       )
															if current_dis < min_dis:
																				UpperCamelCase__       :Optional[int]							 =			current_dis
					return min_dis


def       a				(      __a			, __a			, __a       )  ->     Union[str, Any]:



					'''simple docstring'''






					if points_counts <= 3:
										return dis_between_closest_pair(__a			, __a       )

					# recursion
					UpperCamelCase__       :List[str]							 =			points_counts // 2
					UpperCamelCase__       :str							 =			closest_pair_of_points_sqr(
					    __a			, points_sorted_on_y[:mid]			, __a       )
					UpperCamelCase__       :Tuple							 =			closest_pair_of_points_sqr(
					    __a			, points_sorted_on_y[mid:]			, points_counts - mid       )
					UpperCamelCase__       :str							 =			min(__a			, __a       )
					UpperCamelCase__       :List[Any]							 =			[]
					for point in points_sorted_on_x:
										if abs(point[0] - points_sorted_on_x[mid][0]       ) < closest_pair_dis:
															cross_strip.append(__a       )

					UpperCamelCase__       :Union[str, Any]							 =			dis_between_closest_in_strip(
					    __a			, len(__a       )			, __a       )
					return min(__a			, __a       )


def       a				(      __a			, __a       )  ->     Any:



					'''simple docstring'''






					UpperCamelCase__       :Union[str, Any]							 =			column_based_sort(__a			, column=0       )
					UpperCamelCase__       :Optional[int]							 =			column_based_sort(__a			, column=1       )
					return (
					    closest_pair_of_points_sqr(
					        __a			, __a			, __a       )
					) ** 0.5


if __name__ == "__main__":
		__snake_case											=					[(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)]
		print('''Distance:''', closest_pair_of_points(points, len(points)))



'''simple docstring'''
import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar
class        lowercase     (							unittest.TestCase ):

		"""simple docstring"""

		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							UpperCamelCase__       :int							 =			logging.get_logger()

							# the current default level is logging.WARNING
							UpperCamelCase__       :List[Any]							 =			logging.get_verbosity()

							logging.set_verbosity_error()
							self.assertEqual(logger.getEffectiveLevel()   ,       logging.get_verbosity()							)

							logging.set_verbosity_warning()
							self.assertEqual(logger.getEffectiveLevel()   ,       logging.get_verbosity()							)

							logging.set_verbosity_info()
							self.assertEqual(logger.getEffectiveLevel()   ,       logging.get_verbosity()							)

							logging.set_verbosity_debug()
							self.assertEqual(logger.getEffectiveLevel()   ,       logging.get_verbosity()							)

							# restore to the original level
							logging.set_verbosity(UpperCamelCase_							)




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							UpperCamelCase__       :Union[str, Any]							 =			logging.get_verbosity()

							UpperCamelCase__       :Union[str, Any]							 =			logging.get_logger('''transformers.models.bart.tokenization_bart'''							)
							UpperCamelCase__       :Optional[Any]							 =			'''Testing 1, 2, 3'''

							# should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
							if level_origin <= logging.WARNING:
												with CaptureLogger(UpperCamelCase_							) as cl:
																	logger.warning(UpperCamelCase_							)
												self.assertEqual(cl.out   ,       msg + '''\n'''							)

							# this is setting the level for all of `transformers.*` loggers
							logging.set_verbosity_error()

							# should not be able to log warnings
							with CaptureLogger(UpperCamelCase_							) as cl:
												logger.warning(UpperCamelCase_							)
							self.assertEqual(cl.out   ,       ''''''							)

							# should be able to log warnings again
							logging.set_verbosity_warning()
							with CaptureLogger(UpperCamelCase_							) as cl:
												logger.warning(UpperCamelCase_							)
							self.assertEqual(cl.out   ,       msg + '''\n'''							)

							# restore to the original level
							logging.set_verbosity(UpperCamelCase_							)




		@mockenv(TRANSFORMERS_VERBOSITY='''error'''							)
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							transformers.utils.logging._reset_library_root_logger()
							# this action activates the env var
							UpperCamelCase__       :Tuple							 =			logging.get_logger('''transformers.models.bart.tokenization_bart'''							)

							UpperCamelCase__       :Any							 =			os.getenv('''TRANSFORMERS_VERBOSITY'''   ,       UpperCamelCase_							)
							UpperCamelCase__       :Optional[Any]							 =			logging.log_levels[env_level_str]

							UpperCamelCase__       :int							 =			logging.get_verbosity()
							self.assertEqual(
							    UpperCamelCase_   ,       UpperCamelCase_   ,       F'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'''   ,       )

							# restore to the original level
							UpperCamelCase__       :Union[str, Any]							 =			''''''
							transformers.utils.logging._reset_library_root_logger()




		@mockenv(TRANSFORMERS_VERBOSITY='''super-error'''							)
		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							transformers.utils.logging._reset_library_root_logger()
							UpperCamelCase__       :Dict							 =			logging.logging.getLogger()
							with CaptureLogger(UpperCamelCase_							) as cl:
												# this action activates the env var
												logging.get_logger('''transformers.models.bart.tokenization_bart'''							)
							self.assertIn('''Unknown option TRANSFORMERS_VERBOSITY=super-error'''   ,       cl.out							)

							# no need to restore as nothing was changed




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							transformers.utils.logging._reset_library_root_logger()

							UpperCamelCase__       :Optional[int]							 =			logging.get_logger('''transformers.models.bart.tokenization_bart'''							)
							UpperCamelCase__       :int							 =			'''Testing 1, 2, 3'''

							with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='''1'''							):
												# nothing should be logged as env var disables this method
												with CaptureLogger(UpperCamelCase_							) as cl:
																	logger.warning_advice(UpperCamelCase_							)
												self.assertEqual(cl.out   ,       ''''''							)

							with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=''''''							):
												# should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
												with CaptureLogger(UpperCamelCase_							) as cl:
																	logger.warning_advice(UpperCamelCase_							)
												self.assertEqual(cl.out   ,       msg + '''\n'''							)



def       a				(      )  ->     str:



					'''simple docstring'''






					disable_progress_bar()
					assert are_progress_bars_disabled()

					enable_progress_bar()
					assert not are_progress_bars_disabled()