MonoshiTonmoy/Code_Statement_Prediction_Dataset huggingface dataset:
Project Name: benjamincrom+scrabble
Language: Python
Statement Type: Branch

Source Code:
def get_rack_tile_index(player_rack, move_letter):
    for i, rack_tile in enumerate(player_rack):
        if rack_tile.letter == move_letter:
            return i

    return None

get_rack_tile_index(player_rack=[Q, E, O, S, G, H, E, B, A, K, E, R], move_letter='K')

Selected Statement: if rack_tile.letter == move_letter:

Function Input:
player_rack: [Q, E, O, S, G, H, E, B, A, K, E, R]
move_letter: 'K'

Variable Values Before Statement:
move_letter: 'K'

Value After Statement Execution: No

Variable States During Runtime (line, value):
player_rack: 1
[Q, E, O, S, G, H, E, B, A, K, E, R]
move_letter: 1
'K'
i: 2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
rack_tile: 2
Q
2
E
2
O
2
S
2
G
2
H
2
E
2
B
2
A
2
K
Project Name: benjamincrom+scrabble
Language: Python
Statement Type: Branch

Source Code:
def get_word_set_total_score(board, word_set, num_move_locations):
    total_score = 0
    word_score = 0

    for word_location_set in word_set:
        word_score = 0
        word_multiplier = 1

        for location in word_location_set:
            square = board.board_square_dict[location]
            word_multiplier *= square.word_multiplier
            word_score += square.tile.point_value * square.letter_multiplier

        word_score *= word_multiplier
        total_score += word_score

    if num_move_locations == config.PLAYER_RACK_SIZE:
        total_score += config.BINGO_SCORE

    return total_score

get_word_set_total_score(board=  abcdefghijklmno1 _______________2 _______________3 _______________4 _______________5 _______________6 _______________7 _______________8 _______BAKER___9 _______________10_______________11_______________12_______________13_______________14_______________15_______________, word_set={frozenset(), frozenset({('h', 8), ('j', 8), ('l', 8), ('i', 8), ('k', 8)})}, num_move_locations=5)

Selected Statement: if num_move_locations == config.PLAYER_RACK_SIZE:

Function Input:
board:   abcdefghijklmno1 _______________2 _______________3 _______________4 _______________5 _______________6 _______________7 _______________8 _______BAKER___9 _______________10_______________11_______________12_______________13_______________14_______________15_______________
word_set: {frozenset(), frozenset({('h', 8), ('j', 8), ('l', 8), ('i', 8), ('k', 8)})}
num_move_locations: 5

Variable Values Before Statement:
num_move_locations: 5

Value After Statement Execution: No

Variable States During Runtime (line, value):
board: 1
  abcdefghijklmno1 _______________2 _______________3 _______________4 _______________5 _______________6 _______________7 _______________8 _______BAKER___9 _______________10_______________11_______________12_______________13_______________14_______________15_______________
word_set: 1
{frozenset(), frozenset({('h', 8), ('j', 8), ('l', 8), ('i', 8), ('k', 8)})}
num_move_locations: 1
5
total_score: 2
0
15
24
word_score: 3
0
12
3
12
8
12
10
12
11
12
12
14
24
word_location_set: 5
frozenset()
5
frozenset({('h', 8), ('j', 8), ('l', 8), ('i', 8), ('k', 8)})
word_multiplier: 7
1
11
2
location: 9
('h', 8)
9
('j', 8)
9
('l', 8)
9
('i', 8)
9
('k', 8)
square: 10
B
10
K
10
R
10
A
10
E
Project Name: boto+boto3
Language: Python
Statement Type: Branch

Source Code:
def create_request_parameters(parent, request_model, params=None, index=None):
    """
    Handle request parameters that can be filled in from identifiers,
    resource data members or constants.

    By passing ``params``, you can invoke this method multiple times and
    build up a parameter dict over time, which is particularly useful
    for reverse JMESPath expressions that append to lists.

    :type parent: ServiceResource
    :param parent: The resource instance to which this action is attached.
    :type request_model: :py:class:`~boto3.resources.model.Request`
    :param request_model: The action request model.
    :type params: dict
    :param params: If set, then add to this existing dict. It is both
                   edited in-place and returned.
    :type index: int
    :param index: The position of an item within a list
    :rtype: dict
    :return: Pre-filled parameters to be sent to the request operation.
    """
    if params is None:
        params = {}

    for param in request_model.params:
        source = param.source
        target = param.target

        if source == 'identifier':
            # Resource identifier, e.g. queue.url
            value = getattr(parent, xform_name(param.name))
        elif source == 'data':
            # If this is a data member then it may incur a load
            # action before returning the value.
            value = get_data_member(parent, param.path)
        elif source in ['string', 'integer', 'boolean']:
            # These are hard-coded values in the definition
            value = param.value
        elif source == 'input':
            # This is provided by the user, so ignore it here
            continue
        else:
            raise NotImplementedError(f'Unsupported source type: {source}')

        build_param_structure(params, target, value, index)

    return params

