



import re
import string

import numpy as np

import datasets


__UpperCAmelCase          =       '''
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
'''

__UpperCAmelCase          =       '''
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    25.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    50.0


    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    75.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results["exact_match"], 1))
    100.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]
    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    33.3

'''

__UpperCAmelCase          =       '''
'''



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION       ,    _KWARGS_DESCRIPTION							)
class 				lowerCAmelCase_		(  datasets.Metric							):
       def 					snake_case_       (			self       )     ->		Any:
          return datasets.MetricInfo(
              description=_DESCRIPTION,			citation=_CITATION,			inputs_description=_KWARGS_DESCRIPTION,			features=datasets.Features(
                  {
                      'predictions': datasets.Value('string',			id='sequence'       ),
                      'references': datasets.Value('string',			id='sequence'       ),
                  }       ),			reference_urls=[],			)






       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_=None,			SCREAMING_SNAKE_CASE_=False,			SCREAMING_SNAKE_CASE_=False,			SCREAMING_SNAKE_CASE_=False,			)     ->		Optional[Any]:
          if regexes_to_ignore is not None:
             for s in regexes_to_ignore:
                UpperCamelCase    :  Any							=	np.array([re.sub(SCREAMING_SNAKE_CASE_,			'',			SCREAMING_SNAKE_CASE_       ) for x in predictions]       )
                UpperCamelCase    :  List[Any]							=	np.array([re.sub(SCREAMING_SNAKE_CASE_,			'',			SCREAMING_SNAKE_CASE_       ) for x in references]       )
          else:
             UpperCamelCase    :  Tuple							=	np.asarray(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  Union[str, Any]							=	np.asarray(SCREAMING_SNAKE_CASE_       )

          if ignore_case:
             UpperCamelCase    :  Dict							=	np.char.lower(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  List[Any]							=	np.char.lower(SCREAMING_SNAKE_CASE_       )

          if ignore_punctuation:
             UpperCamelCase    :  List[Any]							=	string.punctuation.maketrans('',			'',			string.punctuation       )
             UpperCamelCase    :  Optional[Any]							=	np.char.translate(SCREAMING_SNAKE_CASE_,			table=SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  Union[str, Any]							=	np.char.translate(SCREAMING_SNAKE_CASE_,			table=SCREAMING_SNAKE_CASE_       )

          if ignore_numbers:
             UpperCamelCase    :  List[str]							=	string.digits.maketrans('',			'',			string.digits       )
             UpperCamelCase    :  Union[str, Any]							=	np.char.translate(SCREAMING_SNAKE_CASE_,			table=SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  Tuple							=	np.char.translate(SCREAMING_SNAKE_CASE_,			table=SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  int							=	predictions == references

          return {"exact_match": np.mean(SCREAMING_SNAKE_CASE_       ) * 100}








from __future__ import annotations

from typing import Any



class 				lowerCAmelCase_		:
       def __init__(			self,			SCREAMING_SNAKE_CASE_       )     ->		None:
          UpperCamelCase    :  Any							=	num_of_nodes
          UpperCamelCase    :  list[list[int]]							=	[]
          UpperCamelCase    :  dict[int, int]							=	{}
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		None:
          self.m_edges.append([u_node, v_node, weight]       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_       )     ->		int:

          if self.m_component[u_node] == u_node:
             return u_node
          return self.find_component(self.m_component[u_node]       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_       )     ->		None:

          if self.m_component[u_node] != u_node:
             for k in self.m_component:
                UpperCamelCase    :  Dict							=	self.find_component(SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		None:

          if component_size[u_node] <= component_size[v_node]:
             UpperCamelCase    :  Tuple							=	v_node
             component_size[v_node] += component_size[u_node]
             self.set_component(SCREAMING_SNAKE_CASE_       )

          elif component_size[u_node] >= component_size[v_node]:
             UpperCamelCase    :  Union[str, Any]							=	self.find_component(SCREAMING_SNAKE_CASE_       )
             component_size[u_node] += component_size[v_node]
             self.set_component(SCREAMING_SNAKE_CASE_       )






       def 					snake_case_       (			self       )     ->		None:
          UpperCamelCase    :  int							=	[]
          UpperCamelCase    :  int							=	0

          UpperCamelCase    :  list[Any]							=	[-1] * self.m_num_of_nodes

          # A list of components (initialized to all of the nodes)
          for node in range(self.m_num_of_nodes       ):
             self.m_component.update({node: node}       )
             component_size.append(1       )

          UpperCamelCase    :  List[str]							=	self.m_num_of_nodes

          while num_of_components > 1:
             for edge in self.m_edges:
                UpperCamelCase	,     UpperCamelCase	,     UpperCamelCase    :  List[Any]							=	edge

                UpperCamelCase    :  str							=	self.m_component[u]
                UpperCamelCase    :  Any							=	self.m_component[v]

                if u_component != v_component:

                   for component in (u_component, v_component):
                      if (
                          minimum_weight_edge[component] == -1
                          or minimum_weight_edge[component][2] > w
                      ):
                         UpperCamelCase    :  Any							=	[u, v, w]

             for edge in minimum_weight_edge:
                if isinstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       ):
                   UpperCamelCase	,     UpperCamelCase	,     UpperCamelCase    :  int							=	edge

                   UpperCamelCase    :  List[Any]							=	self.m_component[u]
                   UpperCamelCase    :  Tuple							=	self.m_component[v]

                   if u_component != v_component:
                      mst_weight += w
                      self.union(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
                      print(F"""Added edge [{u} - {v}]\nAdded weight: {w}\n"""       )
                      num_of_components -= 1

             UpperCamelCase    :  Optional[Any]							=	[-1] * self.m_num_of_nodes
          print(F"""The total weight of the minimal spanning tree is: {mst_weight}"""       )






def 		UpperCamelCase	(   )	->     None:
   pass


if __name__ == "__main__":
    import doctest

    doctest.testmod()



