MonoshiTonmoy/Code_Statement_Prediction_Dataset huggingface dataset:
Project Name: google-research+arxiv-latex-cleaner
Language: Python
Statement Type: Constant Assignment

Source Code:
def _remove_iffalse_block(text):
  """Removes possibly nested r'\iffalse*\fi' blocks from 'text'."""
  p = regex.compile(r'\\if\s*(\w+)|\\fi(?!\w)')
  level = -1
  positions_to_delete = []
  start, end = 0, 0
  for m in p.finditer(text):
    if (
        m.group().replace(' ', '') == r'\iffalse'
        or m.group().replace(' ', '') == r'\if0'
    ) and level == -1:
      level += 1
      start = m.start()
    elif m.group().startswith(r'\if') and level >= 0:
      level += 1
    elif m.group() == r'\fi' and level >= 0:
      if level == 0:
        end = m.end()
        positions_to_delete.append((start, end))
      level -= 1
    else:
      pass

  for start, end in reversed(positions_to_delete):
    if end < len(text) and text[end].isspace():
      end_to_del = end + 1
    else:
      end_to_del = end
    text = text[:start] + text[end_to_del:]

  return text

_remove_iffalse_block(text='\\newcommand\\figref[1]{Figure~\\ref{fig:\\#1}}')

Selected Statement: level = -1

Function Input:
text: '\\newcommand\\figref[1]{Figure~\\ref{fig:\\#1}}'

Variable Values Before Statement:
Constant: -1

Value After Statement Execution: -1

Variable States During Runtime (line, value):
text: 1
'\\newcommand\\figref[1]{Figure~\\ref{fig:\\#1}}'
p: 3
regex.Regex('\\\\if\\s*(\\w+)|\\\\fi(?!\\w)', flags=regex.V0)
level: 4
-1
positions_to_delete: 5
start: 6
0
end: 6
0
Project Name: google-research+arxiv-latex-cleaner
Language: Python
Statement Type: Constant Assignment

Source Code:
def _search_reference(filename, contents, strict=False):
  """Returns a match object if filename is referenced in contents, and None otherwise.

  If not strict mode, path prefix and extension are optional.
  """
  if strict:
    # regex pattern for strict=True for path/to/img.ext:
    # \{[\s%]*path/to/img\.ext[\s%]*\}
    filename_regex = filename.replace('.', r'\.')
  else:
    filename_path = Path(filename)

    # make extension optional
    root, extension = filename_path.stem, filename_path.suffix
    basename_regex = '{}({})?'.format(
        regex.escape(root), regex.escape(extension)
    )

    # iterate through parent fragments to make path prefix optional
    path_prefix_regex = ''
    for fragment in reversed(filename_path.parents):
      if fragment.name == '.':
        continue
      fragment = regex.escape(fragment.name)
      path_prefix_regex = '({}{}{})?'.format(
          path_prefix_regex, fragment, os.sep
      )

    # Regex pattern for strict=True for path/to/img.ext:
    # \{[\s%]*(<path_prefix>)?<basename>(<ext>)?[\s%]*\}
    filename_regex = path_prefix_regex + basename_regex

  # Some files 'path/to/file' are referenced in tex as './path/to/file' thus
  # adds prefix for relative paths starting with './' or '.\' to regex search.
  filename_regex = r'(.' + os.sep + r')?' + filename_regex

  # Pads with braces and optional whitespace/comment characters.
  patn = r'\{{[\s%]*{}[\s%]*\}}'.format(filename_regex)
  # Picture references in LaTeX are allowed to be in different cases.
  return regex.search(patn, contents, regex.IGNORECASE)

_search_reference(filename='to/img.ext', contents='{img.ext}', strict=False)

Selected Statement: path_prefix_regex = ''

Function Input:
filename: 'to/img.ext'
contents: '{img.ext}'
strict: False

Variable Values Before Statement:
Constant: ''

Value After Statement Execution: ''

