Is Jellyfish's Damerau–Levenshtein distance calculation buggy?

Question

I am trying to use Jellyfish to work with fuzzy strings. I am noticing some strange behaviour of the Damerau–Levenshtein distance algorithm. For example:

import jellyfish as jf
In [0]: jf.damerau_levenshtein_distance('ZX', 'XYZ')
Out[0]: 3
In [1]: jf.damerau_levenshtein_distance('BADC', 'ABCD')
Out[1]: 3

To my mind both should score 2.

In the first example:

1. ZX → XZ (transpose adjacent characters)
2. XZ → XYZ (insert Y)

In the second example:

1. BACD → ABDC (transpose adjacent BA characters)
2. ABDC → ABCD (transpose adjacent DC characters)

Is this something wrong with the algorithm, or have I misunderstood the measure? Any guidance would be appreciated.

EDIT

Just to make things more peculiar, I also observe the following:

In [3]: jf.damerau_levenshtein_distance('jellyifhs', 'jellyfish')
Out[3]: 2
In [4]: jf.damerau_levenshtein_distance('ifhs', 'fish')
Out[4]L 3

Which is particularly odd, as the number of edits should not only be two in both examples but they are exactly the same edits:

In the third example:

1. jellyifhs → jellyfihs (transpose adjacent characters if)
2. jellyfihs → jellyfish (transpose adjacent characters hs)

In the fourth example:

1. ifhs → fihs (transpose adjacent characters if)
2. fihs → fish (transpose adjacent characters hs)

Answer 1

From wikipedia

In information theory and computer science, the Damerau–Levenshtein distance (named after Frederick J. Damerau and Vladimir I. Levenshtein)[citation needed] is a "distance" (string metric) between two strings, i.e., finite sequence of symbols, given by counting the minimum number of operations needed to transform one string into the other, where an operation is defined as an insertion, deletion, or substitution of a single character, or a transposition of two adjacent characters.

But if you read further,

Take for example the edit distance between CA and ABC. The Damerau–Levenshtein distance LD(CA,ABC) = 2 because CA -> AC -> ABC, but the optimal string alignment distance OSA(CA,ABC) = 3 because if the operation CA -> AC is used, it is not possible to use AC -> ABC because that would require the substring to be edited more than once, which is not allowed in OSA, and therefore the shortest sequence of operations is CA -> A -> AB -> ABC. Note that for the optimal string alignment distance, the triangle inequality does not hold: OSA(CA,AC) + OSA(AC,ABC) < OSA(CA,ABC), and so it is not a true metric.

EDIT:

After taking a look at the source, it's clear that the function calculates OSA instead of Damerau–Levenshtein distance.