MonoshiTonmoy/Code_Statement_Prediction_Dataset huggingface dataset:
Project Name: d3rp+clima
Language: Python
Statement Type: Branch

Source Code:
def config_dict(configuration_tuple):
    config_dict = {}

    config_file = configuration_tuple._asdict().get('CFG')
    if config_file is None:
        config_file = configfile.get_config_path(configuration_tuple)

    if config_file is not None:
        config_dict = utils.filter_fields(configfile.read_config(config_file), configuration_tuple)
        config_dict = utils.type_correct_with(config_dict, configuration_tuple)

    return config_dict

config_dict(configuration_tuple={})

Selected Statement: if config_file is not None:

Function Input:

Variable Values Before Statement:
config_file: PosixPath('/local/rcs/jinjun/code/pytrace-collector/logs/pypibugs/tried/d3rp+clima/d3rp+clima/foo.cfg')

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
configuration_tuple: 1
config_dict: 2
9
bar: 42
10
bar: 42
config_file: 4
None
6
PosixPath('/local/rcs/jinjun/code/pytrace-collector/logs/pypibugs/tried/d3rp+clima/d3rp+clima/foo.cfg')
Project Name: paul-gauthier+aider
Language: Python
Statement Type: Branch

Source Code:
def do_replace(fname, content, before_text, after_text, fence=None):
    before_text = strip_quoted_wrapping(before_text, fname, fence)
    after_text = strip_quoted_wrapping(after_text, fname, fence)
    fname = Path(fname)

    # does it want to make a new file?
    if not fname.exists() and not before_text.strip():
        fname.touch()
        content = ""

    if content is None:
        return

    if not before_text.strip():
        # append to existing file, or start a new file
        new_content = content + after_text
    else:
        new_content = replace_most_similar_chunk(content, before_text, after_text)

    return new_content

do_replace(fname='/tmp/tmp7g7a2csg/file.txt', content='two\n', before_text='two\n', after_text='three\n', fence=('```', '```'))

Selected Statement: if content is None:

Function Input:
fname: '/tmp/tmp7g7a2csg/file.txt'
content: 'two\n'
before_text: 'two\n'
after_text: 'three\n'
fence: ('```', '```')

Variable Values Before Statement:
content: 'two\n'

Value After Statement Execution: No

Variable States During Runtime (line, value):
fname: 1
'/tmp/tmp7g7a2csg/file.txt'
4
PosixPath('/tmp/tmp7g7a2csg/file.txt')
content: 1
'two\n'
before_text: 1
'two\n'
after_text: 1
'three\n'
fence: 1
('```', '```')
new_content: 18
'three\n'
Project Name: paul-gauthier+aider
Language: Python
Statement Type: Branch

Source Code:
def strip_quoted_wrapping(res, fname=None, fence=DEFAULT_FENCE):
    """
    Given an input string which may have extra "wrapping" around it, remove the wrapping.
    For example:

    filename.ext
    ```
    We just want this content
    Not the filename and triple quotes
    ```
    """
    if not res:
        return res

    res = res.splitlines()

    if fname and res[0].strip().endswith(Path(fname).name):
        res = res[1:]

    if res[0].startswith(fence[0]) and res[-1].startswith(fence[1]):
        res = res[1:-1]

    res = "\n".join(res)
    if res and res[-1] != "\n":
        res += "\n"

    return res

strip_quoted_wrapping(res='two\n', fname='/tmp/tmp7g7a2csg/file.txt', fence=('```', '```'))

Selected Statement: if res and res[-1] != "\n":

Function Input:
res: 'two\n'
fname: '/tmp/tmp7g7a2csg/file.txt'
fence: ('```', '```')

Variable Values Before Statement:
res: two

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
res: 1
'two\n'
15
two
23
'two'
25
'two\n'
fname: 1
'/tmp/tmp7g7a2csg/file.txt'
fence: 1
('```', '```')
Project Name: paul-gauthier+aider
Language: Python
Statement Type: Branch

