MonoshiTonmoy/Code_Statement_Prediction_Dataset huggingface dataset:
Project Name: JRCSTU+co2mpas-ta
Language: Python
Statement Type: API

Source Code:
def _co2mpas_info2df(start_time, main_flags=None):
    import socket
    import datetime
    from co2mpas import __version__
    from ..load.schema import define_flags_schema
    time_elapsed = (datetime.datetime.today() - start_time).total_seconds()
    hostname = socket.gethostname()
    info = [
        ('CO2MPAS version', __version__),
        ('Simulation started', start_time.strftime('%Y/%m/%d-%H:%M:%S')),
        ('Time elapsed', '%.3f sec' % time_elapsed),
        ('Hostname', hostname),
    ]

    if main_flags:
        main_flags = define_flags_schema(read=False).validate(main_flags)
        info.extend(sorted(main_flags.items()))
    import pandas as pd
    df = pd.DataFrame(info, columns=['Parameter', 'Value'])
    df.set_index(['Parameter'], inplace=True)
    setattr(df, 'name', 'info')
    return df

_co2mpas_info2df(start_time=datetime.datetime(2024, 4, 3, 16, 28, 9, 62286), main_flags=None)

Selected Statement: df = pd.DataFrame(info, columns=['Parameter', 'Value'])

Function Input:
start_time: datetime.datetime(2024, 4, 3, 16, 28, 9, 62286)
main_flags: None

Variable Values Before Statement:
info: [('CO2MPAS version', '4.1.6'), ('Simulation started', '2024/04/03-16:28:09'), ('Time elapsed', '103.530 sec'), ('Hostname', 'thor')]

Value After Statement Execution: Parameter                Value0     CO2MPAS version                4.1.61  Simulation started  2024/04/03-16:28:092        Time elapsed          103.530 sec3            Hostname                 thor

Variable States During Runtime (line, value):
start_time: 1
datetime.datetime(2024, 4, 3, 16, 28, 9, 62286)
main_flags: 1
None
socket: 2
<module 'socket' from '/local/rcs/jinjun/miniforge3/envs/JRCSTU+co2mpas-ta/lib/python3.9/socket.py'>
datetime: 3
<module 'datetime' from '/local/rcs/jinjun/miniforge3/envs/JRCSTU+co2mpas-ta/lib/python3.9/datetime.py'>
__version__: 4
'4.1.6'
define_flags_schema: 5
{__module__='co2mpas.core.load.schema', __name__='define_flags_schema', __qualname__='define_flags_schema', __doc__='\n    Define flag schema.\n\n    :param read:\n        Schema for reading?\n    :type read: bool\n\n    :return:\n        Flag schema.\n    :rtype: schema.Schema\n    ', __annotations__={}}
time_elapsed: 6
103.529885
hostname: 7
'thor'
info: 8
[('CO2MPAS version', '4.1.6'), ('Simulation started', '2024/04/03-16:28:09'), ('Time elapsed', '103.530 sec'), ('Hostname', 'thor')]
pd: 18
<module 'pandas' from '/local/rcs/jinjun/miniforge3/envs/JRCSTU+co2mpas-ta/lib/python3.9/site-packages/pandas/__init__.py'>
df: 19
            Parameter                Value0     CO2MPAS version                4.1.61  Simulation started  2024/04/03-16:28:092        Time elapsed          103.530 sec3            Hostname                 thor
20
                                  ValueParameter                              CO2MPAS version                   4.1.6Simulation started  2024/04/03-16:28:09Time elapsed                103.530 secHostname                           thor
Project Name: JRCSTU+co2mpas-ta
Language: Python
Statement Type: API

Source Code:
def dump(self, file, default_flow_style=False, **kw):
        import yaml
        kw['Dumper'] = kw.get('Dumper', yaml.CDumper)
        with open(file, 'w') as f:
            yaml.dump(
                self.to_dict(), f, default_flow_style=default_flow_style, **kw
            )

dump(self={}, file='./conf.yaml', default_flow_style=False, kw={})

Selected Statement: with open(file, 'w') as f:

Function Input:
file: './conf.yaml'
default_flow_style: False

Variable Values Before Statement:
file: './conf.yaml'

Value After Statement Execution: <_io.TextIOWrapper name

