chrislit /
abydos
| Conditions | 51 |
| Total Lines | 195 |
| Code Lines | 128 |
| Lines | 0 |
| Ratio | 0 % |
| Tests | 110 |
| CRAP Score | 51 |
| 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.fingerprint._synoname.SynonameToolcode.fingerprint() 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.
| 1 | # -*- coding: utf-8 -*- |
||
| 265 | 1 | def fingerprint(self, lname, fname='', qual='', normalize=0): |
|
| 266 | """Build the Synoname toolcode. |
||
| 267 | |||
| 268 | :param str lname: last name |
||
| 269 | :param str fname: first name (can be blank) |
||
| 270 | :param str qual: qualifier |
||
| 271 | :param int normalize: normalization mode (0, 1, or 2) |
||
| 272 | :returns: the transformed names and the synoname toolcode |
||
| 273 | :rtype: tuple |
||
| 274 | |||
| 275 | >>> st = SynonameToolcode() |
||
| 276 | >>> st.fingerprint('hat') |
||
| 277 | ('hat', '', '0000000003$$h') |
||
| 278 | >>> st.fingerprint('niall') |
||
| 279 | ('niall', '', '0000000005$$n') |
||
| 280 | >>> st.fingerprint('colin') |
||
| 281 | ('colin', '', '0000000005$$c') |
||
| 282 | >>> st.fingerprint('atcg') |
||
| 283 | ('atcg', '', '0000000004$$a') |
||
| 284 | >>> st.fingerprint('entreatment') |
||
| 285 | ('entreatment', '', '0000000011$$e') |
||
| 286 | |||
| 287 | >>> st.fingerprint('Ste.-Marie', 'Count John II', normalize=2) |
||
| 288 | ('ste.-marie ii', 'count john', '0200491310$015b049a127c$smcji') |
||
| 289 | >>> st.fingerprint('Michelangelo IV', '', 'Workshop of') |
||
| 290 | ('michelangelo iv', '', '3000550015$055b$mi') |
||
| 291 | """ |
||
| 292 | 1 | lname = lname.lower() |
|
| 293 | 1 | fname = fname.lower() |
|
| 294 | 1 | qual = qual.lower() |
|
| 295 | |||
| 296 | # Start with the basic code |
||
| 297 | 1 | toolcode = ['0', '0', '0', '000', '00', '00', '$', '', '$', ''] |
|
| 298 | |||
| 299 | 1 | full_name = ' '.join((lname, fname)) |
|
| 300 | |||
| 301 | 1 | if qual in self.qual_3: |
|
| 302 | 1 | toolcode[0] = '3' |
|
| 303 | 1 | elif qual in self.qual_2: |
|
| 304 | 1 | toolcode[0] = '2' |
|
| 305 | 1 | elif qual in self.qual_1: |
|
| 306 | 1 | toolcode[0] = '1' |
|
| 307 | |||
| 308 | # Fill field 1 (punctuation) |
||
| 309 | 1 | if '.' in full_name: |
|
| 310 | 1 | toolcode[1] = '2' |
|
| 311 | else: |
||
| 312 | 1 | for punct in ',-/:;"&\'()!{|}?$%*+<=>[\\]^_`~': |
|
| 313 | 1 | if punct in full_name: |
|
| 314 | 1 | toolcode[1] = '1' |
|
| 315 | 1 | break |
|
| 316 | |||
| 317 | 1 | elderyounger = '' # save elder/younger for possible movement later |
|
| 318 | 1 | for gen in self.gen_1: |
|
| 319 | 1 | if gen in full_name: |
|
| 320 | 1 | toolcode[2] = '1' |
|
| 321 | 1 | elderyounger = gen |
|
| 322 | 1 | break |
|
| 323 | else: |
||
| 324 | 1 | for gen in self.gen_2: |
|
| 325 | 1 | if gen in full_name: |
|
| 326 | 1 | toolcode[2] = '2' |
|
| 327 | 1 | elderyounger = gen |
|
| 328 | 1 | break |
|
| 329 | |||
| 330 | # do comma flip |
||
| 331 | 1 | if normalize: |
|
| 332 | 1 | comma = lname.find(',') |
|
| 333 | 1 | if comma != -1: |
|
| 334 | 1 | lname_end = lname[comma + 1 :] |
|
| 335 | 1 | while lname_end[0] in {' ', ','}: |
|
| 336 | 1 | lname_end = lname_end[1:] |
|
| 337 | 1 | fname = lname_end + ' ' + fname |
|
| 338 | 1 | lname = lname[:comma].strip() |
|
| 339 | |||
| 340 | # do elder/younger move |
||
| 341 | 1 | if normalize == 2 and elderyounger: |
|
| 342 | 1 | elderyounger_loc = fname.find(elderyounger) |
|
| 343 | 1 | if elderyounger_loc != -1: |
|
| 344 | 1 | lname = ' '.join((lname, elderyounger.strip())) |
|
| 345 | 1 | fname = ' '.join( |
|
| 346 | ( |
||
| 347 | fname[:elderyounger_loc].strip(), |
||
| 348 | fname[elderyounger_loc + len(elderyounger) :], |
||
| 349 | ) |
||
| 350 | ).strip() |
||
| 351 | |||
| 352 | 1 | toolcode[4] = '{:02d}'.format(len(fname)) |
|
| 353 | 1 | toolcode[5] = '{:02d}'.format(len(lname)) |
|
| 354 | |||
| 355 | # strip punctuation |
||
| 356 | 1 | for char in ',/:;"&()!{|}?$%*+<=>[\\]^_`~': |
|
| 357 | 1 | full_name = full_name.replace(char, '') |
|
| 358 | 1 | for pos, char in enumerate(full_name): |
|
| 359 | 1 | if char == '-' and full_name[pos - 1 : pos + 2] != 'b-g': |
|
| 360 | 1 | full_name = full_name[:pos] + ' ' + full_name[pos + 1 :] |
|
| 361 | |||
| 362 | # Fill field 9 (search range) |
||
| 363 | 1 | for letter in [_[0] for _ in full_name.split()]: |
|
| 364 | 1 | if letter not in toolcode[9]: |
|
| 365 | 1 | toolcode[9] += letter |
|
| 366 | 1 | if len(toolcode[9]) == 15: |
|
| 367 | 1 | break |
|
| 368 | |||
| 369 | 1 | def roman_check(numeral, fname, lname): |
|
| 370 | """Move Roman numerals from first name to last.""" |
||
| 371 | 1 | loc = fname.find(numeral) |
|
| 372 | 1 | if fname and ( |
|
| 373 | loc != -1 |
||
| 374 | and (len(fname[loc:]) == len(numeral)) |
||
| 375 | or fname[loc + len(numeral)] in {' ', ','} |
||
| 376 | ): |
||
| 377 | 1 | lname = ' '.join((lname, numeral)) |
|
| 378 | 1 | fname = ' '.join( |
|
| 379 | ( |
||
| 380 | fname[:loc].strip(), |
||
| 381 | fname[loc + len(numeral) :].lstrip(' ,'), |
||
| 382 | ) |
||
| 383 | ) |
||
| 384 | 1 | return fname.strip(), lname.strip() |
|
| 385 | |||
| 386 | # Fill fields 7 (specials) and 3 (roman numerals) |
||
| 387 | 1 | for num, special in enumerate(self.synoname_special_table): |
|
| 388 | 1 | roman, match, extra, method = special |
|
| 389 | 1 | if method & self.method_dict['end']: |
|
| 390 | 1 | match_context = ' ' + match |
|
| 391 | 1 | loc = full_name.find(match_context) |
|
| 392 | 1 | if (len(full_name) > len(match_context)) and ( |
|
| 393 | loc == len(full_name) - len(match_context) |
||
| 394 | ): |
||
| 395 | 1 | if roman: |
|
| 396 | 1 | if not any( |
|
| 397 | abbr in fname for abbr in ('i.', 'v.', 'x.') |
||
| 398 | ): |
||
| 399 | 1 | full_name = full_name[:loc] |
|
| 400 | 1 | toolcode[7] += '{:03d}'.format(num) + 'a' |
|
| 401 | 1 | if toolcode[3] == '000': |
|
| 402 | 1 | toolcode[3] = '{:03d}'.format(num) |
|
| 403 | 1 | if normalize == 2: |
|
| 404 | 1 | fname, lname = roman_check(match, fname, lname) |
|
| 405 | else: |
||
| 406 | 1 | full_name = full_name[:loc] |
|
| 407 | 1 | toolcode[7] += '{:03d}'.format(num) + 'a' |
|
| 408 | 1 | if method & self.method_dict['middle']: |
|
| 409 | 1 | match_context = ' ' + match + ' ' |
|
| 410 | 1 | loc = 0 |
|
| 411 | 1 | while loc != -1: |
|
| 412 | 1 | loc = full_name.find(match_context, loc + 1) |
|
| 413 | 1 | if loc > 0: |
|
| 414 | 1 | if roman: |
|
| 415 | 1 | if not any( |
|
| 416 | abbr in fname for abbr in ('i.', 'v.', 'x.') |
||
| 417 | ): |
||
| 418 | 1 | full_name = ( |
|
| 419 | full_name[:loc] |
||
| 420 | + full_name[loc + len(match) + 1 :] |
||
| 421 | ) |
||
| 422 | 1 | toolcode[7] += '{:03d}'.format(num) + 'b' |
|
| 423 | 1 | if toolcode[3] == '000': |
|
| 424 | 1 | toolcode[3] = '{:03d}'.format(num) |
|
| 425 | 1 | if normalize == 2: |
|
| 426 | 1 | fname, lname = roman_check( |
|
| 427 | match, fname, lname |
||
| 428 | ) |
||
| 429 | else: |
||
| 430 | 1 | full_name = ( |
|
| 431 | full_name[:loc] |
||
| 432 | + full_name[loc + len(match) + 1 :] |
||
| 433 | ) |
||
| 434 | 1 | toolcode[7] += '{:03d}'.format(num) + 'b' |
|
| 435 | 1 | if method & self.method_dict['beginning']: |
|
| 436 | 1 | match_context = match + ' ' |
|
| 437 | 1 | loc = full_name.find(match_context) |
|
| 438 | 1 | if loc == 0: |
|
| 439 | 1 | full_name = full_name[len(match) + 1 :] |
|
| 440 | 1 | toolcode[7] += '{:03d}'.format(num) + 'c' |
|
| 441 | 1 | if method & self.method_dict['beginning_no_space']: |
|
| 442 | 1 | loc = full_name.find(match) |
|
| 443 | 1 | if loc == 0: |
|
| 444 | 1 | toolcode[7] += '{:03d}'.format(num) + 'd' |
|
| 445 | 1 | if full_name[: len(match)] not in toolcode[9]: |
|
| 446 | 1 | toolcode[9] += full_name[: len(match)] |
|
| 447 | |||
| 448 | 1 | if extra: |
|
| 449 | 1 | loc = full_name.find(extra) |
|
| 450 | 1 | if loc != -1: |
|
| 451 | 1 | toolcode[7] += '{:03d}'.format(num) + 'X' |
|
| 452 | # Since extras are unique, we only look for each of them |
||
| 453 | # once, and they include otherwise impossible characters |
||
| 454 | # for this field, it's not possible for the following line |
||
| 455 | # to have ever been false. |
||
| 456 | # if full_name[loc:loc+len(extra)] not in toolcode[9]: |
||
| 457 | 1 | toolcode[9] += full_name[loc : loc + len(match)] |
|
| 458 | |||
| 459 | 1 | return lname, fname, ''.join(toolcode) |
|
| 460 | |||
| 497 |
Loading history...