Source Code:
def replace_part_with_missing_leading_whitespace(whole_lines, part_lines, replace_lines):
    # GPT often messes up leading whitespace.
    # It usually does it uniformly across the ORIG and UPD blocks.
    # Either omitting all leading whitespace, or including only some of it.

    # Outdent everything in part_lines and replace_lines by the max fixed amount possible
    leading = [len(p) - len(p.lstrip()) for p in part_lines if p.strip()] + [
        len(p) - len(p.lstrip()) for p in replace_lines if p.strip()
    ]

    if leading and min(leading):
        num_leading = min(leading)
        part_lines = [p[num_leading:] if p.strip() else p for p in part_lines]
        replace_lines = [p[num_leading:] if p.strip() else p for p in replace_lines]

    # can we find an exact match not including the leading whitespace
    num_part_lines = len(part_lines)

    for i in range(len(whole_lines) - num_part_lines + 1):
        add_leading = match_but_for_leading_whitespace(
            whole_lines[i : i + num_part_lines], part_lines
        )

        if add_leading is None:
            continue

        replace_lines = [add_leading + rline if rline.strip() else rline for rline in replace_lines]
        whole_lines = whole_lines[:i] + replace_lines + whole_lines[i + num_part_lines :]
        return "".join(whole_lines)

    return None

replace_part_with_missing_leading_whitespace(whole_lines=['    line1\n', '    line2\n', '    line3\n'], part_lines=[' line1\n', ' line2\n'], replace_lines=[' new_line1\n', '     new_line2\n'])

Selected Statement: if leading and min(leading):

Function Input:
whole_lines:     line1

    line2

    line3

part_lines:  line1

 line2

replace_lines:  new_line1

     new_line2


Variable Values Before Statement:
leading: [1, 1, 1, 5]

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
whole_lines: 1
    line1

    line2

    line3

28
    new_line1

        new_line2

    line3

part_lines: 1
 line1

 line2

13
line1

line2

replace_lines: 1
 new_line1

     new_line2

14
new_line1

    new_line2

27
    new_line1

        new_line2

leading: 7
[1, 1, 1, 5]
num_leading: 12
1
num_part_lines: 17
2
i: 19
0
add_leading: 20
'    '
Project Name: paul-gauthier+aider
Language: Python
Statement Type: Branch

Source Code:
def process_fenced_block(lines, start_line_num):
    for line_num in range(start_line_num, len(lines)):
        line = lines[line_num]
        if line.startswith("```"):
            break

    block = lines[start_line_num:line_num]
    block.append("@@ @@")

    if block[0].startswith("--- ") and block[1].startswith("+++ "):
        # Extract the file path, considering that it might contain spaces
        fname = block[1][4:].strip()
        block = block[2:]
    else:
        fname = None

    edits = []

    keeper = False
    hunk = []
    op = " "
    for line in block:
        hunk.append(line)
        if len(line) < 2:
            continue

        if line.startswith("+++ ") and hunk[-2].startswith("--- "):
            if hunk[-3] == "\n":
                hunk = hunk[:-3]
            else:
                hunk = hunk[:-2]

            edits.append((fname, hunk))
            hunk = []
            keeper = False

            fname = line[4:].strip()
            continue

        op = line[0]
        if op in "-+":
            keeper = True
            continue
        if op != "@":
            continue
        if not keeper:
            hunk = []
            continue

        hunk = hunk[:-1]
        edits.append((fname, hunk))
        hunk = []
        keeper = False

    return line_num + 1, edits

process_fenced_block(lines=['\n', 'Some text...\n', '\n', '```diff\n', '--- /dev/null\n', '+++ file.txt\n', '@@ ... @@\n', '-Original\n', '+Modified\n', '```\n'], start_line_num=4)

Selected Statement: if not keeper:

Function Input:
lines: 

Some text...



```diff

--- /dev/null

+++ file.txt

@@ ... @@

-Original

+Modified

```

start_line_num: 4

Variable Values Before Statement:
keeper: True

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
lines: 1


Some text...



```diff

--- /dev/null

+++ file.txt

@@ ... @@

-Original

+Modified

```

start_line_num: 1
4
line_num: 2
4
2
5
2
6
2
7
2
8
2
9
line: 3
'--- /dev/null\n'
3
'+++ file.txt\n'
3
'@@ ... @@\n'
3
'-Original\n'
3
'+Modified\n'
3
'```\n'
22
'@@ ... @@\n'
22
'-Original\n'
22
'+Modified\n'
22
'@@ @@'
block: 7
--- /dev/null

+++ file.txt

@@ ... @@

-Original

+Modified

8
--- /dev/null

+++ file.txt

@@ ... @@

-Original

+Modified

@@ @@
13
@@ ... @@

-Original

+Modified

@@ @@
fname: 12
'file.txt'
edits: 17
51
[('file.txt', ['-Original\n', '+Modified\n'])]
keeper: 19
False
42
True
53
False
hunk: 20
23
@@ ... @@

47
23
-Original

23
-Original