Variable States During Runtime (line, value):
filename: 1
'to/img.ext'
contents: 1
'{img.ext}'
strict: 1
False
filename_path: 11
PosixPath('to/img.ext')
root: 14
'img'
extension: 14
'.ext'
basename_regex: 15
'img(\\.ext)?'
path_prefix_regex: 20
''
25
'(/)?'
25
'((/)?to/)?'
fragment: 21
PosixPath('.')
24
''
21
PosixPath('to')
24
'to'
filename_regex: 31
'((/)?to/)?img(\\.ext)?'
35
'(./)?((/)?to/)?img(\\.ext)?'
patn: 38
'\\{[\\s%]*(./)?((/)?to/)?img(\\.ext)?[\\s%]*\\}'
Project Name: d3rp+clima
Language: Python
Statement Type: Constant Assignment

Source Code:
def attr_map(parsed_params):
    """Mapping for the schema's fields (parameters)"""
    mapped_attrs = {}
    for param_type, def_desc in parsed_params.items():
        if ':' in param_type:
            param, _type = param_type.split(':', 1)
            _type = _type.strip()
        else:
            param = param_type
            _type = None

        # TODO: this won't handle # in strings ...
        if '#' in def_desc:
            default, description = def_desc.split('#', 1)
            default = default.strip()
            description = description.strip()
        else:
            default = def_desc.strip()
            description = ''

        mapped_attrs.update(
            {
                param: {
                    'type': _type,
                    'default': default,
                    'description': description,
                }
            }
        )
    return mapped_attrs

attr_map(parsed_params=OrderedDict([('bar: int', '0')]))

Selected Statement: description = ''

Function Input:
parsed_params: OrderedDict([('bar: int', '0')])

Variable Values Before Statement:
Constant: ''

Value After Statement Execution: ''

Variable States During Runtime (line, value):
parsed_params: 1
OrderedDict([('bar: int', '0')])
mapped_attrs: 3
21
{'bar': {'type': 'int', 'default': '0', 'description': ''}}
param_type: 4
'bar: int'
def_desc: 4
'0'
param: 6
'bar'
_type: 6
' int'
7
'int'
default: 18
'0'
description: 19
''
Project Name: d3rp+clima
Language: Python
Statement Type: Constant Assignment

Source Code:
def _ParseFn(args):
    """Parses the list of `args` into (varargs, kwargs), remaining_args."""
    kwargs, remaining_kwargs, remaining_args = _ParseKeywordArgs(
        args, all_args, fn_spec.varkw)

    # Note: _ParseArgs modifies kwargs.
    parsed_args, kwargs, remaining_args, capacity = _ParseArgs(
        fn_spec.args, fn_spec.defaults, num_required_args, kwargs,
        remaining_args, metadata)

    if fn_spec.varargs or fn_spec.varkw:
      # If we're allowed *varargs or **kwargs, there's always capacity.
      capacity = True

    extra_kw = set(kwargs) - set(fn_spec.kwonlyargs)
    if fn_spec.varkw is None and extra_kw:
      raise FireError('Unexpected kwargs present:', extra_kw)

    missing_kwonly = set(required_kwonly) - set(kwargs)
    if missing_kwonly:
      raise FireError('Missing required flags:', missing_kwonly)

    # If we accept *varargs, then use all remaining arguments for *varargs.
    if fn_spec.varargs is not None:
      varargs, remaining_args = remaining_args, []
    else:
      varargs = []

    for index, value in enumerate(varargs):
      varargs[index] = _ParseValue(value, None, None, metadata)

    varargs = parsed_args + varargs
    remaining_args += remaining_kwargs

    consumed_args = args[:len(args) - len(remaining_args)]
    return (varargs, kwargs), consumed_args, remaining_args, capacity

_ParseFn(args=['x'], all_args=[], fn_spec={args=[], varargs=None, varkw='cli_args', defaults=(), kwonlyargs=[], kwonlydefaults={}, annotations={}}, metadata={'ACCEPTS_POSITIONAL_ARGS': False}, num_required_args=0, required_kwonly=set())

