Path 1: 291 calls (0.72)

→ node AssignName (291)

↩ return None (291)

4 run 21 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann
            

Path 2: 28 calls (0.07)

→ node AssignAttr (16) AssignName (10) Const (2)

↩ return Subscript (19) Name (6) BinOp (3)

14 run 11 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann
            

Path 3: 24 calls (0.06)

→ node AssignAttr (24)

↩ return None (24)

13 run 12 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann
            

Path 4: 20 calls (0.05)

→ node AssignAttr (20)

↩ return None (20)

⚠ exception AttributeError (20)

14 run 11 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann
            

Path 5: 16 calls (0.04)

→ node AssignAttr (16)

↩ return None (16)

⚠ exception AttributeError (16)

15 run 10 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann
            

Path 6: 12 calls (0.03)

→ node AssignAttr (12)

↩ return Name (10) Subscript (2)

18 run 7 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann
            

Path 7: 5 calls (0.01)

→ node AssignAttr (5)

↩ return Subscript (4) Name (1)

19 run 6 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann
            

Path 8: 4 calls (0.01)

→ node AssignAttr (3) Const (1)

↩ return Subscript (3) Name (1)

15 run 10 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann
            

Path 9: 3 calls (0.01)

→ node AssignName (1) AssignAttr (1) Const (1)

↩ return Name (2) BinOp (1)

14 run 11 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann
            

Path 10: 2 calls (0.0)

→ node AssignAttr (2)

↩ return Name (2)

18 run 7 not run

1def get_annotation(
2    node: nodes.AssignAttr | nodes.AssignName,
3) -> nodes.Name | nodes.Subscript | None:
4    """Return the annotation for `node`."""
5    ann = None
6    if isinstance(node.parent, nodes.AnnAssign):
7        ann = node.parent.annotation
8    elif isinstance(node, nodes.AssignAttr):
9        init_method = node.parent.parent
10        try:
11            annotations = dict(zip(init_method.locals, init_method.args.annotations))
12            ann = annotations.get(node.parent.value.name)
13        except AttributeError:
14            pass
15    else:
16        return ann
17
18    try:
19        default, *_ = node.infer()
20    except astroid.InferenceError:
21        default = ""
22
23    label = get_annotation_label(ann)
24    if ann:
25        label = (
26            rf"Optional[{label}]"
27            if getattr(default, "value", "value") is None
28            and not label.startswith("Optional")
29            else label
30        )
31    if label:
32        ann.name = label
33    return ann