+Modified

23
-Original

+Modified

@@ @@
50
-Original

+Modified

52
op: 21
' '
40
'@'
40
'-'
40
'+'
40
'@'
Project Name: GeoStat-Framework+welltestpy
Language: Python
Statement Type: Branch

Source Code:
def _addpoint(sol, i, distances, prec):
    """
    Try to add point i to a given solution-approach.

    gives all possibilties and a status about the solution:
        state = 0: possibilities found
        state = 1: no possibilities but no contradiction
        state = 2: solution-approach has a contradiction with point i
    """
    res = []

    # if i is already part of the solution return it
    if np.ndim(sol[i]) != 0:
        return [sol], 0

    # collect the points already present in the solution
    solpnts = []
    for n, m in enumerate(sol):
        if np.ndim(m) != 0:
            solpnts.append(n)

    # number of present points
    pntscount = len(solpnts)

    # try to add the point in all possible constellations
    for n in range(pntscount - 1):
        for m in range(n + 1, pntscount):
            tmppnt, state = _pntcoord(
                sol, i, solpnts[n], solpnts[m], distances, prec
            )

            # if possiblities are found, add them (at most 2! (think about))
            if state == 0:
                for pnt in tmppnt:
                    res.append(dcopy(sol))
                    res[-1][i] = pnt

            # if one possiblity or a contradiction is found, return the result
            if state != 1:
                return res, state

    # if the state remaind 1, return empty result and no contradiction
    return res, state

_addpoint(sol=[array([0., 0.]), array([3., 0.]), 0, 0], i=2, distances=array([[ 0.,  3.,  4.,  1.],       [ 3.,  0.,  2.,  3.],       [ 4.,  2.,  0., -1.],       [ 1.,  3., -1.,  0.]]), prec=0.1)

Selected Statement: if state == 0:

Function Input:
sol: [array([0., 0.]), array([3., 0.]), 0, 0]
i: 2
distances: array([[ 0.,  3.,  4.,  1.],       [ 3.,  0.,  2.,  3.],       [ 4.,  2.,  0., -1.],       [ 1.,  3., -1.,  0.]])
prec: 0.1

Variable Values Before Statement:
state: 0

Value After Statement Execution: No

Variable States During Runtime (line, value):
sol: 1
[array([0., 0.]), array([3., 0.]), 0, 0]
i: 1
2
distances: 1
array([[ 0.,  3.,  4.,  1.],       [ 3.,  0.,  2.,  3.],       [ 4.,  2.,  0., -1.],       [ 1.,  3., -1.,  0.]])
prec: 1
0.1
res: 10
35
[[array([0., 0.]), array([3., 0.]), 0, 0]]
36
[[array([0., 0.]), array([3., 0.]), array([3.5       , 1.93649167]), 0]]
35
[[array([0., 0.]), array([3., 0.]), array([3.5       , 1.93649167]), 0], [array([0., 0.]), array([3., 0.]), 0, 0]]
36
[[array([0., 0.]), array([3., 0.]), array([3.5       , 1.93649167]), 0], [array([0., 0.]), array([3., 0.]), array([ 3.5       , -1.93649167]), 0]]
solpnts: 17
20
[0]
20
[0, 1]
n: 18
0
18
1
18
2
18
3
26
0
m: 18
array([0., 0.])
18
array([3., 0.])
18
0
27
1
pntscount: 23
2
tmppnt: 28
[array([3.5       , 1.93649167]), array([ 3.5       , -1.93649167])]
state: 28
0
pnt: 34
array([3.5       , 1.93649167])
34
array([ 3.5       , -1.93649167])
Project Name: GeoStat-Framework+welltestpy
Language: Python
Statement Type: Branch

