10706603467

Committed 04 Sep 2024 05:28PM UTC coverage: 89.428% (+0.02%) from 89.406%

Build # 10706603467

Build Type

Pull #403

github

Committed by

web-flow

Commit Message

Merge bdf142f4b into 6f99124f9

Pull Request Pull Request #403: Fractions functionality issue #395

Run Details

1611 of 1920 branches covered (83.91%)

Branch coverage included in aggregate %.

105 of 110 new or added lines in 6 files covered. (95.45%)

21 existing lines in 2 files now uncovered.

4006 of 4361 relevant lines covered (91.86%)

3.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.5

/opshin/rewrite/rewrite_import_typing.py

from ast import *
from typing import Optional

from ..util import CompilingNodeTransformer

"""
Checks that there was an import of dataclass if there are any class definitions
"""


class RewriteImportTyping(CompilingNodeTransformer):
    step = "Checking import and usage of typing"

    imports_typing = False

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.imports_Self = False

    def visit_ImportFrom(self, node: ImportFrom) -> Optional[ImportFrom]:
        if node.module != "typing":
            return node
        if len(node.names) == 1 and node.names[0].name == "Self":
            self.imports_Self = True
            return None
        assert (
            len(node.names) == 3
        ), "The program must contain one 'from typing import Dict, List, Union'"
        for i, n in enumerate(["Dict", "List", "Union"]):
            assert (
                node.names[i].name == n
            ), "The program must contain one 'from typing import Dict, List, Union'"
            assert (
                node.names[i].asname == None
            ), "The program must contain one 'from typing import Dict, List, Union'"
        self.imports_typing = True
        return None

    def visit_ClassDef(self, node: ClassDef) -> ClassDef:
        assert (
            self.imports_typing
        ), "typing must be imported in order to use datum classes"
        if self.imports_Self:
            for i, attribute in enumerate(node.body):
                if isinstance(attribute, FunctionDef):
                    for j, arg in enumerate(attribute.args.args):
                        if (
                            isinstance(arg.annotation, Name)
                            and arg.annotation.id == "Self"
                        ):
                            node.body[i].args.args[j].annotation.idSelf = node.name
                        if (
                            isinstance(arg.annotation, Subscript)
                            and arg.annotation.value.id == "Union"
                        ):
                            for k, s in enumerate(arg.annotation.slice.elts):
                                if isinstance(s, Name) and s.id == "Self":
                                    node.body[i].args.args[j].annotation.slice.elts[
                                        k
                                    ].idSelf = node.name

                    if (
                        isinstance(attribute.returns, Name)
                        and attribute.returns.id == "Self"
                    ):
                        node.body[i].returns.idSelf = node.name

        return node

1	from ast import *	4✔
2	from typing import Optional	4✔
3
4	from ..util import CompilingNodeTransformer	4✔
5
6	"""	2✔
7	Checks that there was an import of dataclass if there are any class definitions
8	"""
9
10
11	class RewriteImportTyping(CompilingNodeTransformer):	4✔
12	step = "Checking import and usage of typing"	4✔
13
14	imports_typing = False	4✔
15
16	def __init__(self, args, *kwargs):	4✔
17	super().__init__(args, *kwargs)	4✔
18	self.imports_Self = False	4✔
19
20	def visit_ImportFrom(self, node: ImportFrom) -> Optional[ImportFrom]:	4✔
21	if node.module != "typing":	4✔
22	return node	4✔
23	if len(node.names) == 1 and node.names[0].name == "Self":	4✔
24	self.imports_Self = True	4✔
25	return None	4✔
26	assert (	4✔
27	len(node.names) == 3
28	), "The program must contain one 'from typing import Dict, List, Union'"
29	for i, n in enumerate(["Dict", "List", "Union"]):	4✔
30	assert (	4✔
31	node.names[i].name == n
32	), "The program must contain one 'from typing import Dict, List, Union'"
33	assert (	4✔
34	node.names[i].asname == None
35	), "The program must contain one 'from typing import Dict, List, Union'"
36	self.imports_typing = True	4✔
37	return None	4✔
38
39	def visit_ClassDef(self, node: ClassDef) -> ClassDef:	4✔
40	assert (	4✔
41	self.imports_typing
42	), "typing must be imported in order to use datum classes"
43	if self.imports_Self:	4✔
44	for i, attribute in enumerate(node.body):	4✔
45	if isinstance(attribute, FunctionDef):	4✔
46	for j, arg in enumerate(attribute.args.args):	4✔
47	if (	4✔
48	isinstance(arg.annotation, Name)
49	and arg.annotation.id == "Self"
50	):
51	node.body[i].args.args[j].annotation.idSelf = node.name	4✔
52	if (	4!
53	isinstance(arg.annotation, Subscript)
54	and arg.annotation.value.id == "Union"
55	):
NEW 56	for k, s in enumerate(arg.annotation.slice.elts):	×
NEW 57	if isinstance(s, Name) and s.id == "Self":	×
NEW 58	node.body[i].args.args[j].annotation.slice.elts[	×
59	k
60	].idSelf = node.name
61
62	if (	4✔
63	isinstance(attribute.returns, Name)
64	and attribute.returns.id == "Self"
65	):
66	node.body[i].returns.idSelf = node.name	4✔
67
68	return node	4✔

OpShin / opshin / 10706603467

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous