chrislit /
abydos
| Conditions | 31 |
| Total Lines | 165 |
| Code Lines | 75 |
| Lines | 0 |
| Ratio | 0 % |
| Tests | 57 |
| CRAP Score | 31 |
| Changes | 0 | ||
Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.
For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.
Commonly applied refactorings include:
If many parameters/temporary variables are present:
Complex classes like abydos.distance._jaro_winkler.JaroWinkler.sim() often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
Methods with many parameters are not only hard to understand, but their parameters also often become inconsistent when you need more, or different data.
There are several approaches to avoid long parameter lists:
| 1 | # -*- coding: utf-8 -*- |
||
| 55 | 1 | def sim( |
|
| 56 | self, |
||
| 57 | src, |
||
| 58 | tar, |
||
| 59 | qval=1, |
||
| 60 | mode='winkler', |
||
| 61 | long_strings=False, |
||
| 62 | boost_threshold=0.7, |
||
| 63 | scaling_factor=0.1, |
||
| 64 | ): |
||
| 65 | """Return the Jaro or Jaro-Winkler similarity of two strings. |
||
| 66 | |||
| 67 | Args: |
||
| 68 | src (str): Source string for comparison |
||
| 69 | tar (str): Target string for comparison |
||
| 70 | qval (int): The length of each q-gram (defaults to 1: |
||
| 71 | character-wise matching) |
||
| 72 | mode (str): Indicates which variant of this distance metric to |
||
| 73 | compute: |
||
| 74 | - ``winkler`` -- computes the Jaro-Winkler distance |
||
| 75 | (default) which increases the score for matches near the |
||
| 76 | start of the word |
||
| 77 | - ``jaro`` -- computes the Jaro distance |
||
| 78 | long_strings (bool): Set to True to "Increase the probability of a |
||
| 79 | match when the number of matched characters is large. This |
||
| 80 | option allows for a little more tolerance when the strings are |
||
| 81 | large. It is not an appropriate test when comparing fixed |
||
| 82 | length fields such as phone and social security numbers." |
||
| 83 | (Used in 'winkler' mode only.) |
||
| 84 | boost_threshold (float): A value between 0 and 1, below which the |
||
| 85 | Winkler boost is not applied (defaults to 0.7). (Used in |
||
| 86 | 'winkler' mode only.) |
||
| 87 | scaling_factor (float): A value between 0 and 0.25, indicating by |
||
| 88 | how much to boost scores for matching prefixes (defaults to |
||
| 89 | 0.1). (Used in 'winkler' mode only.) |
||
| 90 | |||
| 91 | Returns: |
||
| 92 | float: Jaro or Jaro-Winkler similarity |
||
| 93 | |||
| 94 | Raises: |
||
| 95 | ValueError: Unsupported boost_threshold assignment; boost_threshold |
||
| 96 | must be between 0 and 1. |
||
| 97 | ValueError: Unsupported scaling_factor assignment; scaling_factor |
||
| 98 | must be between 0 and 0.25.' |
||
| 99 | |||
| 100 | Examples: |
||
| 101 | >>> round(sim_jaro_winkler('cat', 'hat'), 12) |
||
| 102 | 0.777777777778 |
||
| 103 | >>> round(sim_jaro_winkler('Niall', 'Neil'), 12) |
||
| 104 | 0.805 |
||
| 105 | >>> round(sim_jaro_winkler('aluminum', 'Catalan'), 12) |
||
| 106 | 0.60119047619 |
||
| 107 | >>> round(sim_jaro_winkler('ATCG', 'TAGC'), 12) |
||
| 108 | 0.833333333333 |
||
| 109 | |||
| 110 | >>> round(sim_jaro_winkler('cat', 'hat', mode='jaro'), 12) |
||
| 111 | 0.777777777778 |
||
| 112 | >>> round(sim_jaro_winkler('Niall', 'Neil', mode='jaro'), 12) |
||
| 113 | 0.783333333333 |
||
| 114 | >>> round(sim_jaro_winkler('aluminum', 'Catalan', mode='jaro'), 12) |
||
| 115 | 0.60119047619 |
||
| 116 | >>> round(sim_jaro_winkler('ATCG', 'TAGC', mode='jaro'), 12) |
||
| 117 | 0.833333333333 |
||
| 118 | |||
| 119 | """ |
||
| 120 | 1 | if mode == 'winkler': |
|
| 121 | 1 | if boost_threshold > 1 or boost_threshold < 0: |
|
| 122 | 1 | raise ValueError( |
|
| 123 | 'Unsupported boost_threshold assignment; ' |
||
| 124 | + 'boost_threshold must be between 0 and 1.' |
||
| 125 | ) |
||
| 126 | 1 | if scaling_factor > 0.25 or scaling_factor < 0: |
|
| 127 | 1 | raise ValueError( |
|
| 128 | 'Unsupported scaling_factor assignment; ' |
||
| 129 | + 'scaling_factor must be between 0 and 0.25.' |
||
| 130 | ) |
||
| 131 | |||
| 132 | 1 | if src == tar: |
|
| 133 | 1 | return 1.0 |
|
| 134 | |||
| 135 | 1 | src = QGrams(src.strip(), qval).ordered_list |
|
| 136 | 1 | tar = QGrams(tar.strip(), qval).ordered_list |
|
| 137 | |||
| 138 | 1 | lens = len(src) |
|
| 139 | 1 | lent = len(tar) |
|
| 140 | |||
| 141 | # If either string is blank - return - added in Version 2 |
||
| 142 | 1 | if lens == 0 or lent == 0: |
|
| 143 | 1 | return 0.0 |
|
| 144 | |||
| 145 | 1 | if lens > lent: |
|
| 146 | 1 | search_range = lens |
|
| 147 | 1 | minv = lent |
|
| 148 | else: |
||
| 149 | 1 | search_range = lent |
|
| 150 | 1 | minv = lens |
|
| 151 | |||
| 152 | # Zero out the flags |
||
| 153 | 1 | src_flag = [0] * search_range |
|
| 154 | 1 | tar_flag = [0] * search_range |
|
| 155 | 1 | search_range = max(0, search_range // 2 - 1) |
|
| 156 | |||
| 157 | # Looking only within the search range, |
||
| 158 | # count and flag the matched pairs. |
||
| 159 | 1 | num_com = 0 |
|
| 160 | 1 | yl1 = lent - 1 |
|
| 161 | 1 | for i in range(lens): |
|
| 162 | 1 | low_lim = (i - search_range) if (i >= search_range) else 0 |
|
| 163 | 1 | hi_lim = (i + search_range) if ((i + search_range) <= yl1) else yl1 |
|
| 164 | 1 | for j in range(low_lim, hi_lim + 1): |
|
| 165 | 1 | if (tar_flag[j] == 0) and (tar[j] == src[i]): |
|
| 166 | 1 | tar_flag[j] = 1 |
|
| 167 | 1 | src_flag[i] = 1 |
|
| 168 | 1 | num_com += 1 |
|
| 169 | 1 | break |
|
| 170 | |||
| 171 | # If no characters in common - return |
||
| 172 | 1 | if num_com == 0: |
|
| 173 | 1 | return 0.0 |
|
| 174 | |||
| 175 | # Count the number of transpositions |
||
| 176 | 1 | k = n_trans = 0 |
|
| 177 | 1 | for i in range(lens): |
|
| 178 | 1 | if src_flag[i] != 0: |
|
| 179 | 1 | j = 0 |
|
| 180 | 1 | for j in range(k, lent): # pragma: no branch |
|
| 181 | 1 | if tar_flag[j] != 0: |
|
| 182 | 1 | k = j + 1 |
|
| 183 | 1 | break |
|
| 184 | 1 | if src[i] != tar[j]: |
|
| 185 | 1 | n_trans += 1 |
|
| 186 | 1 | n_trans //= 2 |
|
| 187 | |||
| 188 | # Main weight computation for Jaro distance |
||
| 189 | 1 | weight = ( |
|
| 190 | num_com / lens + num_com / lent + (num_com - n_trans) / num_com |
||
| 191 | ) |
||
| 192 | 1 | weight /= 3.0 |
|
| 193 | |||
| 194 | # Continue to boost the weight if the strings are similar |
||
| 195 | # This is the Winkler portion of Jaro-Winkler distance |
||
| 196 | 1 | if mode == 'winkler' and weight > boost_threshold: |
|
| 197 | |||
| 198 | # Adjust for having up to the first 4 characters in common |
||
| 199 | 1 | j = 4 if (minv >= 4) else minv |
|
| 200 | 1 | i = 0 |
|
| 201 | 1 | while (i < j) and (src[i] == tar[i]): |
|
| 202 | 1 | i += 1 |
|
| 203 | 1 | weight += i * scaling_factor * (1.0 - weight) |
|
| 204 | |||
| 205 | # Optionally adjust for long strings. |
||
| 206 | |||
| 207 | # After agreeing beginning chars, at least two more must agree and |
||
| 208 | # the agreeing characters must be > .5 of remaining characters. |
||
| 209 | 1 | if ( |
|
| 210 | long_strings |
||
| 211 | and (minv > 4) |
||
| 212 | and (num_com > i + 1) |
||
| 213 | and (2 * num_com >= minv + i) |
||
| 214 | ): |
||
| 215 | 1 | weight += (1.0 - weight) * ( |
|
| 216 | (num_com - i - 1) / (lens + lent - i * 2 + 2) |
||
| 217 | ) |
||
| 218 | |||
| 219 | 1 | return weight |
|
| 220 | |||
| 356 |
Loading history...