Source Code:
def _pntcoord(sol, i, n, m, distances, prec):
    """
    Generate coordinates for point i in constellation to points m and n.

    Check if these coordinates are valid with all other points in the solution.
    """
    tmppnt = []

    state = 1

    pntscount = len(sol)

    # if no distances known, return empty result and the unknown-state
    if distances[i, n] < -0.5 or distances[i, m] < -0.5:
        return tmppnt, state

    # if the Triangle inequality is not fullfilled give a contradiction
    if distances[i, n] + distances[i, m] < _dist(sol[n], sol[m]):
        state = 2
        return tmppnt, state

    # generate the affine rotation to bring the points in the right place
    g = _affinef(*_invtranmat(*_tranmat(sol[n], sol[m])))

    # generate the coordinates
    x = _xvalue(distances[i, n], distances[i, m], _dist(sol[n], sol[m]))
    y1, y2 = _yvalue(distances[i, n], distances[i, m], _dist(sol[n], sol[m]))

    # generate the possible positons
    pos1 = g(np.array([x, y1]))
    pos2 = g(np.array([x, y2]))

    valid1 = True
    valid2 = True

    # check if the possible positions are valid
    for k in range(pntscount):
        if np.ndim(sol[k]) != 0 and distances[i, k] > -0.5:
            valid1 &= abs(_dist(sol[k], pos1) - distances[i, k]) < prec
            valid2 &= abs(_dist(sol[k], pos2) - distances[i, k]) < prec

    # if any position is valid, add it to the result
    if valid1 or valid2:
        state = 0
        same = abs(y1 - y2) < prec / 4.0
        if valid1:
            tmppnt.append(dcopy(pos1))
        if valid2 and not same:
            tmppnt.append(dcopy(pos2))
    # if the positions are not valid, give a contradiction
    else:
        state = 2

    return tmppnt, state

_pntcoord(sol=[array([0., 0.]), array([3., 0.]), 0, 0], i=2, n=0, m=1, distances=array([[ 0.,  3.,  4.,  1.],       [ 3.,  0.,  2.,  3.],       [ 4.,  2.,  0., -1.],       [ 1.,  3., -1.,  0.]]), prec=0.1)

Selected Statement: if valid1 or valid2:

Function Input:
sol: [array([0., 0.]), array([3., 0.]), 0, 0]
i: 2
n: 0
m: 1
distances: array([[ 0.,  3.,  4.,  1.],       [ 3.,  0.,  2.,  3.],       [ 4.,  2.,  0., -1.],       [ 1.,  3., -1.,  0.]])
prec: 0.1

Variable Values Before Statement:
valid1: True
valid2: True

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
sol: 1
[array([0., 0.]), array([3., 0.]), 0, 0]
i: 1
2
n: 1
0
m: 1
1
distances: 1
array([[ 0.,  3.,  4.,  1.],       [ 3.,  0.,  2.,  3.],       [ 4.,  2.,  0., -1.],       [ 1.,  3., -1.,  0.]])
prec: 1
0.1
tmppnt: 7
47
[array([3.5       , 1.93649167])]
49
[array([3.5       , 1.93649167]), array([ 3.5       , -1.93649167])]
state: 9
1
44
0
pntscount: 11
4
g: 23
<function _affinef.<locals>.func at 0x7f9d2f5dc9d0>
x: 26
3.5
y1: 27
1.9364916731037083
y2: 27
-1.9364916731037083
pos1: 30
array([3.5       , 1.93649167])
pos2: 31
array([ 3.5       , -1.93649167])
valid1: 33
True
valid2: 34
True
k: 37
0
37
1
37
2
37
3
same: 45
False
Project Name: SkyTruth+gpsd_format
Language: Python
Statement Type: Branch

Source Code:
def str2datetime(string):
    """
    Convert a normalized Benthos timestamp to a datetime object

    Parameters
    ----------
    string : str
        String to convert
    """

    if string == "0000-00-00T24:60:60Z":
        return None

    ms = string[20:-1]
    ms += "000000"[:6 - len(ms)]
    return datetime.datetime(
        int(string[:4]),
        int(string[5:7]),
        int(string[8:10]),
        int(string[11:13]),
        int(string[14:16]),
        int(string[17:19]),
        int(ms))

str2datetime(string='1970-01-01T00:00:00.0Z')

Selected Statement: if string == "0000-00-00T24:60:60Z":

Function Input:
string: '1970-01-01T00:00:00.0Z'

Variable Values Before Statement:
string: '1970-01-01T00:00:00.0Z'

Value After Statement Execution: No

Variable States During Runtime (line, value):
string: 1
'1970-01-01T00:00:00.0Z'
ms: 14
'0'
15
'000000'
Project Name: amarouane-ABDLHAK+cumulus-process-py
Language: Python
Statement Type: Branch

Source Code:
def getLogger(name, stdout=None):
    """ Return logger suitable for Cumulus """
    logger = logging.getLogger(name)
    # clear existing handlers
    logger.handlers = []
    if (stdout is None):
        logger.addHandler(logging.NullHandler())
    if stdout is not None:
        handler = logging.StreamHandler()
        handler.setLevel(stdout['level'])
        handler.setFormatter(CumulusFormatter())
        logger.addHandler(handler)
    # logging level
    logger.setLevel(1)
    return logger

