mandos.search.chembl.target_traversal.StandardStrategyParser.read_lines() - Code Metrics - Inspection of "build(deps-dev): bump flake8-bugbear from 20.11.1..." - dmyersturnbull/mandos - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — dependabot/pip/flake8-bugbear-... ( 5c5892...6076c0 )

unknown

created 2021-04-04 07:45 UTC

StandardStrategyParser.read_lines() A

↳ Parent: mandos.search.chembl.target_traversal

Complexity

Conditions

Size

Total Lines	6
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	6
nop	2
dl	0
loc	6
rs	10
c	0
b	0
f	0

from __future__ import annotations

import abc
import enum
import sys

import sre_compile
import re
from pathlib import Path
from typing import Dict, Sequence, Type, Set, Optional, Mapping
from typing import Tuple as Tup

from mandos.model import MandosResources, ReflectionUtils
from mandos.model.chembl_api import ChemblApi
from mandos.model.chembl_support.chembl_targets import TargetType, ChemblTarget
from mandos.model.chembl_support.chembl_target_graphs import (
    ChemblTargetGraph,
    TargetNode,
    TargetEdgeReqs,
    TargetRelType,
)


class Acceptance(enum.Enum):

    always = enum.auto()
    never = enum.auto()
    at_start = enum.auto()
    at_end = enum.auto()


