



"""simple docstring"""







import unittest

from parameterized import parameterized

from transformers import OpenLlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel







class 				UpperCamelCase__       :




      """simple docstring"""




      def __init__(				self    :				int   ,      SCREAMING_SNAKE_CASE_    :				Optional[int]   ,      SCREAMING_SNAKE_CASE_    :				Any=1_3   ,      SCREAMING_SNAKE_CASE_    :				Dict=7   ,      SCREAMING_SNAKE_CASE_    :				List[str]=True   ,      SCREAMING_SNAKE_CASE_    :				int=True   ,      SCREAMING_SNAKE_CASE_    :				Any=False   ,      SCREAMING_SNAKE_CASE_    :				str=True   ,      SCREAMING_SNAKE_CASE_    :				Any=9_9   ,      SCREAMING_SNAKE_CASE_    :				str=3_2   ,      SCREAMING_SNAKE_CASE_    :				Optional[int]=5   ,      SCREAMING_SNAKE_CASE_    :				Dict=4   ,      SCREAMING_SNAKE_CASE_    :				int=3_7   ,      SCREAMING_SNAKE_CASE_    :				Optional[int]="gelu"   ,      SCREAMING_SNAKE_CASE_    :				List[str]=0.1   ,      SCREAMING_SNAKE_CASE_    :				Dict=0.1   ,      SCREAMING_SNAKE_CASE_    :				Union[str, Any]=5_1_2   ,      SCREAMING_SNAKE_CASE_    :				Union[str, Any]=1_6   ,      SCREAMING_SNAKE_CASE_    :				List[Any]=2   ,      SCREAMING_SNAKE_CASE_    :				List[str]=0.02   ,      SCREAMING_SNAKE_CASE_    :				Tuple=3   ,      SCREAMING_SNAKE_CASE_    :				Optional[int]=4   ,      SCREAMING_SNAKE_CASE_    :				Tuple=None   ,      ):
        lowerCAmelCase_       :    str								=			parent
        lowerCAmelCase_       :    Optional[Any]								=			batch_size
        lowerCAmelCase_       :    int								=			seq_length
        lowerCAmelCase_       :    Dict								=			is_training
        lowerCAmelCase_       :    Union[str, Any]								=			use_input_mask
        lowerCAmelCase_       :    Optional[Any]								=			use_token_type_ids
        lowerCAmelCase_       :    Any								=			use_labels
        lowerCAmelCase_       :    List[Any]								=			vocab_size
        lowerCAmelCase_       :    int								=			hidden_size
        lowerCAmelCase_       :    Dict								=			num_hidden_layers
        lowerCAmelCase_       :    Union[str, Any]								=			num_attention_heads
        lowerCAmelCase_       :    str								=			intermediate_size
        lowerCAmelCase_       :    int								=			hidden_act
        lowerCAmelCase_       :    Union[str, Any]								=			hidden_dropout_prob
        lowerCAmelCase_       :    List[Any]								=			attention_probs_dropout_prob
        lowerCAmelCase_       :    List[str]								=			max_position_embeddings
        lowerCAmelCase_       :    Dict								=			type_vocab_size
        lowerCAmelCase_       :    str								=			type_sequence_label_size
        lowerCAmelCase_       :    Optional[int]								=			initializer_range
        lowerCAmelCase_       :    List[str]								=			num_labels
        lowerCAmelCase_       :    int								=			num_choices
        lowerCAmelCase_       :    Union[str, Any]								=			scope



      def 					SCREAMING_SNAKE_CASE__			(				self    :				int	):
        lowerCAmelCase_       :    Optional[int]								=			ids_tensor([self.batch_size, self.seq_length]   ,      self.vocab_size	)

        lowerCAmelCase_       :    Dict								=			None
        if self.use_input_mask:
          lowerCAmelCase_       :    Any								=			random_attention_mask([self.batch_size, self.seq_length]	)

        lowerCAmelCase_       :    Any								=			None
        if self.use_token_type_ids:
          lowerCAmelCase_       :    int								=			ids_tensor([self.batch_size, self.seq_length]   ,      self.type_vocab_size	)

        lowerCAmelCase_       :    Union[str, Any]								=			None
        lowerCAmelCase_       :    List[Any]								=			None
        lowerCAmelCase_       :    str								=			None
        if self.use_labels:
          lowerCAmelCase_       :    List[Any]								=			ids_tensor([self.batch_size]   ,      self.type_sequence_label_size	)
          lowerCAmelCase_       :    Union[str, Any]								=			ids_tensor([self.batch_size, self.seq_length]   ,      self.num_labels	)
          lowerCAmelCase_       :    Optional[int]								=			ids_tensor([self.batch_size]   ,      self.num_choices	)

        lowerCAmelCase_       :    Optional[Any]								=			self.get_config()

        return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Dict	):
        return OpenLlamaConfig(
            vocab_size=self.vocab_size   ,      hidden_size=self.hidden_size   ,      num_hidden_layers=self.num_hidden_layers   ,      num_attention_heads=self.num_attention_heads   ,      intermediate_size=self.intermediate_size   ,      hidden_act=self.hidden_act   ,      hidden_dropout_prob=self.hidden_dropout_prob   ,      attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,      max_position_embeddings=self.max_position_embeddings   ,      type_vocab_size=self.type_vocab_size   ,      is_decoder=SCREAMING_SNAKE_CASE_   ,      initializer_range=self.initializer_range   ,      use_stable_embedding=SCREAMING_SNAKE_CASE_   ,      )



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Optional[int]   ,      SCREAMING_SNAKE_CASE_    :				Optional[Any]   ,      SCREAMING_SNAKE_CASE_    :				Optional[Any]   ,      SCREAMING_SNAKE_CASE_    :				int   ,      SCREAMING_SNAKE_CASE_    :				Union[str, Any]   ,      SCREAMING_SNAKE_CASE_    :				Union[str, Any]   ,      SCREAMING_SNAKE_CASE_    :				Tuple   ,      SCREAMING_SNAKE_CASE_    :				str	):
        lowerCAmelCase_       :    int								=			OpenLlamaModel(config=SCREAMING_SNAKE_CASE_	)
        model.to(SCREAMING_SNAKE_CASE_	)
        model.eval()
        lowerCAmelCase_       :    List[str]								=			model(SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    Union[str, Any]								=			model(SCREAMING_SNAKE_CASE_	)
        self.parent.assertEqual(result.last_hidden_state.shape   ,      (self.batch_size, self.seq_length, self.hidden_size)	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Dict   ,      SCREAMING_SNAKE_CASE_    :				int   ,      SCREAMING_SNAKE_CASE_    :				Tuple   ,      SCREAMING_SNAKE_CASE_    :				Union[str, Any]   ,      SCREAMING_SNAKE_CASE_    :				List[Any]   ,      SCREAMING_SNAKE_CASE_    :				int   ,      SCREAMING_SNAKE_CASE_    :				Optional[int]   ,      SCREAMING_SNAKE_CASE_    :				Any   ,      SCREAMING_SNAKE_CASE_    :				Any   ,      SCREAMING_SNAKE_CASE_    :				List[str]   ,      ):
        lowerCAmelCase_       :    Optional[int]								=			True
        lowerCAmelCase_       :    List[str]								=			OpenLlamaModel(SCREAMING_SNAKE_CASE_	)
        model.to(SCREAMING_SNAKE_CASE_	)
        model.eval()
        lowerCAmelCase_       :    int								=			model(
            SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_   ,      encoder_hidden_states=SCREAMING_SNAKE_CASE_   ,      encoder_attention_mask=SCREAMING_SNAKE_CASE_   ,      )
        lowerCAmelCase_       :    Union[str, Any]								=			model(
            SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_   ,      encoder_hidden_states=SCREAMING_SNAKE_CASE_   ,      )
        lowerCAmelCase_       :    List[Any]								=			model(SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_	)
        self.parent.assertEqual(result.last_hidden_state.shape   ,      (self.batch_size, self.seq_length, self.hidden_size)	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				int   ,      SCREAMING_SNAKE_CASE_    :				Optional[Any]   ,      SCREAMING_SNAKE_CASE_    :				Optional[int]   ,      SCREAMING_SNAKE_CASE_    :				Any   ,      SCREAMING_SNAKE_CASE_    :				Any   ,      SCREAMING_SNAKE_CASE_    :				Dict   ,      SCREAMING_SNAKE_CASE_    :				Tuple   ,      SCREAMING_SNAKE_CASE_    :				Union[str, Any]   ,      SCREAMING_SNAKE_CASE_    :				str   ,      SCREAMING_SNAKE_CASE_    :				List[Any]   ,      ):
        lowerCAmelCase_       :    List[str]								=			OpenLlamaForCausalLM(config=SCREAMING_SNAKE_CASE_	)
        model.to(SCREAMING_SNAKE_CASE_	)
        model.eval()
        lowerCAmelCase_       :    str								=			model(SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_   ,      labels=SCREAMING_SNAKE_CASE_	)
        self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.seq_length, self.vocab_size)	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				List[str]   ,      SCREAMING_SNAKE_CASE_    :				Any   ,      SCREAMING_SNAKE_CASE_    :				Tuple   ,      SCREAMING_SNAKE_CASE_    :				str   ,      SCREAMING_SNAKE_CASE_    :				Any   ,      SCREAMING_SNAKE_CASE_    :				List[str]   ,      SCREAMING_SNAKE_CASE_    :				List[Any]   ,      SCREAMING_SNAKE_CASE_    :				Tuple   ,      SCREAMING_SNAKE_CASE_    :				Tuple   ,      SCREAMING_SNAKE_CASE_    :				List[Any]   ,      ):
        lowerCAmelCase_       :    str								=			True
        lowerCAmelCase_       :    Union[str, Any]								=			True
        lowerCAmelCase_       :    str								=			OpenLlamaForCausalLM(config=SCREAMING_SNAKE_CASE_	)
        model.to(SCREAMING_SNAKE_CASE_	)
        model.eval()

        # first forward pass
        lowerCAmelCase_       :    int								=			model(
            SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_   ,      encoder_hidden_states=SCREAMING_SNAKE_CASE_   ,      encoder_attention_mask=SCREAMING_SNAKE_CASE_   ,      use_cache=SCREAMING_SNAKE_CASE_   ,      )
        lowerCAmelCase_       :    str								=			outputs.past_key_values

        # create hypothetical multiple next token and extent to next_input_ids
        lowerCAmelCase_       :    int								=			ids_tensor((self.batch_size, 3)   ,      config.vocab_size	)
        lowerCAmelCase_       :    Tuple								=			ids_tensor((self.batch_size, 3)   ,      vocab_size=2	)

        # append to next input_ids and
        lowerCAmelCase_       :    Union[str, Any]								=			torch.cat([input_ids, next_tokens]   ,      dim=-1	)
        lowerCAmelCase_       :    Dict								=			torch.cat([input_mask, next_mask]   ,      dim=-1	)

        lowerCAmelCase_       :    int								=			model(
            SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_   ,      encoder_hidden_states=SCREAMING_SNAKE_CASE_   ,      encoder_attention_mask=SCREAMING_SNAKE_CASE_   ,      output_hidden_states=SCREAMING_SNAKE_CASE_   ,      )['hidden_states'][0]
        lowerCAmelCase_       :    int								=			model(
            SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_   ,      encoder_hidden_states=SCREAMING_SNAKE_CASE_   ,      encoder_attention_mask=SCREAMING_SNAKE_CASE_   ,      past_key_values=SCREAMING_SNAKE_CASE_   ,      output_hidden_states=SCREAMING_SNAKE_CASE_   ,      )['hidden_states'][0]

        # select random slice
        lowerCAmelCase_       :    Optional[int]								=			ids_tensor((1,)   ,      output_from_past.shape[-1]	).item()
        lowerCAmelCase_       :    Optional[int]								=			output_from_no_past[:, -3:, random_slice_idx].detach()
        lowerCAmelCase_       :    Optional[int]								=			output_from_past[:, :, random_slice_idx].detach()

        self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]	)

        # test that outputs are equal for slice
        self.parent.assertTrue(torch.allclose(SCREAMING_SNAKE_CASE_   ,      SCREAMING_SNAKE_CASE_   ,      atol=1E-3	)	)





      def 					SCREAMING_SNAKE_CASE__			(				self    :				int	):
        lowerCAmelCase_       :    Any								=			self.prepare_config_and_inputs()
        (
            (
            lowerCAmelCase_
        )						,(
            lowerCAmelCase_
        )						,(
            lowerCAmelCase_
        )						,(
            lowerCAmelCase_
        )						,(
            lowerCAmelCase_
        )						,(
            lowerCAmelCase_
        )						,(
            lowerCAmelCase_
        )						,
        )       :    Dict								=			config_and_inputs
        lowerCAmelCase_       :    Dict								=			{'input_ids': input_ids, 'attention_mask': input_mask}
        return config, inputs_dict