getLogger(name='cumulus.aws', stdout=None)

Selected Statement: if stdout is not None:

Function Input:
name: 'cumulus.aws'
stdout: None

Variable Values Before Statement:
stdout: None

Value After Statement Execution: No

Variable States During Runtime (line, value):
name: 1
'cumulus.aws'
stdout: 1
None
logger: 3
<Logger cumulus.aws (WARNING)>
14
<Logger cumulus.aws (Level 1)>
Project Name: OxfordHED+sunbear
Language: Python
Statement Type: Branch

Source Code:
def get_idx(ndim, axis=None, axis_idx=None):
    s = [midx] * ndim
    if axis is not None:
        if hasattr(axis, "__iter__"):
            for ax, axidx in zip(axis, axis_idx):
                s[ax] = axidx
        else:
            s[axis] = axis_idx
    return tuple(s)

get_idx(ndim=1, axis=0, axis_idx=slice(None, -2, None))

Selected Statement: if axis is not None:

Function Input:
ndim: 1
axis: 0
axis_idx: slice(None, -2, None)

Variable Values Before Statement:
axis: 0

Value After Statement Execution: No

Variable States During Runtime (line, value):
ndim: 1
1
axis: 1
0
axis_idx: 1
slice(None, -2, None)
s: 2
[slice(1, -1, None)]
8
[slice(None, -2, None)]
Project Name: Zulko+moviepy
Language: Python
Statement Type: Branch

Source Code:
def test_audioclip_stereo_max_volume(nchannels, channel_muted):
    def make_frame(t):
        frame = []
        # build channels (one of each pair muted)
        for i in range(int(nchannels / 2)):
            if channel_muted == "left":
                # if muted channel is left, [0, sound, 0, sound...]
                frame.append(np.sin(t * 0))
                frame.append(np.sin(440 * 2 * np.pi * t))
            else:
                # if muted channel is right, [sound, 0, sound, 0...]
                frame.append(np.sin(440 * 2 * np.pi * t))
                frame.append(np.sin(t * 0))
        return np.array(frame).T

    clip = AudioClip(make_frame, fps=44100, duration=1)
    max_volume = clip.max_volume(stereo=True)
    # if `stereo == True`, `AudioClip.max_volume` returns a Numpy array`
    assert isinstance(max_volume, np.ndarray)
    assert len(max_volume) == nchannels

    # check channels muted and with sound
    for i, channel_max_volume in enumerate(max_volume):
        if i % 2 == 0:
            if channel_muted == "left":
                assert channel_max_volume == 0
            else:
                assert channel_max_volume > 0
        else:
            if channel_muted == "right":
                assert channel_max_volume == 0
            else:
                assert channel_max_volume > 0

test_audioclip_stereo_max_volume(nchannels=2, channel_muted='left')

Selected Statement: if channel_muted == "left":

Function Input:
nchannels: 2
channel_muted: 'left'

Variable Values Before Statement:
channel_muted: 'left'

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
nchannels: 1
2
channel_muted: 1
'left'
make_frame: 2
<function test_audioclip_stereo_max_volume.<locals>.make_frame at 0x7f8c02a8e670>
clip: 16
{start=0, end=1, duration=1, memoize=False, memoized_t=None, memoized_frame=None, fps=44100, nchannels=2}
max_volume: 17
array([0.        , 0.99999975])
@py_assert3: 19
None
@py_assert5: 19
None
@py_assert2: 20
None
@py_assert4: 20
None
i: 23
0
23
1
channel_max_volume: 23
0.0
23
0.999999746257887
@py_assert1: 26
None
Project Name: Zulko+moviepy
Language: Python
Statement Type: Branch

Source Code:
def test_clip_with_end(duration, start, end, expected_start, expected_duration):
    clip = ColorClip(color=(255, 0, 0), size=(2, 2), duration=duration).with_fps(1)
    if start is not None:
        clip = clip.with_start(start)
    else:
        clip.start = None
    clip = clip.with_end(end)

    assert clip.start == expected_start
    assert clip.duration == expected_duration

test_clip_with_end(duration=3, start=1, end=2, expected_start=1, expected_duration=1)

Selected Statement: if start is not None:

Function Input:
duration: 3
start: 1
end: 2
expected_start: 1
expected_duration: 1