class TargetTraversalStrategy(metaclass=abc.ABCMeta):

    """"""

    @classmethod
    @property
    def api(cls) -> ChemblApi:

        raise NotImplementedError()

    def traverse(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:

        return self.__call__(target)

    def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
        """

        Returns:

        """
        raise NotImplementedError()


class NullTargetTraversalStrategy(TargetTraversalStrategy, metaclass=abc.ABCMeta):

    """"""

    @classmethod
    @property
    def api(cls) -> ChemblApi:
        raise NotImplementedError()

    def traverse(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
        return self.__call__(target)

    def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
        return [target]


class StandardTargetTraversalStrategy(TargetTraversalStrategy, metaclass=abc.ABCMeta):

    """"""

    @classmethod
    @property
    def edges(cls) -> Set[TargetEdgeReqs]:

        raise NotImplementedError()

    @classmethod
    @property
    def acceptance(cls) -> Mapping[TargetEdgeReqs, Acceptance]:

        raise NotImplementedError()

    def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTarget]:
        found = target.traverse(self.edges)
        return [f.target for f in found if self.accept(f)]

    def accept(self, target: TargetNode) -> bool:

        if target.link_reqs is None:
            # typically for root nodes -- we'll have a self-loop to check, too
            return False
        acceptance_type = self.acceptance[target.link_reqs]
        return (
            acceptance_type is Acceptance.always
            or (acceptance_type is Acceptance.at_start and target.is_start)
            or (acceptance_type is Acceptance.at_end and target.is_end)
        )


class StandardStrategyParser:

    @classmethod
    def read_lines(cls, path: Path) -> Sequence[str]:

        return [
            line
            for line in path.read_text(encoding="utf8").splitlines()
            if not line.startswith("#") and len(line.strip()) > 0
        ]

    @classmethod
    def parse(

        cls, lines: Sequence[str]

    ) -> Tup[Set[TargetEdgeReqs], Mapping[TargetEdgeReqs, Acceptance]]:
        pat_type = r"(@?[a-z_]+)"
        pat_rel = r"([<>~=.*])"
        pat_accept = r"(?:accept:([\-*^$]))?"
        pat_src_words = r"(?:src:'''(.+?)''')?"
        pat_dest_words = r"(?:dest:'''(.+?)''')?"
        comment = r"(?:#(.*))?"
        pat = f"^ *{pat_type} *{pat_rel} *{pat_type} *{pat_accept} *{pat_src_words} *{pat_dest_words} *{comment} *$"

        pat = re.compile(pat)
        to_rel = {
            ">": TargetRelType.superset_of,
            "<": TargetRelType.subset_of,
            "~": TargetRelType.overlaps_with,
            "=": TargetRelType.equivalent_to,
            "*": TargetRelType.any_link,
            ".": TargetRelType.self_link,
        }
        to_accept = {
            "*": Acceptance.always,
            "-": Acceptance.never,
            "^": Acceptance.at_start,
            "$": Acceptance.at_end,
        }
        edges = set()
        edge_to_acceptance: Dict[TargetEdgeReqs, Acceptance] = {}
        for line in lines:
            match = pat.fullmatch(line)
            if match is None:
                raise AssertionError(f"Could not parse line '{line}'")
            try:
                sources = TargetType.resolve(match.group(1))
                rel = to_rel[match.group(2)]
                dests = TargetType.resolve(match.group(3))
                accept = to_accept[match.group(4).lower()]
                src_pat = (
                    None
                    if match.group(5) is None or match.group(5) == ""
                    else re.compile(match.group(5))
                )
                dest_pat = (
                    None
                    if match.group(6) is None or match.group(6) == ""
                    else re.compile(match.group(6))
                )
            except (KeyError, TypeError, sre_compile.error):
                raise AssertionError(f"Could not parse line '{line}'")
            for source in sources:
                for dest in dests:
                    edge = TargetEdgeReqs(
                        src_type=source,
                        src_pattern=src_pat,
                        rel_type=rel,
                        dest_type=dest,
                        dest_pattern=dest_pat,
                    )
                    edges.add(edge)
                    edge_to_acceptance[edge] = accept
        return edges, edge_to_acceptance


class TargetTraversalStrategies:
    """
    Factory.
    """

    @classmethod
    def standard_strategies(cls) -> Set[str]:

        return {
            p.stem for p in MandosResources.path("strategies").iterdir() if p.suffix == ".strat"
        }

    @classmethod
    def by_name(cls, name: str, api: ChemblApi) -> TargetTraversalStrategy:

        if name == "@null":  # just slightly more efficient
            return cls.null(api)
        if MandosResources.contains("strategies", name, suffix=".strat"):

            return cls.from_resource(name, api)
        elif name.endswith(".strat"):
            return cls.from_file(Path(name), api)
        return cls.by_classname(name, api)

    @classmethod
    def by_classname(cls, fully_qualified: str, api: ChemblApi) -> TargetTraversalStrategy:

        clazz = ReflectionUtils.injection(fully_qualified, TargetTraversalStrategy)
        return cls.create(clazz, api)

    @classmethod
    def from_resource(cls, name: str, api: ChemblApi) -> TargetTraversalStrategy:

        path = MandosResources.path("strategies", name, suffix=".strat")
        lines = StandardStrategyParser.read_lines(path)
        return cls._from_lines(lines, api, path.stem)

    @classmethod
    def from_file(cls, path: Path, api: ChemblApi) -> TargetTraversalStrategy:

        lines = StandardStrategyParser.read_lines(path)
        return cls._from_lines(lines, api, path.stem)

    @classmethod
    def from_lines(

        cls, lines: Sequence[str], api: ChemblApi, name: Optional[str]

    ) -> TargetTraversalStrategy:
        return cls._from_lines(lines, api, "" if name is None else name)

    @classmethod
    def _from_lines(
        cls, lines: Sequence[str], api: ChemblApi, name: str

    ) -> TargetTraversalStrategy:
        edges, accept = StandardStrategyParser.parse(lines)

        class Strategy(StandardTargetTraversalStrategy):

            @classmethod
            @property
            def edges(cls) -> Set[TargetEdgeReqs]:
                return edges

            @classmethod
            @property
            def acceptance(cls) -> Mapping[TargetEdgeReqs, Acceptance]:
                return accept

            @classmethod
            @property
            def api(cls) -> ChemblApi:
                return api

        Strategy.__name__ = StandardTargetTraversalStrategy.__class__.__name__ + "_" + name
        return Strategy()

    @classmethod
    def null(cls, api: ChemblApi) -> TargetTraversalStrategy:

        class NullStrategy(NullTargetTraversalStrategy):

            @classmethod
            @property
            def api(cls) -> ChemblApi:
                return api

        return NullStrategy()

    # noinspection PyAbstractClass
    @classmethod
    def create(cls, clz: Type[TargetTraversalStrategy], api: ChemblApi) -> TargetTraversalStrategy:
        """
        Factory method.

        Args:
            clz:
            api:

        Returns:

        """

        class X(clz):

            @classmethod
            @property
            def api(cls) -> ChemblApi:

                return api

        X.__name__ = clz.__name__
        return X()


__all__ = ["TargetTraversalStrategy", "TargetTraversalStrategies"]


1			from __future__ import annotations
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Missing module docstring Loading history...
2			import abc
3			import enum
4			import sys
			0 ignored issues – show Unused Code introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report The import `sys` seems to be unused. Loading history...
5			import sre_compile
6			import re
7			from pathlib import Path
8			from typing import Dict, Sequence, Type, Set, Optional, Mapping
9			from typing import Tuple as Tup
10
11			from mandos.model import MandosResources, ReflectionUtils
12			from mandos.model.chembl_api import ChemblApi
13			from mandos.model.chembl_support.chembl_targets import TargetType, ChemblTarget
14			from mandos.model.chembl_support.chembl_target_graphs import (
15			ChemblTargetGraph,
16			TargetNode,
17			TargetEdgeReqs,
18			TargetRelType,
19			)
20
21
22			class Acceptance(enum.Enum):
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
23			always = enum.auto()
24			never = enum.auto()
25			at_start = enum.auto()
26			at_end = enum.auto()
27
28
29			class TargetTraversalStrategy(metaclass=abc.ABCMeta):
			0 ignored issues – show Documentation introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Empty class docstring Loading history...
30			""""""
31
32			@classmethod
33			@property
34			def api(cls) -> ChemblApi:
			0 ignored issues – show introduced 2021-03-10 02:41 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
35			raise NotImplementedError()
36
37			def traverse(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
38			return self.__call__(target)
39
40			def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
41			"""
42
43			Returns:
44
45			"""
46			raise NotImplementedError()
47
48
49			class NullTargetTraversalStrategy(TargetTraversalStrategy, metaclass=abc.ABCMeta):
			0 ignored issues – show Documentation introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Empty class docstring Loading history...
50			""""""
51
52			@classmethod
53			@property
54			def api(cls) -> ChemblApi:
55			raise NotImplementedError()
56
57			def traverse(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
58			return self.__call__(target)
59
60			def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
61			return [target]
62
63
64			class StandardTargetTraversalStrategy(TargetTraversalStrategy, metaclass=abc.ABCMeta):
			0 ignored issues – show Documentation introduced 2021-04-04 05:57 UTC by Report Bug Copy Issue Report Empty class docstring Loading history...
65			""""""
66
67			@classmethod
68			@property
69			def edges(cls) -> Set[TargetEdgeReqs]:
			0 ignored issues – show introduced 2021-03-10 02:41 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
70			raise NotImplementedError()
71
72			@classmethod
73			@property
74			def acceptance(cls) -> Mapping[TargetEdgeReqs, Acceptance]:
			0 ignored issues – show introduced 2021-03-10 02:41 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
75			raise NotImplementedError()
76
77			def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTarget]:
78			found = target.traverse(self.edges)
79			return [f.target for f in found if self.accept(f)]
80
81			def accept(self, target: TargetNode) -> bool:
			0 ignored issues – show introduced 2021-03-10 02:41 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
82			if target.link_reqs is None:
83			# typically for root nodes -- we'll have a self-loop to check, too
84			return False
85			acceptance_type = self.acceptance[target.link_reqs]
86			return (
87			acceptance_type is Acceptance.always
88			or (acceptance_type is Acceptance.at_start and target.is_start)
89			or (acceptance_type is Acceptance.at_end and target.is_end)
90			)
91
92
93			class StandardStrategyParser:
			0 ignored issues – show introduced 2021-03-13 01:12 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
94			@classmethod
95			def read_lines(cls, path: Path) -> Sequence[str]:
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
96			return [
97			line
98			for line in path.read_text(encoding="utf8").splitlines()
99			if not line.startswith("#") and len(line.strip()) > 0
100			]
101
102			@classmethod
103			def parse(
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history... Comprehensibility introduced 2021-03-13 01:12 UTC by Report Bug Copy Issue Report This function exceeds the maximum number of variables (24/15). Loading history...
104			cls, lines: Sequence[str]
			0 ignored issues – show Coding Style introduced 2021-03-15 02:29 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
105			) -> Tup[Set[TargetEdgeReqs], Mapping[TargetEdgeReqs, Acceptance]]:
106			pat_type = r"(@?[a-z_]+)"
107			pat_rel = r"([<>~=.*])"
108			pat_accept = r"(?:accept:([\-*^$]))?"
109			pat_src_words = r"(?:src:'''(.+?)''')?"
110			pat_dest_words = r"(?:dest:'''(.+?)''')?"
111			comment = r"(?:#(.*))?"
112			pat = f"^ {pat_type} {pat_rel} {pat_type} {pat_accept} {pat_src_words} {pat_dest_words} {comment} $"
			0 ignored issues – show Coding Style introduced 2021-03-13 01:12 UTC by Report Bug Copy Issue Report This line is too long as per the coding-style (116/100). This check looks for lines that are too long. You can specify the maximum line length. Loading history...
113			pat = re.compile(pat)
114			to_rel = {
115			">": TargetRelType.superset_of,
116			"<": TargetRelType.subset_of,
117			"~": TargetRelType.overlaps_with,
118			"=": TargetRelType.equivalent_to,
119			"*": TargetRelType.any_link,
120			".": TargetRelType.self_link,
121			}
122			to_accept = {
123			"*": Acceptance.always,
124			"-": Acceptance.never,
125			"^": Acceptance.at_start,
126			"$": Acceptance.at_end,
127			}
128			edges = set()
129			edge_to_acceptance: Dict[TargetEdgeReqs, Acceptance] = {}
130			for line in lines:
131			match = pat.fullmatch(line)
132			if match is None:
133			raise AssertionError(f"Could not parse line '{line}'")
134			try:
135			sources = TargetType.resolve(match.group(1))
136			rel = to_rel[match.group(2)]
137			dests = TargetType.resolve(match.group(3))
138			accept = to_accept[match.group(4).lower()]
139			src_pat = (
140			None
141			if match.group(5) is None or match.group(5) == ""
142			else re.compile(match.group(5))
143			)
144			dest_pat = (
145			None
146			if match.group(6) is None or match.group(6) == ""
147			else re.compile(match.group(6))
148			)
149			except (KeyError, TypeError, sre_compile.error):
150			raise AssertionError(f"Could not parse line '{line}'")
151			for source in sources:
152			for dest in dests:
153			edge = TargetEdgeReqs(
154			src_type=source,
155			src_pattern=src_pat,
156			rel_type=rel,
157			dest_type=dest,
158			dest_pattern=dest_pat,
159			)
160			edges.add(edge)
161			edge_to_acceptance[edge] = accept
162			return edges, edge_to_acceptance
163
164
165			class TargetTraversalStrategies:
166			"""
167			Factory.
168			"""
169
170			@classmethod
171			def standard_strategies(cls) -> Set[str]:
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
172			return {
173			p.stem for p in MandosResources.path("strategies").iterdir() if p.suffix == ".strat"
174			}
175
176			@classmethod
177			def by_name(cls, name: str, api: ChemblApi) -> TargetTraversalStrategy:
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
178			if name == "@null": # just slightly more efficient
179			return cls.null(api)
180			if MandosResources.contains("strategies", name, suffix=".strat"):
			0 ignored issues – show unused-code introduced 2021-03-16 18:40 UTC by Report Bug Copy Issue Report Unnecessary "elif" after "return" Loading history...
181			return cls.from_resource(name, api)
182			elif name.endswith(".strat"):
183			return cls.from_file(Path(name), api)
184			return cls.by_classname(name, api)
185
186			@classmethod
187			def by_classname(cls, fully_qualified: str, api: ChemblApi) -> TargetTraversalStrategy:
			0 ignored issues – show introduced 2021-03-13 01:12 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
188			clazz = ReflectionUtils.injection(fully_qualified, TargetTraversalStrategy)
189			return cls.create(clazz, api)
190
191			@classmethod
192			def from_resource(cls, name: str, api: ChemblApi) -> TargetTraversalStrategy:
			0 ignored issues – show introduced 2021-03-13 01:12 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
193			path = MandosResources.path("strategies", name, suffix=".strat")
194			lines = StandardStrategyParser.read_lines(path)
195			return cls._from_lines(lines, api, path.stem)
196
197			@classmethod
198			def from_file(cls, path: Path, api: ChemblApi) -> TargetTraversalStrategy:
			0 ignored issues – show introduced 2021-03-15 02:29 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
199			lines = StandardStrategyParser.read_lines(path)
200			return cls._from_lines(lines, api, path.stem)
201
202			@classmethod
203			def from_lines(
			0 ignored issues – show introduced 2021-03-16 18:40 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
204			cls, lines: Sequence[str], api: ChemblApi, name: Optional[str]
			0 ignored issues – show Coding Style introduced 2021-03-15 02:29 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
205			) -> TargetTraversalStrategy:
206			return cls._from_lines(lines, api, "" if name is None else name)
207
208			@classmethod
209			def _from_lines(
210			cls, lines: Sequence[str], api: ChemblApi, name: str
			0 ignored issues – show Coding Style introduced 2021-03-15 02:29 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
211			) -> TargetTraversalStrategy:
212			edges, accept = StandardStrategyParser.parse(lines)
213
214			class Strategy(StandardTargetTraversalStrategy):
			0 ignored issues – show introduced 2021-03-15 02:29 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
215			@classmethod
216			@property
217			def edges(cls) -> Set[TargetEdgeReqs]:
218			return edges
219
220			@classmethod
221			@property
222			def acceptance(cls) -> Mapping[TargetEdgeReqs, Acceptance]:
223			return accept
224
225			@classmethod
226			@property
227			def api(cls) -> ChemblApi:
228			return api
229
230			Strategy.__name__ = StandardTargetTraversalStrategy.__class__.__name__ + "_" + name
231			return Strategy()
232
233			@classmethod
234			def null(cls, api: ChemblApi) -> TargetTraversalStrategy:
			0 ignored issues – show introduced 2021-03-16 18:40 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
235			class NullStrategy(NullTargetTraversalStrategy):
			0 ignored issues – show introduced 2021-03-15 02:29 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
236			@classmethod
237			@property
238			def api(cls) -> ChemblApi:
239			return api
240
241			return NullStrategy()
242
243			# noinspection PyAbstractClass
244			@classmethod
245			def create(cls, clz: Type[TargetTraversalStrategy], api: ChemblApi) -> TargetTraversalStrategy:
246			"""
247			Factory method.
248
249			Args:
250			clz:
251			api:
252
253			Returns:
254
255			"""
256
257			class X(clz):
			0 ignored issues – show Coding Style Naming introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Class name "X" doesn't conform to PascalCase naming style ('[^\\W\\da-z][^\\W_]+$' pattern) This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... introduced 2021-04-04 05:57 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
258			@classmethod
259			@property
260			def api(cls) -> ChemblApi:
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
261			return api
262
263			X.__name__ = clz.__name__
264			return X()
265
266
267			__all__ = ["TargetTraversalStrategy", "TargetTraversalStrategies"]
268

dmyersturnbull / mandos

Push — dependabot/pip/flake8-bugbear-... ( 5c5892...6076c0 )

StandardStrategyParser.read_lines() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like