Selected Statement: capacity = True

Function Input:
args: x
fn_spec: {args=[], varargs=None, varkw='cli_args', defaults=(), kwonlyargs=[], kwonlydefaults={}, annotations={}}
metadata: ACCEPTS_POSITIONAL_ARGS: no
num_required_args: 0
required_kwonly: set()

Variable Values Before Statement:
Constant: True

Value After Statement Execution: True

Variable States During Runtime (line, value):
args: 1
x
all_args: 1
fn_spec: 1
{args=[], varargs=None, varkw='cli_args', defaults=(), kwonlyargs=[], kwonlydefaults={}, annotations={}}
metadata: 1
ACCEPTS_POSITIONAL_ARGS: no
num_required_args: 1
0
required_kwonly: 1
set()
kwargs: 3
remaining_kwargs: 3
remaining_args: 3
x
parsed_args: 7
capacity: 7
False
13
True
extra_kw: 15
set()
missing_kwonly: 19
set()
varargs: 27
consumed_args: 35
Project Name: miguelgrinberg+flasky
Language: Python
Statement Type: Constant Assignment

Source Code:
def insert_roles():
        roles = {
            'User': [Permission.FOLLOW, Permission.COMMENT, Permission.WRITE],
            'Moderator': [Permission.FOLLOW, Permission.COMMENT,
                          Permission.WRITE, Permission.MODERATE],
            'Administrator': [Permission.FOLLOW, Permission.COMMENT,
                              Permission.WRITE, Permission.MODERATE,
                              Permission.ADMIN],
        }
        default_role = 'User'
        for r in roles:
            role = Role.query.filter_by(name=r).first()
            if role is None:
                role = Role(name=r)
            role.reset_permissions()
            for perm in roles[r]:
                role.add_permission(perm)
            role.default = (role.name == default_role)
            db.session.add(role)
        db.session.commit()

insert_roles()

Selected Statement: default_role = 'User'

Function Input:

Variable Values Before Statement:
Constant: 'User'

Value After Statement Execution: 'User'

Variable States During Runtime (line, value):
roles: 2
{'User': [1, 2, 4], 'Moderator': [1, 2, 4, 8], 'Administrator': [1, 2, 4, 8, 16]}
default_role: 10
'User'
r: 11
'User'
11
'Moderator'
11
'Administrator'
role: 12
None
14
<Role 'User'>
12
None
14
<Role 'Moderator'>
12
None
14
<Role 'Administrator'>
perm: 16
1
16
2
16
4
16
1
16
2
16
4
16
8
16
1
16
2
16
4
16
8
16
16
Project Name: miguelgrinberg+flasky
Language: Python
Statement Type: Constant Assignment

Source Code:
def unauthorized(message):
    response = jsonify({'error': 'unauthorized', 'message': message})
    response.status_code = 401
    return response

unauthorized(message='Invalid credentials')

Selected Statement: response.status_code = 401

Function Input:
message: 'Invalid credentials'

Variable Values Before Statement:
Constant: 401

Value After Statement Execution: 401

Variable States During Runtime (line, value):
message: 1
'Invalid credentials'
response: 2
<Response 67 bytes [200 OK]>
3
<Response 67 bytes [401 UNAUTHORIZED]>
Project Name: paul-gauthier+aider
Language: Python
Statement Type: Constant Assignment

Source Code:
def check_gitignore(git_root, io, ask=True):
    if not git_root:
        return

    try:
        repo = git.Repo(git_root)
        if repo.ignored(".aider"):
            return
    except git.exc.InvalidGitRepositoryError:
        pass

    pat = ".aider*"

    gitignore_file = Path(git_root) / ".gitignore"
    if gitignore_file.exists():
        content = io.read_text(gitignore_file)
        if content is None:
            return
        if pat in content.splitlines():
            return
    else:
        content = ""

    if ask and not io.confirm_ask(f"Add {pat} to .gitignore (recommended)?"):
        return

    if content and not content.endswith("\n"):
        content += "\n"
    content += pat + "\n"
    io.write_text(gitignore_file, content)

    io.tool_output(f"Added {pat} to .gitignore")