create_request_parameters(parent=dynamodb.Table(name='MyTable'), request_model={_definition=OrderedDict([('operation', 'Scan'), ('params', [OrderedDict([('target', 'TableName'), ('source', 'identifier'), ('name', 'Name')])])]), operation='Scan'}, params=None, index=None)

Selected Statement: if params is None:

Function Input:
parent: dynamodb.Table(name='MyTable')
request_model: {_definition=OrderedDict([('operation', 'Scan'), ('params', [OrderedDict([('target', 'TableName'), ('source', 'identifier'), ('name', 'Name')])])]), operation='Scan'}
params: None
index: None

Variable Values Before Statement:
params: None

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
parent: 1
dynamodb.Table(name='MyTable')
request_model: 1
{_definition=OrderedDict([('operation', 'Scan'), ('params', [OrderedDict([('target', 'TableName'), ('source', 'identifier'), ('name', 'Name')])])]), operation='Scan'}
params: 1
None
23
45
TableName: MyTable
index: 1
None
param: 25
{target='TableName', source='identifier', name='Name', path=None, value=None}
source: 26
'identifier'
target: 27
'TableName'
value: 31
'MyTable'
Project Name: dbcli+mycli
Language: Python
Statement Type: Branch

Source Code:
def get_mylogin_cnf_path():
    """Return the path to the login path file or None if it doesn't exist."""
    mylogin_cnf_path = os.getenv('MYSQL_TEST_LOGIN_FILE')

    if mylogin_cnf_path is None:
        app_data = os.getenv('APPDATA')
        default_dir = os.path.join(app_data, 'MySQL') if app_data else '~'
        mylogin_cnf_path = os.path.join(default_dir, '.mylogin.cnf')

    mylogin_cnf_path = os.path.expanduser(mylogin_cnf_path)

    if exists(mylogin_cnf_path):
        logger.debug("Found login path file at '{0}'".format(mylogin_cnf_path))
        return mylogin_cnf_path
    return None

get_mylogin_cnf_path()

Selected Statement: if mylogin_cnf_path is None:

Function Input:

Variable Values Before Statement:
mylogin_cnf_path: None

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
mylogin_cnf_path: 3
None
8
'~/.mylogin.cnf'
10
'/home/jinjun/.mylogin.cnf'
app_data: 6
None
default_dir: 7
'~'
Project Name: ccarocean+pyrads
Language: Python
Statement Type: Branch

Source Code:
def _check(self) -> None:
        """Check the syntax of the expression.

        :raises ValueError:
            If the expression is incomplete.  This error is aimed at debugging
            the expression so it is very verbose.
        """
        stack_size = 0
        for i, token_ in enumerate(self._tokens):
            stack_size -= token_.pops
            if stack_size < 0:
                raise ValueError(
                    self._format_syntax_error(
                        f"'{token_}' takes {token_.pops} argument(s) but the stack"
                        f" will only have {stack_size + token_.pops} element(s)",
                        i,
                    )
                )
            stack_size += token_.puts
        if stack_size == 0:
            raise ValueError(
                self._format_syntax_error("expression does not produce a result")
            )
        if stack_size > 1:
            raise ValueError(
                self._format_syntax_error(
                    f"expression produces too many results ({stack_size}), "
                    "expected 1"
                )
            )

_check(self=CompleteExpression([Literal(1)]), self[0]=Literal(1))

Selected Statement: if stack_size == 0:

Function Input:
self: CompleteExpression([Literal(1)])
self[0]: Literal(1)

Variable Values Before Statement:
stack_size: 0

Value After Statement Execution: No

Variable States During Runtime (line, value):
self: 1
CompleteExpression([Literal(1)])
self[0]: 1
Literal(1)
stack_size: 8
0
19
1
i: 9
0
token_: 9
Literal(1)
Project Name: ccarocean+pyrads
Language: Python
Statement Type: Branch