@require_torch
class 				UpperCamelCase__       (     lowercase_, lowercase_, lowercase_, unittest.TestCase  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE      =					(
          (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
      )
      _SCREAMING_SNAKE_CASE      =					(OpenLlamaForCausalLM,) if is_torch_available() else ()
      _SCREAMING_SNAKE_CASE      =					(
          {
              """feature-extraction""": OpenLlamaModel,
              """text-classification""": OpenLlamaForSequenceClassification,
              """text-generation""": OpenLlamaForCausalLM,
              """zero-shot""": OpenLlamaForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      _SCREAMING_SNAKE_CASE      =					False
      _SCREAMING_SNAKE_CASE      =					False



      def 					SCREAMING_SNAKE_CASE__			(				self    :				int	):
        lowerCAmelCase_       :    int								=			OpenLlamaModelTester(self	)
        lowerCAmelCase_       :    List[Any]								=			ConfigTester(self   ,      config_class=SCREAMING_SNAKE_CASE_   ,      hidden_size=3_7	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Any	):
        self.config_tester.run_common_tests()



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Tuple	):
        lowerCAmelCase_       :    Optional[Any]								=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Optional[int]	):
        lowerCAmelCase_       :    Optional[Any]								=			self.model_tester.prepare_config_and_inputs()
        for type in ["absolute", "relative_key", "relative_key_query"]:
          lowerCAmelCase_       :    str								=			type
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Any	):
        lowerCAmelCase_						,lowerCAmelCase_       :    List[str]								=			self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase_       :    Union[str, Any]								=			3
        lowerCAmelCase_       :    Any								=			input_dict['input_ids']
        lowerCAmelCase_       :    Dict								=			input_ids.ne(1	).to(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    Optional[Any]								=			ids_tensor([self.model_tester.batch_size]   ,      self.model_tester.type_sequence_label_size	)
        lowerCAmelCase_       :    List[Any]								=			OpenLlamaForSequenceClassification(SCREAMING_SNAKE_CASE_	)
        model.to(SCREAMING_SNAKE_CASE_	)
        model.eval()
        lowerCAmelCase_       :    List[str]								=			model(SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_   ,      labels=SCREAMING_SNAKE_CASE_	)
        self.assertEqual(result.logits.shape   ,      (self.model_tester.batch_size, self.model_tester.num_labels)	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Optional[Any]	):
        lowerCAmelCase_						,lowerCAmelCase_       :    List[Any]								=			self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase_       :    Tuple								=			3
        lowerCAmelCase_       :    int								=			'single_label_classification'
        lowerCAmelCase_       :    int								=			input_dict['input_ids']
        lowerCAmelCase_       :    str								=			input_ids.ne(1	).to(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    str								=			ids_tensor([self.model_tester.batch_size]   ,      self.model_tester.type_sequence_label_size	)
        lowerCAmelCase_       :    List[str]								=			OpenLlamaForSequenceClassification(SCREAMING_SNAKE_CASE_	)
        model.to(SCREAMING_SNAKE_CASE_	)
        model.eval()
        lowerCAmelCase_       :    List[Any]								=			model(SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_   ,      labels=SCREAMING_SNAKE_CASE_	)
        self.assertEqual(result.logits.shape   ,      (self.model_tester.batch_size, self.model_tester.num_labels)	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				str	):
        lowerCAmelCase_						,lowerCAmelCase_       :    str								=			self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase_       :    Tuple								=			3
        lowerCAmelCase_       :    List[str]								=			'multi_label_classification'
        lowerCAmelCase_       :    Tuple								=			input_dict['input_ids']
        lowerCAmelCase_       :    int								=			input_ids.ne(1	).to(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    int								=			ids_tensor(
            [self.model_tester.batch_size, config.num_labels]   ,      self.model_tester.type_sequence_label_size	).to(torch.float	)
        lowerCAmelCase_       :    List[str]								=			OpenLlamaForSequenceClassification(SCREAMING_SNAKE_CASE_	)
        model.to(SCREAMING_SNAKE_CASE_	)
        model.eval()
        lowerCAmelCase_       :    Optional[Any]								=			model(SCREAMING_SNAKE_CASE_   ,      attention_mask=SCREAMING_SNAKE_CASE_   ,      labels=SCREAMING_SNAKE_CASE_	)
        self.assertEqual(result.logits.shape   ,      (self.model_tester.batch_size, self.model_tester.num_labels)	)



      @unittest.skip('Open-Llama buffers include complex numbers, which breaks this test'	)
      def 					SCREAMING_SNAKE_CASE__			(				self    :				List[str]	):
        pass





      @parameterized.expand([('linear',), ('dynamic',)]	)
      def 					SCREAMING_SNAKE_CASE__			(				self    :				List[Any]   ,      SCREAMING_SNAKE_CASE_    :				Any	):
        lowerCAmelCase_						,lowerCAmelCase_       :    Any								=			self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase_       :    Optional[Any]								=			ids_tensor([1, 1_0]   ,      config.vocab_size	)
        lowerCAmelCase_       :    List[str]								=			ids_tensor([1, int(config.max_position_embeddings * 1.5	)]   ,      config.vocab_size	)

        set_seed(4_2	)  # Fixed seed at init time so the two models get the same random weights
        lowerCAmelCase_       :    Tuple								=			OpenLlamaModel(SCREAMING_SNAKE_CASE_	)
        original_model.to(SCREAMING_SNAKE_CASE_	)
        original_model.eval()
        lowerCAmelCase_       :    str								=			original_model(SCREAMING_SNAKE_CASE_	).last_hidden_state
        lowerCAmelCase_       :    Dict								=			original_model(SCREAMING_SNAKE_CASE_	).last_hidden_state

        set_seed(4_2	)  # Fixed seed at init time so the two models get the same random weights
        lowerCAmelCase_       :    Optional[Any]								=			{'type': scaling_type, 'factor': 10.0}
        lowerCAmelCase_       :    Optional[Any]								=			OpenLlamaModel(SCREAMING_SNAKE_CASE_	)
        scaled_model.to(SCREAMING_SNAKE_CASE_	)
        scaled_model.eval()
        lowerCAmelCase_       :    Optional[Any]								=			scaled_model(SCREAMING_SNAKE_CASE_	).last_hidden_state
        lowerCAmelCase_       :    str								=			scaled_model(SCREAMING_SNAKE_CASE_	).last_hidden_state

        # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
        # maximum sequence length, so the outputs for the short input should match.
        if scaling_type == "dynamic":
          self.assertTrue(torch.allclose(SCREAMING_SNAKE_CASE_   ,      SCREAMING_SNAKE_CASE_   ,      atol=1E-5	)	)
        else:
          self.assertFalse(torch.allclose(SCREAMING_SNAKE_CASE_   ,      SCREAMING_SNAKE_CASE_   ,      atol=1E-5	)	)

        # The output should be different for long inputs
        self.assertFalse(torch.allclose(SCREAMING_SNAKE_CASE_   ,      SCREAMING_SNAKE_CASE_   ,      atol=1E-5	)	)










"""simple docstring"""







def     UpperCamelCase_   (   lowerCAmelCase__				:    Optional[Any]   ,       lowerCAmelCase__				:    str						)						->       List[Any]:

  """simple docstring"""




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

def     UpperCamelCase_   (   lowerCAmelCase__				:    List[Any]   ,       lowerCAmelCase__				:    str=0						)						->       Union[str, Any]:

  """simple docstring"""




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

def     UpperCamelCase_   (   lowerCAmelCase__				:    Dict   ,       lowerCAmelCase__				:    Optional[int]   ,       lowerCAmelCase__				:    Optional[Any]=float('inf'						)						)						->       Optional[int]:

  """simple docstring"""




  for i in range(points_counts - 1						):
    for j in range(i + 1   ,       lowerCAmelCase__						):
      lowerCAmelCase_       :    Union[str, Any]								=			euclidean_distance_sqr(points[i]   ,       points[j]						)
      if current_dis < min_dis:
        lowerCAmelCase_       :    Optional[int]								=			current_dis
  return min_dis

def     UpperCamelCase_   (   lowerCAmelCase__				:    List[Any]   ,       lowerCAmelCase__				:    Dict   ,       lowerCAmelCase__				:    Union[str, Any]=float('inf'						)						)						->       Dict:

  """simple docstring"""




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

def     UpperCamelCase_   (   lowerCAmelCase__				:    Dict   ,       lowerCAmelCase__				:    int   ,       lowerCAmelCase__				:    Optional[int]						)						->       Dict:

  """simple docstring"""




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

  # recursion
  lowerCAmelCase_       :    int								=			points_counts // 2
  lowerCAmelCase_       :    Optional[Any]								=			closest_pair_of_points_sqr(
      lowerCAmelCase__   ,       points_sorted_on_y[:mid]   ,       lowerCAmelCase__						)
  lowerCAmelCase_       :    Optional[Any]								=			closest_pair_of_points_sqr(
      lowerCAmelCase__   ,       points_sorted_on_y[mid:]   ,       points_counts - mid						)
  lowerCAmelCase_       :    Any								=			min(lowerCAmelCase__   ,       lowerCAmelCase__						)
  lowerCAmelCase_       :    str								=			[]
  for point in points_sorted_on_x:
    if abs(point[0] - points_sorted_on_x[mid][0]						) < closest_pair_dis:
      cross_strip.append(lowerCAmelCase__						)

  lowerCAmelCase_       :    List[Any]								=			dis_between_closest_in_strip(
      lowerCAmelCase__   ,       len(lowerCAmelCase__						)   ,       lowerCAmelCase__						)
  return min(lowerCAmelCase__   ,       lowerCAmelCase__						)

def     UpperCamelCase_   (   lowerCAmelCase__				:    str   ,       lowerCAmelCase__				:    Tuple						)						->       List[Any]:

  """simple docstring"""




  lowerCAmelCase_       :    List[str]								=			column_based_sort(lowerCAmelCase__   ,       column=0						)
  lowerCAmelCase_       :    Dict								=			column_based_sort(lowerCAmelCase__   ,       column=1						)
  return (
      closest_pair_of_points_sqr(
          lowerCAmelCase__   ,       lowerCAmelCase__   ,       lowerCAmelCase__						)
  ) ** 0.5


if __name__ == "__main__":
     lowercase__		:    List[str]				   =     [(2, 3), (1_2, 3_0), (4_0, 5_0), (5, 1), (1_2, 1_0), (3, 4)]
     print("""Distance:""", closest_pair_of_points(points, len(points)))