check_gitignore(git_root=PosixPath('/tmp/tmpcr1f5en7'), io={user_input_color=None, tool_output_color=None, tool_error_color=None, input=None, output=None, pretty=False, yes=True, input_history_file=None, chat_history_file=None, encoding='utf-8', dry_run=False, console=<console width=105 None>}, ask=True)

Selected Statement: pat = ".aider*"

Function Input:
git_root: PosixPath('/tmp/tmpcr1f5en7')
io: {user_input_color=None, tool_output_color=None, tool_error_color=None, input=None, output=None, pretty=False, yes=True, input_history_file=None, chat_history_file=None, encoding='utf-8', dry_run=False, console=<console width=105 None>}
ask: True

Variable Values Before Statement:
Constant: ".aider*"

Value After Statement Execution: ".aider*"

Variable States During Runtime (line, value):
git_root: 1
PosixPath('/tmp/tmpcr1f5en7')
io: 1
{user_input_color=None, tool_output_color=None, tool_error_color=None, input=None, output=None, pretty=False, yes=True, input_history_file=None, chat_history_file=None, encoding='utf-8', dry_run=False, console=<console width=105 None>}
24
{user_input_color=None, tool_output_color=None, tool_error_color=None, input=None, output=None, pretty=False, yes=True, input_history_file=None, chat_history_file=None, encoding='utf-8', dry_run=False, console=<console width=105 None>, num_user_asks=1}
ask: 1
True
repo: 6
<git.repo.base.Repo '/tmp/tmpcr1f5en7/.git'>
pat: 12
'.aider*'
gitignore_file: 14
PosixPath('/tmp/tmpcr1f5en7/.gitignore')
content: 22
''
29
'.aider*\n'
Project Name: paul-gauthier+aider
Language: Python
Statement Type: Constant Assignment

Source Code:
def find_diffs(content):
    # We can always fence with triple-quotes, because all the udiff content
    # is prefixed with +/-/space.

    if not content.endswith("\n"):
        content = content + "\n"

    lines = content.splitlines(keepends=True)
    line_num = 0
    edits = []
    while line_num < len(lines):
        while line_num < len(lines):
            line = lines[line_num]
            if line.startswith("```diff"):
                line_num, these_edits = process_fenced_block(lines, line_num + 1)
                edits += these_edits
                break
            line_num += 1

    # For now, just take 1!
    # edits = edits[:1]

    return edits

find_diffs(content='\nSome text...\n\n```diff\n--- /dev/null\n+++ file.txt\n@@ ... @@\n-Original\n+Modified\n```\n')

Selected Statement: line_num = 0

Function Input:
content: '\nSome text...\n\n```diff\n--- /dev/null\n+++ file.txt\n@@ ... @@\n-Original\n+Modified\n```\n'

Variable Values Before Statement:
Constant: 0

Value After Statement Execution: 0

Variable States During Runtime (line, value):
content: 1
'\nSome text...\n\n```diff\n--- /dev/null\n+++ file.txt\n@@ ... @@\n-Original\n+Modified\n```\n'
lines: 8


Some text...



```diff

--- /dev/null

+++ file.txt

@@ ... @@

-Original

+Modified

```

line_num: 9
0
18
1
18
2
18
3
15
10
edits: 10
16
[('file.txt', ['-Original\n', '+Modified\n'])]
line: 13
'\n'
13
'Some text...\n'
13
'\n'
13
'```diff\n'
these_edits: 15
[('file.txt', ['-Original\n', '+Modified\n'])]
Project Name: paul-gauthier+aider
Language: Python
Statement Type: Constant Assignment

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: keeper = False

Function Input:
lines: 

Some text...