Source Code:
def contains_sublist(list_: List[Any], sublist: List[Any]) -> bool:
    """Determine if a `list` contains a `sublist`.

    :param list_:
        list to search for the `sublist` in.
    :param sublist:
        Sub list to search for.

    :return:
        True if `list` contains `sublist`.

    """
    # Adapted from: https://stackoverflow.com/a/12576755
    if not sublist:
        return False
    for i in range(len(list_)):
        if list_[i] == sublist[0] and list_[i : i + len(sublist)] == sublist:
            return True
    return False

contains_sublist(list_=[1, 2, 3, 4], sublist=[1, 2])

Selected Statement: if not sublist:

Function Input:
list_: [1, 2, 3, 4]
sublist: [1, 2]

Variable Values Before Statement:
sublist: [1, 2]

Value After Statement Execution: No

Variable States During Runtime (line, value):
list_: 1
[1, 2, 3, 4]
sublist: 1
[1, 2]
i: 16
0
Project Name: ccarocean+pyrads
Language: Python
Statement Type: Branch

Source Code:
def delete_sublist(list_: List[Any], sublist: List[Any]) -> List[Any]:
    """Remove a `sublist` from the given `list_`.

    :param list_:
        List to remove the `sublist` from.
    :param sublist:
        Sublist to remove from `list_`.

    :return:
        A copy of `list_` with the `sublist` removed.
    """
    if not sublist:
        return list_[:]
    for i in range(len(list_)):
        if list_[i] == sublist[0] and list_[i : i + len(sublist)] == sublist:
            return list_[:i] + list_[i + len(sublist) :]
    return list_[:]

delete_sublist(list_=[1, 2, 3, 4], sublist=[1, 2])

Selected Statement: if not sublist:

Function Input:
list_: [1, 2, 3, 4]
sublist: [1, 2]

Variable Values Before Statement:
sublist: [1, 2]

Value After Statement Execution: No

Variable States During Runtime (line, value):
list_: 1
[1, 2, 3, 4]
sublist: 1
[1, 2]
i: 14
0
Project Name: chubin+cheat.sh
Language: Python
Statement Type: Branch

Source Code:
def _get_nested(data, key):
    """
    Return value for a hierrachical key (like a.b.c).
    Return None if nothing found.
    If there is a key with . in the name, and a subdictionary,
    the former is preferred:

    >>> print(_get_nested({'a.b': 10, 'a':{'b': 20}}, 'a.b'))
    10
    >>> print(_get_nested({'a': {'b': 20}}, 'a.b'))
    20
    >>> print(_get_nested({'a': {'b': {'c': 30}}}, 'a.b.c'))
    30
    """

    if not data or not isinstance(data, dict):
        return None
    if '.' not in key:
        return data.get(key)
    if key in data:
        return data[key]

    parts = key.split('.')
    for i in range(len(parts))[::-1]:
        prefix = ".".join(parts[:i])
        if prefix in data:
            return _get_nested(data[prefix], ".".join(parts[i:]))

    return None

_get_nested(data={'server': {'address': '0.0.0.0'}, 'cache': {'type': 'redis'}}, key='adapters.active')

Selected Statement: if '.' not in key:

Function Input:
data: {'server': {'address': '0.0.0.0'}, 'cache': {'type': 'redis'}}
key: 'adapters.active'

Variable Values Before Statement:
key: 'adapters.active'

Value After Statement Execution: No

Variable States During Runtime (line, value):
data: 1
{'server': {'address': '0.0.0.0'}, 'cache': {'type': 'redis'}}
key: 1
'adapters.active'
parts: 23
adapters, active
i: 24
1
24
0
prefix: 25
'adapters'
25
''
Project Name: Lightning-AI+lit-gpt
Language: Python
Statement Type: Branch

Source Code:
def sample(logits: torch.Tensor, temperature: float = 1.0, top_k: Optional[int] = None) -> torch.Tensor:
    logits = logits[0, -1]
    # optionally crop the logits to only the top k options
    if top_k is not None:
        v, i = torch.topk(logits, min(top_k, logits.size(-1)))
        # do not use `torch.where` as in nanogpt because it will repeat top-k collisions
        logits = torch.full_like(logits, float("-inf")).scatter_(-1, i, v)
    # optionally scale the logits and sample from a probability distribution
    if temperature > 0.0:
        probs = torch.nn.functional.softmax(logits / temperature, dim=-1)
        return multinomial_num_samples_1(probs)
    return torch.argmax(logits, dim=-1, keepdim=True)