Variable States During Runtime (line, value):
self: 1
file: 1
'./conf.yaml'
default_flow_style: 1
False
kw: 1
3
{'Dumper': <class 'yaml.cyaml.CDumper'>}
yaml: 2
<module 'yaml' from '/local/rcs/jinjun/miniforge3/envs/JRCSTU+co2mpas-ta/lib/python3.9/site-packages/yaml/__init__.py'>
f: 4
<_io.TextIOWrapper name='./conf.yaml' mode='w' encoding='UTF-8'>
Project Name: coreofscience+python-wostools
Language: Python
Statement Type: API

Source Code:
def article_missing(field: str):
    article = Article(
        title=None, authors=["L, Robertson"], year=1999, journal="Science"
    )
    setattr(article, field, None)
    return ArticleWrapper(article=article)

article_missing(field='year')

Selected Statement: setattr(article, field, None)

Function Input:
field: 'year'

Variable Values Before Statement:
article: {title=None, authors=['L, Robertson'], keywords=[], year=1999, journal='Science', volume=None, issue=None, page=None, doi=None, references=[], sources=set(), extra={}}
field: 'year'

Value After Statement Execution: {title

Variable States During Runtime (line, value):
field: 1
'year'
article: 2
{title=None, authors=['L, Robertson'], keywords=[], year=1999, journal='Science', volume=None, issue=None, page=None, doi=None, references=[], sources=set(), extra={}}
5
{title=None, authors=['L, Robertson'], keywords=[], year=None, journal='Science', volume=None, issue=None, page=None, doi=None, references=[], sources=set(), extra={}}
Project Name: facebookresearch+detectron2
Language: Python
Statement Type: API

Source Code:
def create_dummy_class(klass, dependency, message=""):
    """
    When a dependency of a class is not available, create a dummy class which throws ImportError
    when used.

    Args:
        klass (str): name of the class.
        dependency (str): name of the dependency.
        message: extra message to print
    Returns:
        class: a class object
    """
    err = "Cannot import '{}', therefore '{}' is not available.".format(dependency, klass)
    if message:
        err = err + " " + message

    class _DummyMetaClass(type):
        # throw error on class attribute access
        def __getattr__(_, __):  # noqa: B902
            raise ImportError(err)

    class _Dummy(object, metaclass=_DummyMetaClass):
        # throw error on constructor
        def __init__(self, *args, **kwargs):
            raise ImportError(err)

    return _Dummy

create_dummy_class(klass='DeformConv', dependency='detectron2._C', message='detectron2 is not compiled successfully, please build following the instructions!')

Selected Statement: err = "Cannot import '{}', therefore '{}' is not available.".format(dependency, klass)

Function Input:
klass: 'DeformConv'
dependency: 'detectron2._C'
message: 'detectron2 is not compiled successfully, please build following the instructions!'

Variable Values Before Statement:
dependency: 'detectron2._C'
klass: 'DeformConv'

Value After Statement Execution: "Cannot import 'detectron2._C', therefore 'DeformConv' is not available."

Variable States During Runtime (line, value):
klass: 1
'DeformConv'
dependency: 1
'detectron2._C'
message: 1
'detectron2 is not compiled successfully, please build following the instructions!'
err: 13
"Cannot import 'detectron2._C', therefore 'DeformConv' is not available."
15
"Cannot import 'detectron2._C', therefore 'DeformConv' is not available. detectron2 is not compiled successfully, please build following the instructions!"
_DummyMetaClass: 17
<class 'detectron2.utils.develop.create_dummy_class.<locals>._DummyMetaClass'>
_Dummy: 22
<class 'detectron2.utils.develop.create_dummy_class.<locals>._Dummy'>
Project Name: facebookresearch+detectron2
Language: Python
Statement Type: API

Source Code:
def create_dummy_func(func, dependency, message=""):
    """
    When a dependency of a function is not available, create a dummy function which throws
    ImportError when used.

    Args:
        func (str): name of the function.
        dependency (str or list[str]): name(s) of the dependency.
        message: extra message to print
    Returns:
        function: a function object
    """
    err = "Cannot import '{}', therefore '{}' is not available.".format(dependency, func)
    if message:
        err = err + " " + message

    if isinstance(dependency, (list, tuple)):
        dependency = ",".join(dependency)

    def _dummy(*args, **kwargs):
        raise ImportError(err)

    return _dummy

create_dummy_func(func='deform_conv', dependency='detectron2._C', message='detectron2 is not compiled successfully, please build following the instructions!')

Selected Statement: err = "Cannot import '{}', therefore '{}' is not available.".format(dependency, func)

Function Input:
func: 'deform_conv'
dependency: 'detectron2._C'
message: 'detectron2 is not compiled successfully, please build following the instructions!'

Variable Values Before Statement:
dependency: 'detectron2._C'
func: 'deform_conv'

Value After Statement Execution: "Cannot import 'detectron2._C', therefore 'deform_conv' is not available."

Variable States During Runtime (line, value):
func: 1
'deform_conv'
dependency: 1
'detectron2._C'
message: 1
'detectron2 is not compiled successfully, please build following the instructions!'
err: 13
"Cannot import 'detectron2._C', therefore 'deform_conv' is not available."
15
"Cannot import 'detectron2._C', therefore 'deform_conv' is not available. detectron2 is not compiled successfully, please build following the instructions!"
_dummy: 20
<function create_dummy_func.<locals>._dummy at 0x7f3337cdfd30>
Project Name: facebookresearch+detectron2
Language: Python
Statement Type: API

Source Code:
def register_mesh(mesh_info: MeshInfo, base_path: Optional[str]) -> None:
    geodists, symmetry, texcoords = mesh_info.geodists, mesh_info.symmetry, mesh_info.texcoords
    if geodists:
        geodists = maybe_prepend_base_path(base_path, geodists)
    if symmetry:
        symmetry = maybe_prepend_base_path(base_path, symmetry)
    if texcoords:
        texcoords = maybe_prepend_base_path(base_path, texcoords)
    MeshCatalog[mesh_info.name] = MeshInfo(
        name=mesh_info.name,
        data=maybe_prepend_base_path(base_path, mesh_info.data),
        geodists=geodists,
        symmetry=symmetry,
        texcoords=texcoords,
    )

register_mesh(mesh_info=MeshInfo(name='smpl_27554', data='smpl_27554.pkl', geodists='geodists/geodists_smpl_27554.pkl', symmetry='symmetry/symmetry_smpl_27554.pkl', texcoords='texcoords/texcoords_smpl_27554.pkl'), base_path='https://dl.fbaipublicfiles.com/densepose/meshes/')

Selected Statement: geodists = maybe_prepend_base_path(base_path, geodists)

Function Input:
mesh_info: MeshInfo(name='smpl_27554', data='smpl_27554.pkl', geodists='geodists/geodists_smpl_27554.pkl', symmetry='symmetry/symmetry_smpl_27554.pkl', texcoords='texcoords/texcoords_smpl_27554.pkl')
base_path: 'https://dl.fbaipublicfiles.com/densepose/meshes/'

Variable Values Before Statement:
base_path: 'https://dl.fbaipublicfiles.com/densepose/meshes/'
geodists: 'geodists/geodists_smpl_27554.pkl'

Value After Statement Execution: 'https://dl.fbaipublicfiles.com/densepose/meshes/geodists/geodists_smpl_27554.pkl'

Variable States During Runtime (line, value):
mesh_info: 1
MeshInfo(name='smpl_27554', data='smpl_27554.pkl', geodists='geodists/geodists_smpl_27554.pkl', symmetry='symmetry/symmetry_smpl_27554.pkl', texcoords='texcoords/texcoords_smpl_27554.pkl')
base_path: 1
'https://dl.fbaipublicfiles.com/densepose/meshes/'
geodists: 2
'geodists/geodists_smpl_27554.pkl'
4
'https://dl.fbaipublicfiles.com/densepose/meshes/geodists/geodists_smpl_27554.pkl'
symmetry: 2
'symmetry/symmetry_smpl_27554.pkl'
6
'https://dl.fbaipublicfiles.com/densepose/meshes/symmetry/symmetry_smpl_27554.pkl'
texcoords: 2
'texcoords/texcoords_smpl_27554.pkl'
8
'https://dl.fbaipublicfiles.com/densepose/meshes/texcoords/texcoords_smpl_27554.pkl'
Project Name: European-XFEL+h5glance
Language: Python
Statement Type: API

Source Code:
def fmt_dtype(hdf_dt):
    """Get a (preferably short) string describing an HDF5 datatype"""
    size = hdf_dt.get_size()

    if isinstance(hdf_dt, h5t.TypeIntegerID):
        # Check normal int & uint dtypes first
        for candidate, descr in int_types_by_size().get(size, ()):
            if hdf_dt == candidate:
                return descr
        un = 'un' if hdf_dt.get_sign() == h5t.SGN_NONE else ''
        return "{}-byte {}signed integer".format(size, un)
    elif isinstance(hdf_dt, h5t.TypeFloatID):
        # Check normal float dtypes first
        for candidate, descr in float_types_by_size().get(size, ()):
            if hdf_dt == candidate:
                return descr
        return "custom {}-byte float".format(size)
    elif isinstance(hdf_dt, h5t.TypeBitfieldID):
        return "{}-byte bitfield".format(size)
    elif isinstance(hdf_dt, h5t.TypeTimeID):
        return "time"  # NB. time datatype is deprecated
    elif isinstance(hdf_dt, h5t.TypeOpaqueID):
        s = "{}-byte opaque".format(size)
        tag = hdf_dt.get_tag()
        if tag:
            s += ' ({})'.format(tag.decode('utf-8', 'replace'))
        return s
    elif isinstance(hdf_dt, h5t.TypeStringID):
        cset = cset_names.get(hdf_dt.get_cset(), '?cset')
        if hdf_dt.is_variable_str():
            return "{} string".format(cset)
        else:
            return "{}-byte {} string".format(size, cset)
    elif isinstance(hdf_dt, h5t.TypeVlenID):
        return "vlen array of " + fmt_dtype(hdf_dt.get_super())
    elif isinstance(hdf_dt, h5t.TypeArrayID):
        shape = fmt_shape(hdf_dt.get_array_dims())
        return "{} array of {}".format(shape, fmt_dtype(hdf_dt.get_super()))

    elif isinstance(hdf_dt, h5t.TypeCompoundID):
        return "({})".format(", ".join(
            "{}: {}".format(
                hdf_dt.get_member_name(i).decode('utf-8', 'replace'),
                fmt_dtype(hdf_dt.get_member_type(i))
            )
            for i in range(hdf_dt.get_nmembers())
        ))
    elif isinstance(hdf_dt, h5t.TypeEnumID):
        nmembers = hdf_dt.get_nmembers()
        if nmembers >= 5:
            return "enum ({} options)".format(nmembers)
        else:
            return "enum ({})".format(", ".join(
                hdf_dt.get_member_name(i).decode('utf-8', 'replace')
                for i in range(nmembers)
            ))
    elif isinstance(hdf_dt, h5t.TypeReferenceID):
        return "region ref" if hdf_dt == h5t.STD_REF_DSETREG else "object ref"

    return "unrecognised {}-byte datatype".format(size)

fmt_dtype(hdf_dt=REPR FAILED)

Selected Statement: for candidate, descr in float_types_by_size().get(size, ()):

Function Input:
hdf_dt: REPR FAILED

Variable Values Before Statement:
size: 4

Value After Statement Execution: REPR FAILED

Variable States During Runtime (line, value):
hdf_dt: 1
REPR FAILED
size: 3
4
candidate: 14
REPR FAILED
descr: 14
'float32'
Project Name: European-XFEL+h5glance
Language: Python
Statement Type: API

Source Code:
def dtype_description(hdf_dt):
    """A slightly longer description, suitable for a tooltip

    Can return None
    """
    size = hdf_dt.get_size()

    if isinstance(hdf_dt, h5t.TypeIntegerID):
        # Check normal int & uint dtypes first
        for candidate, descr in int_types_by_size().get(size, ()):
            if hdf_dt == candidate:
                un = 'un' if hdf_dt.get_sign() == h5t.SGN_NONE else ''
                return '{}-bit {}signed integer'.format(size * 8, un)

    elif isinstance(hdf_dt, h5t.TypeFloatID):
        # Check normal float dtypes first
        for candidate, descr in float_types_by_size().get(size, ()):
            if hdf_dt == candidate:
                return '{}-bit floating point'.format(size * 8)

    return None

dtype_description(hdf_dt=REPR FAILED)

Selected Statement: for candidate, descr in float_types_by_size().get(size, ()):

Function Input:
hdf_dt: REPR FAILED

Variable Values Before Statement:
size: 4

Value After Statement Execution: REPR FAILED

Variable States During Runtime (line, value):
hdf_dt: 1
REPR FAILED
size: 6
4
candidate: 17
REPR FAILED
descr: 17
'float32'
Project Name: altair-viz+altair
Language: Python
Statement Type: API

Source Code:
def _prepare_references_in_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
    # Create a copy so that $ref is not modified in the original schema in case
    # that it would still reference a dictionary which might be attached to
    # an Altair class _schema attribute
    schema = copy.deepcopy(schema)

    def _prepare_refs(d: Dict[str, Any]) -> Dict[str, Any]:
        """Add _VEGA_LITE_ROOT_URI in front of all $ref values. This function
        recursively iterates through the whole dictionary."""
        for key, value in d.items():
            if key == "$ref":
                d[key] = _VEGA_LITE_ROOT_URI + d[key]
            else:
                # $ref values can only be nested in dictionaries or lists
                # as the passed in `d` dictionary comes from the Vega-Lite json schema
                # and in json we only have arrays (-> lists in Python) and objects
                # (-> dictionaries in Python) which we need to iterate through.
                if isinstance(value, dict):
                    d[key] = _prepare_refs(value)
                elif isinstance(value, list):
                    prepared_values = []
                    for v in value:
                        if isinstance(v, dict):
                            v = _prepare_refs(v)
                        prepared_values.append(v)
                    d[key] = prepared_values
        return d

    schema = _prepare_refs(schema)
    return schema

_prepare_references_in_schema(schema={'$ref': '#/definitions/ExprRef'})

Selected Statement: schema = _prepare_refs(schema)

Function Input:
schema: $ref: #/definitions/ExprRef

Variable Values Before Statement:
schema: $ref: #/definitions/ExprRef

Value After Statement Execution: $ref: urn:vega-lite-schema#/definitions/ExprRef

Variable States During Runtime (line, value):
schema: 1
$ref: #/definitions/ExprRef
29
$ref: urn:vega-lite-schema#/definitions/ExprRef
_prepare_refs: 7
<function _prepare_references_in_schema.<locals>._prepare_refs at 0x7fc2eb850a60>
Project Name: gruns+icecream
Language: Python
Statement Type: API

Source Code:
def lineAfterContext(line, prefix):
    if line.startswith(prefix):
        line = line[len(prefix):]

    toks = line.split(' in ', 1)
    if len(toks) == 2:
        rest = toks[1].split(' ')
        line = ' '.join(rest[1:])

    return line

lineAfterContext(line='ic| eins: zwei', prefix='ic| ')

Selected Statement: line = line[len(prefix):]

Function Input:
line: 'ic| eins: zwei'
prefix: 'ic| '

Variable Values Before Statement:
prefix: 'ic| '

Value After Statement Execution: 'eins: zwei'

Variable States During Runtime (line, value):
line: 1
'ic| eins: zwei'
3
'eins: zwei'
prefix: 1
'ic| '
toks: 5
eins: zwei
Project Name: gruns+icecream
Language: Python
Statement Type: API

Source Code:
def argumentToString(obj):
    s = DEFAULT_ARG_TO_STRING_FUNCTION(obj)
    s = s.replace('\\n', '\n')  # Preserve string newlines in output.
    return s

argumentToString(obj=1)

Selected Statement: s = DEFAULT_ARG_TO_STRING_FUNCTION(obj)

Function Input:
obj: 1

Variable Values Before Statement:
obj: 1

Value After Statement Execution: '1'

Variable States During Runtime (line, value):
obj: 1
1
s: 2
'1'
Project Name: gruns+icecream
Language: Python
Statement Type: API

Source Code:
def lineIsContextAndTime(line):
    line = stripPrefix(line)  # ic| f.py:33 in foo() at 08:08:51.389
    context, time = line.split(' at ')

    return (
        lineIsContext(context) and
        len(time.split(':')) == 3 and
        len(time.split('.')) == 2)

lineIsContextAndTime(line='ic| test_icecream.py:229 in testAsArgument() at 01:15:24.779')

Selected Statement: line = stripPrefix(line)  # ic| f.py:33 in foo() at 08:08:51.389

Function Input:
line: 'ic| test_icecream.py:229 in testAsArgument() at 01:15:24.779'

Variable Values Before Statement:
line: 'ic| test_icecream.py:229 in testAsArgument() at 01:15:24.779'

Value After Statement Execution: 'test_icecream.py:229 in testAsArgument() at 01:15:24.779'

Variable States During Runtime (line, value):
line: 1
'ic| test_icecream.py:229 in testAsArgument() at 01:15:24.779'
2
'test_icecream.py:229 in testAsArgument() at 01:15:24.779'
context: 3
'test_icecream.py:229 in testAsArgument()'
time: 3
'01:15:24.779'
Project Name: gruns+icecream
Language: Python
Statement Type: API

Source Code:
def lineIsContext(line):
    line = stripPrefix(line)  # ic| f.py:33 in foo()
    sourceLocation, function = line.split(' in ')  # f.py:33 in foo()
    filename, lineNumber = sourceLocation.split(':')  # f.py:33
    name, ext = splitext(filename)

    return (
        int(lineNumber) > 0 and
        ext in ['.py', '.pyc', '.pyo'] and
        name == splitext(MY_FILENAME)[0] and
        (function == '<module>' or function.endswith('()')))

lineIsContext(line='test_icecream.py:229 in testAsArgument()')

Selected Statement: name, ext = splitext(filename)

Function Input:
line: 'test_icecream.py:229 in testAsArgument()'

Variable Values Before Statement:
filename: 'test_icecream.py'

Value After Statement Execution: 'test_icecream'

Variable States During Runtime (line, value):
line: 1
'test_icecream.py:229 in testAsArgument()'
sourceLocation: 3
'test_icecream.py:229'
function: 3
'testAsArgument()'
filename: 4
'test_icecream.py'
lineNumber: 4
'229'
name: 5
'test_icecream'
ext: 5
'.py'
Project Name: gruns+icecream
Language: Python
Statement Type: API

Source Code:
def format_pair(prefix, arg, value):
    if arg is _arg_source_missing:
        arg_lines = []
        value_prefix = prefix
    else:
        arg_lines = indented_lines(prefix, arg)
        value_prefix = arg_lines[-1] + ': '

    looksLikeAString = value[0] + value[-1] in ["''", '""']
    if looksLikeAString:  # Align the start of multiline strings.
        value = prefixLinesAfterFirst(' ', value)

    value_lines = indented_lines(value_prefix, value)
    lines = arg_lines[:-1] + value_lines
    return '\n'.join(lines)

format_pair(prefix='    ', arg='multilineStr', value="'line1\nline2'")

Selected Statement: arg_lines = indented_lines(prefix, arg)

Function Input:
prefix: '    '
arg: 'multilineStr'
value: "'line1\nline2'"

Variable Values Before Statement:
prefix: '    '
arg: 'multilineStr'

Value After Statement Execution:     multilineStr

Variable States During Runtime (line, value):
prefix: 1
'    '
arg: 1
'multilineStr'
value: 1
"'line1\nline2'"
11
"'line1\n line2'"
arg_lines: 6
    multilineStr
value_prefix: 7
'    multilineStr: '
looksLikeAString: 9
True
value_lines: 13
    multilineStr: 'line1,                    line2'
lines: 14
    multilineStr: 'line1,                    line2'
Project Name: gruns+icecream
Language: Python
Statement Type: API

Source Code:
def appendTo(s):
            lst.append(s)

appendTo(s='ic| a: 1', lst=[])

Selected Statement: lst.append(s)

Function Input:
s: 'ic| a: 1'

Variable Values Before Statement:
s: 'ic| a: 1'

Value After Statement Execution: ic| a: 1

Variable States During Runtime (line, value):
s: 1
'ic| a: 1'
lst: 1
2
ic| a: 1
Project Name: sweepai+sweep
Language: Python
Statement Type: API

Source Code:
def call_on_comment(*args, **kwargs):
    global events
    repo_full_name = kwargs["repo_full_name"]
    pr_id = kwargs["pr_number"]
    key = f"{repo_full_name}-{pr_id}"

    # Check if a previous process exists for the same key, cancel it
    thread = events.get(key, None)
    if thread:
        terminate_thread(thread)

    thread = threading.Thread(target=run_comment, args=args, kwargs=kwargs)
    events[key] = thread
    thread.start()

call_on_comment(args=(), kwargs={'repo_full_name': 'exampleRepo', 'pr_number': 1})

Selected Statement: thread = events.get(key, None)

Function Input:
args: ()
kwargs: repo_full_name: exampleRepo
pr_number: 1

Variable Values Before Statement:
key: 'exampleRepo-1'

Value After Statement Execution: None

Variable States During Runtime (line, value):
args: 1
()
kwargs: 1
repo_full_name: exampleRepo
pr_number: 1
repo_full_name: 3
'exampleRepo'
pr_id: 4
1
key: 5
'exampleRepo-1'
thread: 8
None
12
<Thread(Thread-1, initial)>
14
<Thread(Thread-1, started 140445971379776)>