```diff

--- /dev/null

+++ file.txt

@@ ... @@

-Original

+Modified

```

start_line_num: 4

Variable Values Before Statement:
Constant: False

Value After Statement Execution: False

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: Constant Assignment

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: state = 1

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:
Constant: 1

Value After Statement Execution: 1

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: GeoStat-Framework+welltestpy
Language: Python
Statement Type: Constant Assignment

Source Code:
def _solequal(sol1, sol2, prec):
    """
    Compare two different solutions with a given precicion.

    Return True if they equal.
    """
    res = True

    for sol_1, sol_2 in zip(sol1, sol2):
        if np.ndim(sol_1) != 0 and np.ndim(sol_2) != 0:
            res &= _dist(sol_1, sol_2) < prec
        elif np.ndim(sol_1) != 0 and np.ndim(sol_2) == 0:
            return False
        elif np.ndim(sol_1) == 0 and np.ndim(sol_2) != 0:
            return False

    return res

_solequal(sol1=[array([0., 0.]), array([3., 0.]), array([3.5       , 1.93649167]), array([ 0.16666667, -0.9860133 ])], sol2=[array([0., 0.]), array([3., 0.]), array([3.5       , 1.93649167]), array([0.16666667, 0.9860133 ])], prec=0.1)

Selected Statement: res = True

Function Input:
sol1: [array([0., 0.]), array([3., 0.]), array([3.5       , 1.93649167]), array([ 0.16666667, -0.9860133 ])]
sol2: [array([0., 0.]), array([3., 0.]), array([3.5       , 1.93649167]), array([0.16666667, 0.9860133 ])]
prec: 0.1

Variable Values Before Statement:
Constant: True

Value After Statement Execution: True

Variable States During Runtime (line, value):
sol1: 1
[array([0., 0.]), array([3., 0.]), array([3.5       , 1.93649167]), array([ 0.16666667, -0.9860133 ])]
sol2: 1
[array([0., 0.]), array([3., 0.]), array([3.5       , 1.93649167]), array([0.16666667, 0.9860133 ])]
prec: 1
0.1
res: 7
True
11
False
sol_1: 9
array([0., 0.])
9
array([3., 0.])
9
array([3.5       , 1.93649167])
9
array([ 0.16666667, -0.9860133 ])
sol_2: 9
array([0., 0.])
9
array([3., 0.])
9
array([3.5       , 1.93649167])
9
array([0.16666667, 0.9860133 ])
Project Name: activeloopai+deeplake
Language: Python
Statement Type: Constant Assignment

Source Code:
def parse_access_method(access_method: str):
    num_workers = 0
    scheduler = "threaded"
    download = access_method.startswith("download")
    local = access_method.startswith("local")
    if download or local:
        split = access_method.split(":")
        if len(split) == 1:
            split.extend(("threaded", "0"))
        elif len(split) == 2:
            split.append("threaded" if split[1].isnumeric() else "0")
        elif len(split) >= 3:
            num_integers = sum(1 for i in split if i.isnumeric())
            if num_integers != 1 or len(split) > 3:
                raise ValueError(
                    "Invalid access_method format. Expected format is one of the following: {download, download:scheduler, download:num_workers, download:scheduler:num_workers, download:num_workers:scheduler}"
                )

        access_method = "download" if download else "local"
        num_worker_index = 1 if split[1].isnumeric() else 2
        scheduler_index = 3 - num_worker_index
        num_workers = int(split[num_worker_index])
        scheduler = split[scheduler_index]
    return access_method, num_workers, scheduler

parse_access_method(access_method='download')

Selected Statement: num_workers = 0

Function Input:
access_method: 'download'

Variable Values Before Statement:
Constant: 0

Value After Statement Execution: 0

Variable States During Runtime (line, value):
access_method: 1
'download'
num_workers: 2
0
scheduler: 3
'threaded'
download: 4
True
local: 5
False
split: 7
download
9
download, threaded, 0
num_worker_index: 20
2
scheduler_index: 21
1