sample(logits=tensor([[[ 0.2595,  0.0058,  0.6498, -0.5155,  0.0366, -0.2944,  0.0555,          -0.4013],         [ 0.5342, -0.9790, -0.0861,  0.2530,  0.1378, -0.4913,  0.1915,          -0.3248],         [ 0.5289, -0.3149,  0.4052,  0.2107, -0.8788, -0.9871,  0.6539,          -0.2213]]], device='cuda:0'), temperature=0.8, top_k=None)

Selected Statement: if temperature > 0.0:

Function Input:
logits: tensor([[[ 0.2595,  0.0058,  0.6498, -0.5155,  0.0366, -0.2944,  0.0555,          -0.4013],         [ 0.5342, -0.9790, -0.0861,  0.2530,  0.1378, -0.4913,  0.1915,          -0.3248],         [ 0.5289, -0.3149,  0.4052,  0.2107, -0.8788, -0.9871,  0.6539,          -0.2213]]], device='cuda:0')
temperature: 0.8
top_k: None

Variable Values Before Statement:
temperature: 0.8

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
logits: 1
tensor([[[ 0.2595,  0.0058,  0.6498, -0.5155,  0.0366, -0.2944,  0.0555,          -0.4013],         [ 0.5342, -0.9790, -0.0861,  0.2530,  0.1378, -0.4913,  0.1915,          -0.3248],         [ 0.5289, -0.3149,  0.4052,  0.2107, -0.8788, -0.9871,  0.6539,          -0.2213]]], device='cuda:0')
2
tensor([ 0.5289, -0.3149,  0.4052,  0.2107, -0.8788, -0.9871,  0.6539, -0.2213],       device='cuda:0')
temperature: 1
0.8
top_k: 1
None
probs: 10
tensor([0.2101, 0.0732, 0.1800, 0.1411, 0.0362, 0.0316, 0.2456, 0.0823],       device='cuda:0')
Project Name: Lightning-AI+lit-gpt
Language: Python
Statement Type: Branch

Source Code:
def test_generate(monkeypatch, generated, stop_tokens, expected):
    import chat.base as chat
    import generate.base as generate

    input_idx = torch.tensor([5, 3])
    max_returned_tokens = len(input_idx) + 8
    model = MagicMock()
    model.config.block_size = 100
    model.max_seq_length = 100
    it = iter(generated)

    def multinomial(*_, **__):
        out = next(it)
        return torch.tensor([out])

    monkeypatch.setattr(generate, "multinomial_num_samples_1", multinomial)
    actual = chat.generate(model, input_idx, max_returned_tokens, stop_tokens=stop_tokens)
    actual = list(actual)

    assert len(actual) == len(expected)
    if not actual:
        assert actual == expected
    else:
        for t in actual:
            assert t.dtype == torch.long
        assert torch.cat(actual).tolist() == expected

test_generate(monkeypatch={_setattr=[], _setitem=[], _cwd=None, _savesyspath=None}, generated=repeat(1), stop_tokens=(), expected=[1, 1, 1, 1, 1, 1, 1, 1])

Selected Statement: if not actual:

Function Input:
monkeypatch: {_setattr=[], _setitem=[], _cwd=None, _savesyspath=None}
generated: repeat(1)
stop_tokens: ()
expected: [1, 1, 1, 1, 1, 1, 1, 1]

Variable Values Before Statement:
actual: [tensor([1]), tensor([1]), tensor([1]), tensor([1]), tensor([1]), tensor([1]), tensor([1]), tensor([1])]

Value After Statement Execution: No