Variable Values Before Statement:
start: 1

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
duration: 1
3
start: 1
1
end: 1
2
expected_start: 1
1
expected_duration: 1
1
clip: 2
{start=0, end=3, duration=3, memoize=False, memoized_t=None, memoized_frame=None, mask=None, audio=None, relative_pos=False, layer=0, is_mask=False, has_constant_size=True, size=(2, 2), img=array([[[255,   0,   0],        [255,   0,   0]],       [[255,   0,   0],        [255,   0,   0]]]), fps=1}
4
{start=1, end=4, duration=3, memoize=False, memoized_t=None, memoized_frame=None, mask=None, audio=None, relative_pos=False, layer=0, is_mask=False, has_constant_size=True, size=(2, 2), img=array([[[255,   0,   0],        [255,   0,   0]],       [[255,   0,   0],        [255,   0,   0]]]), fps=1}
7
{start=1, end=2, duration=1, memoize=False, memoized_t=None, memoized_frame=None, mask=None, audio=None, relative_pos=False, layer=0, is_mask=False, has_constant_size=True, size=(2, 2), img=array([[[255,   0,   0],        [255,   0,   0]],       [[255,   0,   0],        [255,   0,   0]]]), fps=1}
@py_assert1: 9
None
@py_assert3: 9
None
Project Name: activeloopai+deeplake
Language: Python
Statement Type: Branch

Source Code:
def _validate_htype_overwrites(htype: str, htype_overwrite: dict):
    """Raises errors if ``htype_overwrite`` has invalid keys or was missing required values."""

    defaults = HTYPE_CONFIGURATIONS[htype]

    for key, value in htype_overwrite.items():
        if key not in defaults:
            raise TensorMetaInvalidHtypeOverwriteKey(htype, key, list(defaults.keys()))

        if isinstance(value, str) and value == UNSPECIFIED:
            if defaults[key] == REQUIRE_USER_SPECIFICATION:
                raise TensorMetaMissingRequiredValue(htype, key)

    sc = htype_overwrite["sample_compression"]
    cc = htype_overwrite["chunk_compression"]
    compr = sc if cc in (None, UNSPECIFIED) else cc
    actual_htype = f"link[{htype}]" if htype_overwrite["is_link"] else htype
    if htype.startswith("image") and sc == UNSPECIFIED and cc == UNSPECIFIED:
        raise TensorMetaMissingRequiredValue(
            actual_htype, ["chunk_compression", "sample_compression"]  # type: ignore
        )
    if htype in ("audio", "video", "point_cloud", "mesh", "nifti"):
        if cc not in (UNSPECIFIED, None):
            raise UnsupportedCompressionError("Chunk compression", htype=htype)
        elif sc == UNSPECIFIED:
            raise TensorMetaMissingRequiredValue(
                actual_htype, "sample_compression"  # type: ignore
            )
    supported_compressions = HTYPE_SUPPORTED_COMPRESSIONS.get(htype)
    if (
        compr
        and compr != UNSPECIFIED
        and supported_compressions
        and compr not in supported_compressions
    ):
        raise UnsupportedCompressionError(compr, htype=htype)

_validate_htype_overwrites(htype='generic', htype_overwrite={'sample_compression': 'unspecified', 'chunk_compression': 'unspecified', 'dtype': 'unspecified', 'hidden': False, 'tiling_threshold': None, 'max_chunk_size': 2000000, 'is_sequence': False, 'is_link': False, 'verify': True})

Selected Statement: if htype in ("audio", "video", "point_cloud", "mesh", "nifti"):

Function Input:
htype: 'generic'
htype_overwrite: sample_compression: unspecified
chunk_compression: unspecified
dtype: unspecified
hidden: no
max_chunk_size: 2000000
is_sequence: no
is_link: no
verify: yes

Variable Values Before Statement:
htype: 'generic'

Value After Statement Execution: No

Variable States During Runtime (line, value):
htype: 1
'generic'
htype_overwrite: 1
sample_compression: unspecified
chunk_compression: unspecified
dtype: unspecified
hidden: no
max_chunk_size: 2000000
is_sequence: no
is_link: no
verify: yes
defaults: 4
is_sequence: no
is_link: no
hidden: no
verify: no
key: 6
'sample_compression'
6
'chunk_compression'
6
'dtype'
6
'hidden'
6
'tiling_threshold'
6
'max_chunk_size'
6
'is_sequence'
6
'is_link'
6
'verify'
value: 6
'unspecified'
6
False
6
None
6
2000000
6
False
6
True
sc: 14
'unspecified'
cc: 15
'unspecified'
compr: 16
'unspecified'
actual_htype: 17
'generic'
supported_compressions: 29
None