abydos.distance._strcmp95.Strcmp95.sim()

Complexity

Conditions

37

Size

Total Lines	150
Code Lines	77

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	69
CRAP Score	37

Importance

Changes

0

# -*- coding: utf-8 -*-
    def sim(self, src, tar, long_strings=False):

This function exceeds the maximum number of variables (24/15).

Parameters differ from overridden 'sim' method

        """Return the strcmp95 similarity of two strings.

        Args:
            src (str): Source string for comparison
            tar (str): Target string for comparison
            long_strings (bool): Set to True to increase the probability of a
                match when the number of matched characters is large. This
                option allows for a little more tolerance when the strings are
                large. It is not an appropriate test when comparing fixed
                length fields such as phone and social security numbers.

        Returns:
            float: Strcmp95 similarity

        Examples:
            >>> cmp = Strcmp95()
            >>> cmp.sim('cat', 'hat')
            0.7777777777777777
            >>> cmp.sim('Niall', 'Neil')
            0.8454999999999999
            >>> cmp.sim('aluminum', 'Catalan')
            0.6547619047619048
            >>> cmp.sim('ATCG', 'TAGC')
            0.8333333333333334

        """

        def _in_range(char):
            """Return True if char is in the range (0, 91).

            Args:
                char (str): The character to check

            Returns:
                bool: True if char is in the range (0, 91)

            """
            return 91 > ord(char) > 0

        ying = src.strip().upper()
        yang = tar.strip().upper()

        if ying == yang:
            return 1.0
        # If either string is blank - return - added in Version 2
        if not ying or not yang:
            return 0.0

        adjwt = defaultdict(int)

        # Initialize the adjwt array on the first call to the function only.
        # The adjwt array is used to give partial credit for characters that
        # may be errors due to known phonetic or character recognition errors.
        # A typical example is to match the letter "O" with the number "0"
        for i in self._sp_mx:
            adjwt[(i[0], i[1])] = 3
            adjwt[(i[1], i[0])] = 3

        if len(ying) > len(yang):
            search_range = len(ying)
            minv = len(yang)
        else:
            search_range = len(yang)
            minv = len(ying)

        # Blank out the flags
        ying_flag = [0] * search_range
        yang_flag = [0] * search_range
        search_range = max(0, search_range // 2 - 1)

        # Looking only within the search range,
        # count and flag the matched pairs.
        num_com = 0
        yl1 = len(yang) - 1
        for i in range(len(ying)):

Consider using enumerate instead of iterating with range and len

            low_lim = (i - search_range) if (i >= search_range) else 0
            hi_lim = (i + search_range) if ((i + search_range) <= yl1) else yl1
            for j in range(low_lim, hi_lim + 1):
                if (yang_flag[j] == 0) and (yang[j] == ying[i]):
                    yang_flag[j] = 1
                    ying_flag[i] = 1
                    num_com += 1
                    break

        # If no characters in common - return
        if num_com == 0:
            return 0.0

        # Count the number of transpositions
        k = n_trans = 0
        for i in range(len(ying)):

Consider using enumerate instead of iterating with range and len

            if ying_flag[i] != 0:
                j = 0
                for j in range(k, len(yang)):  # pragma: no branch
                    if yang_flag[j] != 0:
                        k = j + 1
                        break
                if ying[i] != yang[j]:
                    n_trans += 1
        n_trans //= 2

        # Adjust for similarities in unmatched characters
        n_simi = 0
        if minv > num_com:

Too many nested blocks (6/5)

            for i in range(len(ying)):

Consider using enumerate instead of iterating with range and len

                if ying_flag[i] == 0 and _in_range(ying[i]):
                    for j in range(len(yang)):

Consider using enumerate instead of iterating with range and len

                        if yang_flag[j] == 0 and _in_range(yang[j]):
                            if (ying[i], yang[j]) in adjwt:
                                n_simi += adjwt[(ying[i], yang[j])]
                                yang_flag[j] = 2
                                break
        num_sim = n_simi / 10.0 + num_com

        # Main weight computation
        weight = (
            num_sim / len(ying)
            + num_sim / len(yang)
            + (num_com - n_trans) / num_com
        )
        weight /= 3.0

        # Continue to boost the weight if the strings are similar
        if weight > 0.7:

            # Adjust for having up to the first 4 characters in common
            j = 4 if (minv >= 4) else minv
            i = 0
            while (i < j) and (ying[i] == yang[i]) and (not ying[i].isdigit()):
                i += 1
            if i:
                weight += i * 0.1 * (1.0 - weight)

            # Optionally adjust for long strings.

            # After agreeing beginning chars, at least two more must agree and
            # the agreeing characters must be > .5 of remaining characters.
            if (
                long_strings

Wrong hanging indentation before block (add 4 spaces).

                and (minv > 4)

Wrong hanging indentation before block (add 4 spaces).

                and (num_com > i + 1)

Wrong hanging indentation before block (add 4 spaces).

                and (2 * num_com >= minv + i)

Wrong hanging indentation before block (add 4 spaces).

            ):
                if not ying[0].isdigit():
                    weight += (1.0 - weight) * (
                        (num_com - i - 1) / (len(ying) + len(yang) - i * 2 + 2)
                    )

        return weight