code: def min_edit_distance(
          source: Sequence[T], target: Sequence[T],
          ins_cost: Callable[..., int] = lambda _x: 1,
          del_cost: Callable[..., int] = lambda _x: 1,
          sub_cost: Callable[..., int] = lambda x, y: 0 if x == y else 1) -> int:
      
  
      # Initialize an m+1 by n+1 array. Note that the strings start from index 1,
      # with index 0 being used to denote the empty string.
      n = len(target)
      m = len(source)
      distance = np.zeros((m+1, n+1), dtype=np.int16)
  
      # Initialize the zeroth row and column to be the distance from the empty
      # string.
      for i in range(1, m+1):
          distance[i, 0] = distance[i-1, 0] + ins_cost(source[i-1])
      for j in range(1, n+1):
          distance[0, j] = distance[0, j-1] + ins_cost(target[j-1])
  
      # Do the dynamic programming to fill in the matrix with the edit distances.
      for j in range(1, n+1):
          for i in range(1, m+1):
              distance[i, j] = min(
                      distance[i-1, j] + ins_cost(source[i-1]),
                      distance[i-1, j-1] + sub_cost(source[i-1],target[j-1]),
                      distance[i, j-1] + del_cost(target[j-1]))
  
      return int(distance[len(source), len(target)])
docs: Calculates the minimum edit distance between two sequences.
  
      Uses the Levenshtein weighting as a default, but offers keyword arguments
      to supply functions to measure the costs for editing with different
      elements.
  
      Args:
          ins_cost: A function describing the cost of inserting a given char
          del_cost: A function describing the cost of deleting a given char
          sub_cost: A function describing the cost of substituting one char for
  
      Returns:
          The edit distance between the two input sequences.