Path 1: 12 calls (0.52)

→ dfunc unified_diff def (7) context_diff def (5)

→ a list (12)

→ b list (12)

→ fromfile bytes (12)

→ tofile bytes (12)

→ fromfiledate bytes (12)

→ tofiledate bytes (12)

→ n 3 (12)

→ lineterm bytes (12)

⇇ yield bytes (79)

11 run 6 not run

1def diff_bytes(dfunc, a, b, fromfile=b'', tofile=b'',
2               fromfiledate=b'', tofiledate=b'', n=3, lineterm=b'\n'):
3    r"""
4    Compare `a` and `b`, two sequences of lines represented as bytes rather
5    than str. This is a wrapper for `dfunc`, which is typically either
6    unified_diff() or context_diff(). Inputs are losslessly converted to
7    strings so that `dfunc` only has to worry about strings, and encoded
8    back to bytes on return. This is necessary to compare files with
9    unknown or inconsistent encoding. All other inputs (except `n`) must be
10    bytes rather than str.
11    """
12    def decode(s):
13        try:
14            return s.decode('ascii', 'surrogateescape')
15        except AttributeError as err:
16            msg = ('all arguments must be bytes, not %s (%r)' %
17                   (type(s).__name__, s))
18            raise TypeError(msg) from err
19    a = list(map(decode, a))
20    b = list(map(decode, b))
21    fromfile = decode(fromfile)
22    tofile = decode(tofile)
23    fromfiledate = decode(fromfiledate)
24    tofiledate = decode(tofiledate)
25    lineterm = decode(lineterm)
26
27    lines = dfunc(a, b, fromfile, tofile, fromfiledate, tofiledate, n, lineterm)
28    for line in lines:
29        yield line.encode('ascii', 'surrogateescape')
            

Path 2: 6 calls (0.26)

→ dfunc unified_diff def (3) context_diff def (3)

→ a list (6)

→ b list (6)

→ fromfile bytes (6)

→ tofile bytes (6)

→ fromfiledate bytes (6)

→ tofiledate bytes (6)

→ n 3 (6)

→ lineterm bytes (6)

10 run 7 not run

1def diff_bytes(dfunc, a, b, fromfile=b'', tofile=b'',
2               fromfiledate=b'', tofiledate=b'', n=3, lineterm=b'\n'):
3    r"""
4    Compare `a` and `b`, two sequences of lines represented as bytes rather
5    than str. This is a wrapper for `dfunc`, which is typically either
6    unified_diff() or context_diff(). Inputs are losslessly converted to
7    strings so that `dfunc` only has to worry about strings, and encoded
8    back to bytes on return. This is necessary to compare files with
9    unknown or inconsistent encoding. All other inputs (except `n`) must be
10    bytes rather than str.
11    """
12    def decode(s):
13        try:
14            return s.decode('ascii', 'surrogateescape')
15        except AttributeError as err:
16            msg = ('all arguments must be bytes, not %s (%r)' %
17                   (type(s).__name__, s))
18            raise TypeError(msg) from err
19    a = list(map(decode, a))
20    b = list(map(decode, b))
21    fromfile = decode(fromfile)
22    tofile = decode(tofile)
23    fromfiledate = decode(fromfiledate)
24    tofiledate = decode(tofiledate)
25    lineterm = decode(lineterm)
26
27    lines = dfunc(a, b, fromfile, tofile, fromfiledate, tofiledate, n, lineterm)
28    for line in lines:
29        yield line.encode('ascii', 'surrogateescape')
            

Path 3: 2 calls (0.09)

→ dfunc unified_diff def (1) context_diff def (1)

→ a list (2)

→ b ['hello'] (2)

→ fromfile bytes (2)

→ tofile bytes (2)

→ fromfiledate bytes (2)

→ tofiledate bytes (2)

→ n 3 (2)

→ lineterm bytes (2)

⚠ exception TypeError (2)

3 run 14 not run