Variable States During Runtime (line, value):
monkeypatch: 1
{_setattr=[], _setitem=[], _cwd=None, _savesyspath=None}
16
{_setattr=[(<module 'generate.base' from '/local/rcs/jinjun/code/pytrace-collector/logs/self_collected/tried/Lightning-AI+lit-gpt/Lightning-AI+lit-gpt/generate/base.py'>, 'multinomial_num_samples_1', <function multinomial_num_samples_1 at 0x7f805238a160>)], _setitem=[], _cwd=None, _savesyspath=None}
generated: 1
repeat(1)
stop_tokens: 1
()
expected: 1
[1, 1, 1, 1, 1, 1, 1, 1]
chat: 2
<module 'chat.base' from '/local/rcs/jinjun/code/pytrace-collector/logs/self_collected/tried/Lightning-AI+lit-gpt/Lightning-AI+lit-gpt/chat/base.py'>
generate: 3
<module 'generate.base' from '/local/rcs/jinjun/code/pytrace-collector/logs/self_collected/tried/Lightning-AI+lit-gpt/Lightning-AI+lit-gpt/generate/base.py'>
input_idx: 5
tensor([5, 3])
max_returned_tokens: 6
10
model: 7
<MagicMock id='140188337253248'>
it: 10
repeat(1)
multinomial: 12
<function test_generate.<locals>.multinomial at 0x7f7fd0f7e430>
actual: 17
<generator object generate at 0x7f803c55ff90>
18
[tensor([1]), tensor([1]), tensor([1]), tensor([1]), tensor([1]), tensor([1]), tensor([1]), tensor([1])]
@py_assert2: 20
None
@py_assert7: 20
None
@py_assert4: 20
None
t: 24
tensor([1])
@py_assert1: 25
None
@py_assert5: 25
None
@py_assert3: 25
None
@py_assert6: 26
None
@py_assert8: 26
None
@py_assert10: 26
None
Project Name: berkeleylab+als.milo
Language: Python
Statement Type: Branch

Source Code:
def render_pep440_feature(pieces):
    """Build up version string, used within "feature" branch of repository.

    Our goal: MERGE-POINT.post.devN+gHEX.BRANCH-NAME.M[.dirty]
        +) MERGE-POINT = Most recent common ancestor for `develop` and `master`
          *) Does not yet handle branch from `release-*`
        +) N = DISTANCE from the MERGE-POINT of `develop` and `master`
        +) M = DISTANCE from the MERGE-POINT of "feature" and `develop`

    Exceptions:
    1: no tags. 0.post.devDISTANCE+gHEX[.dirty]
    """
    if pieces["closest-tag"] and pieces["develop"]:
        rendered = pieces["closest-tag"]
        distance_to_develop = pieces["distance-to-develop"]
        distance_to_merge = pieces["distance-to-master"]
        distance_merge_to_tag = (pieces["distance"] - distance_to_merge)
        distance_dev_to_merge = (distance_to_merge - distance_to_develop)
        if (distance_merge_to_tag > 0):
            rendered += ".%d" % distance_merge_to_tag
        rendered += ".post.dev%d" % distance_dev_to_merge
        rendered += plus_or_dot(pieces)
        rendered += "g%s" % pieces["short"]
        rendered += ".%s" % pieces["branch"]
        rendered += ".%d" % distance_to_develop
    else:
        # exception #1
        rendered = "0.post.dev%d" % (pieces["distance"] - 1)
        rendered += plus_or_dot(pieces)
        rendered += "g%s" % pieces["short"]
    if pieces["dirty"]:
        rendered += ".dirty"
    return rendered

render_pep440_feature(pieces={'long': 'e60d005d389cb31b6e99f937e35adbe3fccb7aaf', 'short': 'e60d005', 'error': None, 'dirty': False, 'closest-tag': '0.8', 'distance': 3, 'branch': 'HEAD', 'distance-to-master': 0, 'develop': None, 'distance-to-develop': None, 'date': '2018-05-05T22:17:58-0700', 'authors': ['Padraic Shafer']})

Selected Statement: if pieces["dirty"]:

Function Input:
pieces: {'long': 'e60d005d389cb31b6e99f937e35adbe3fccb7aaf', 'short': 'e60d005', 'error': None, 'dirty': False, 'closest-tag': '0.8', 'distance': 3, 'branch': 'HEAD', 'distance-to-master': 0, 'develop': None, 'distance-to-develop': None, 'date': '2018-05-05T22:17:58-0700', 'authors': ['Padraic Shafer']}

Variable Values Before Statement:
pieces: {'long': 'e60d005d389cb31b6e99f937e35adbe3fccb7aaf', 'short': 'e60d005', 'error': None, 'dirty': False, 'closest-tag': '0.8', 'distance': 3, 'branch': 'HEAD', 'distance-to-master': 0, 'develop': None, 'distance-to-develop': None, 'date': '2018-05-05T22:17:58-0700', 'authors': ['Padraic Shafer']}

Value After Statement Execution: No

