<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def compute_composite_distance(distance, x, y):
 """ Compute the value of a composite distance function on two dictionaries, typically SFrame rows. Parameters distance : list[list] A composite distance function. Composite distance functions are a weighted sum of standard distance functions, each of which applies to its own subset of features. Composite distance functions are specified as a list of distance components, each of which is itself a list containing three items: 1. list or tuple of feature names (strings) 2. standard distance name (string) 3. scaling factor (int or float) x, y : dict Individual observations, typically rows of an SFrame, in dictionary form. Must include the features specified by `distance`. Returns ------- out : float The distance between `x` and `y`, as specified by `distance`. Examples -------- 1.95286120899 """


    ## Validate inputs
    _validate_composite_distance(distance)
    distance = _convert_distance_names_to_functions(distance)

    if not isinstance(x, dict) or not isinstance(y, dict):
        raise TypeError("Inputs 'x' and 'y' must be in dictionary form. " +
                        "Selecting individual rows of an SFrame yields the " +
                        "correct format.")

    ans = 0.

    for d in distance:
        ftrs, dist, weight = d

        ## Special check for multiple columns with levenshtein distance.
        if dist == _tc.distances.levenshtein and len(ftrs) > 1:
            raise ValueError("levenshtein distance cannot be used with multiple" +
                             "columns. Please concatenate strings into a single " +
                             "column before computing the distance.")

        ## Extract values for specified features.
        a = {}
        b = {}

        for ftr in ftrs:
            if type(x[ftr]) != type(y[ftr]):
                if not isinstance(x[ftr], (int, float)) or not isinstance(y[ftr], (int, float)):
                    raise ValueError("Input data has different types.")

            if isinstance(x[ftr], (int, float, str)):
                a[ftr] = x[ftr]
                b[ftr] = y[ftr]

            elif isinstance(x[ftr], dict):
                for key, val in _six.iteritems(x[ftr]):
                    a['{}.{}'.format(ftr, key)] = val

                for key, val in _six.iteritems(y[ftr]):
                    b['{}.{}'.format(ftr, key)] = val

            elif isinstance(x[ftr], (list, _array.array)):
                for i, val in enumerate(x[ftr]):
                    a[i] = val

                for i, val in enumerate(y[ftr]):
                    b[i] = val

            else:
                raise TypeError("Type of feature '{}' not understood.".format(ftr))


        ## Pull out the raw values for levenshtein
        if dist == _tc.distances.levenshtein:
            a = list(a.values())[0]
            b = list(b.values())[0]

        ## Compute component distance and add to the total distance.
        ans += weight * dist(a, b)

    return ans