1def diff_bytes(dfunc, a, b, fromfile=b'', tofile=b'',
2               fromfiledate=b'', tofiledate=b'', n=3, lineterm=b'\n'):
3    r"""
4    Compare `a` and `b`, two sequences of lines represented as bytes rather
5    than str. This is a wrapper for `dfunc`, which is typically either
6    unified_diff() or context_diff(). Inputs are losslessly converted to
7    strings so that `dfunc` only has to worry about strings, and encoded
8    back to bytes on return. This is necessary to compare files with
9    unknown or inconsistent encoding. All other inputs (except `n`) must be
10    bytes rather than str.
11    """
12    def decode(s):
13        try:
14            return s.decode('ascii', 'surrogateescape')
15        except AttributeError as err:
16            msg = ('all arguments must be bytes, not %s (%r)' %
17                   (type(s).__name__, s))
18            raise TypeError(msg) from err
19    a = list(map(decode, a))
20    b = list(map(decode, b))
21    fromfile = decode(fromfile)
22    tofile = decode(tofile)
23    fromfiledate = decode(fromfiledate)
24    tofiledate = decode(tofiledate)
25    lineterm = decode(lineterm)
26
27    lines = dfunc(a, b, fromfile, tofile, fromfiledate, tofiledate, n, lineterm)
28    for line in lines:
29        yield line.encode('ascii', 'surrogateescape')
            

Path 4: 2 calls (0.09)

→ dfunc unified_diff def (1) context_diff def (1)

→ a ['hello'] (2)

→ b list (2)

→ fromfile bytes (2)

→ tofile bytes (2)

→ fromfiledate bytes (2)

→ tofiledate bytes (2)

→ n 3 (2)

→ lineterm bytes (2)

⚠ exception TypeError (2)

2 run 15 not run

1def diff_bytes(dfunc, a, b, fromfile=b'', tofile=b'',
2               fromfiledate=b'', tofiledate=b'', n=3, lineterm=b'\n'):
3    r"""
4    Compare `a` and `b`, two sequences of lines represented as bytes rather
5    than str. This is a wrapper for `dfunc`, which is typically either
6    unified_diff() or context_diff(). Inputs are losslessly converted to
7    strings so that `dfunc` only has to worry about strings, and encoded
8    back to bytes on return. This is necessary to compare files with
9    unknown or inconsistent encoding. All other inputs (except `n`) must be
10    bytes rather than str.
11    """
12    def decode(s):
13        try:
14            return s.decode('ascii', 'surrogateescape')
15        except AttributeError as err:
16            msg = ('all arguments must be bytes, not %s (%r)' %
17                   (type(s).__name__, s))
18            raise TypeError(msg) from err
19    a = list(map(decode, a))
20    b = list(map(decode, b))
21    fromfile = decode(fromfile)
22    tofile = decode(tofile)
23    fromfiledate = decode(fromfiledate)
24    tofiledate = decode(tofiledate)
25    lineterm = decode(lineterm)
26
27    lines = dfunc(a, b, fromfile, tofile, fromfiledate, tofiledate, n, lineterm)
28    for line in lines:
29        yield line.encode('ascii', 'surrogateescape')
            

Path 5: 1 calls (0.04)

→ dfunc unified_diff def (1)

→ a list (1)

→ b list (1)

→ fromfile bytes (1)

→ tofile bytes (1)

→ fromfiledate '1 fév' (1)

→ tofiledate '3 fév' (1)

→ n 3 (1)

→ lineterm bytes (1)

⚠ exception TypeError (1)

6 run 11 not run

1def diff_bytes(dfunc, a, b, fromfile=b'', tofile=b'',
2               fromfiledate=b'', tofiledate=b'', n=3, lineterm=b'\n'):
3    r"""
4    Compare `a` and `b`, two sequences of lines represented as bytes rather
5    than str. This is a wrapper for `dfunc`, which is typically either
6    unified_diff() or context_diff(). Inputs are losslessly converted to
7    strings so that `dfunc` only has to worry about strings, and encoded
8    back to bytes on return. This is necessary to compare files with
9    unknown or inconsistent encoding. All other inputs (except `n`) must be
10    bytes rather than str.
11    """
12    def decode(s):
13        try:
14            return s.decode('ascii', 'surrogateescape')
15        except AttributeError as err:
16            msg = ('all arguments must be bytes, not %s (%r)' %
17                   (type(s).__name__, s))
18            raise TypeError(msg) from err
19    a = list(map(decode, a))
20    b = list(map(decode, b))
21    fromfile = decode(fromfile)
22    tofile = decode(tofile)
23    fromfiledate = decode(fromfiledate)
24    tofiledate = decode(tofiledate)
25    lineterm = decode(lineterm)
26
27    lines = dfunc(a, b, fromfile, tofile, fromfiledate, tofiledate, n, lineterm)
28    for line in lines:
29        yield line.encode('ascii', 'surrogateescape')