Variable States During Runtime (line, value):
pieces: 1
{'long': 'e60d005d389cb31b6e99f937e35adbe3fccb7aaf', 'short': 'e60d005', 'error': None, 'dirty': False, 'closest-tag': '0.8', 'distance': 3, 'branch': 'HEAD', 'distance-to-master': 0, 'develop': None, 'distance-to-develop': None, 'date': '2018-05-05T22:17:58-0700', 'authors': ['Padraic Shafer']}
rendered: 28
'0.post.dev2'
29
'0.post.dev2+'
30
'0.post.dev2+ge60d005'
Project Name: ccxt+ccxt
Language: Python
Statement Type: Branch

Source Code:
def encode_number(n):
    b128_digits = []
    while n:
        b128_digits.insert(0, (n & 0x7f) | 0x80)
        n = n >> 7
    if not b128_digits:
        b128_digits.append(0)
    b128_digits[-1] &= 0x7f
    return b''.join([int.to_bytes(d, 1, 'big') for d in b128_digits])

encode_number(n=840)

Selected Statement: if not b128_digits:

Function Input:
n: 840

Variable Values Before Statement:
b128_digits: [134, 200]

Value After Statement Execution: No

Variable States During Runtime (line, value):
n: 1
840
5
6
5
0
b128_digits: 2
4
[200]
4
[134, 200]
8
[134, 72]
Project Name: ccxt+ccxt
Language: Python
Statement Type: Branch

Source Code:
def bits2octets(data, order):
    z1 = bits2int(data, bit_length(order))
    z2 = z1 - order

    if z2 < 0:
        z2 = z1

    return number_to_string_crop(z2, order)

bits2octets(data=b'\xa7?\xcf3\x96@\x92\x92\x07(\x1f\xb8\xe08\x88H\x06\xe2\xeb\x08@\xf2$V\x94\xdb\xba\x1d\\\xc8\x9ee', order=115792089237316195423570985008687907852837564279074904382605163141518161494337)

Selected Statement: if z2 < 0:

Function Input:
data: b'\xa7?\xcf3\x96@\x92\x92\x07(\x1f\xb8\xe08\x88H\x06\xe2\xeb\x08@\xf2$V\x94\xdb\xba\x1d\\\xc8\x9ee'
order: 115792089237316195423570985008687907852837564279074904382605163141518161494337

Variable Values Before Statement:
z2: -40143102106555197328287958903398272462062044396680684900905814410515880714972

Value After Statement Execution: Yes

Variable States During Runtime (line, value):
data: 1
b'\xa7?\xcf3\x96@\x92\x92\x07(\x1f\xb8\xe08\x88H\x06\xe2\xeb\x08@\xf2$V\x94\xdb\xba\x1d\\\xc8\x9ee'
order: 1
115792089237316195423570985008687907852837564279074904382605163141518161494337
z1: 2
75648987130760998095283026105289635390775519882394219481699348731002280779365
z2: 3
-40143102106555197328287958903398272462062044396680684900905814410515880714972
6
75648987130760998095283026105289635390775519882394219481699348731002280779365
Project Name: aws+aws-cli
Language: Python
Statement Type: Branch

Source Code:
def _import_plugins(plugin_names):
    plugins = []
    for name, path in plugin_names.items():
        log.debug("Importing plugin %s: %s", name, path)
        if '.' not in path:
            plugins.append(__import__(path))
        else:
            package, module = path.rsplit('.', 1)
            module = __import__(path, fromlist=[module])
            plugins.append(module)
    return plugins

_import_plugins(plugin_names={'__builtin__': 'awscli.handlers'})

Selected Statement: if '.' not in path:

Function Input:
plugin_names: __builtin__: awscli.handlers

Variable Values Before Statement:
path: 'awscli.handlers'

Value After Statement Execution: No

Variable States During Runtime (line, value):
plugin_names: 1
__builtin__: awscli.handlers
plugins: 2
10
[<module 'awscli.handlers' from '/local/rcs/jinjun/code/pytrace-collector/logs/self_collected/tried/aws+aws-cli/aws+aws-cli/awscli/handlers.py'>]
name: 3
'__builtin__'
path: 3
'awscli.handlers'
package: 8
'awscli'
module: 8
'handlers'
9
<module 'awscli.handlers' from '/local/rcs/jinjun/code/pytrace-collector/logs/self_collected/tried/aws+aws-cli/aws+aws-cli/awscli/handlers.py'>