mandos.model.apis.chembl_support.target_traversal.StandardTargetTraversalStrategy.acceptance() - Code Metrics - Inspection of "build(deps): bump selenium from 3.141.0 to 4.0.0" - dmyersturnbull/mandos - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — dependabot/pip/selenium-4.0.0 ( 3d45c5...314fb9 )

unknown

created 2021-11-05 00:30 UTC

StandardTargetTraversalStrategy.acceptance() A

↳ Parent: mandos.model.apis.chembl_support.target_traversal

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

from __future__ import annotations


import abc
import enum
import sre_compile
from pathlib import Path
from typing import Dict, Mapping, MutableMapping, Optional, Sequence, Set

from typing import Tuple as Tup
from typing import Type

import decorateme

import regex

from pocketutils.core.enums import CleverEnum

from pocketutils.core.exceptions import ParsingError

from pocketutils.tools.reflection_tools import ReflectionTools


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


class Acceptance(CleverEnum):

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


class TargetTraversalStrategy(metaclass=abc.ABCMeta):

    """ """

    @classmethod
    def api(cls) -> ChemblApi:

        raise NotImplementedError()

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

        return self.__call__(target)

    def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
        """
        Run the strategy.
        """
        raise NotImplementedError()

    def __repr__(self) -> str:
        return self.__class__.__name__ + "(" + str(self.api()) + ")"

    def __str__(self) -> str:
        return repr(self)


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

    """ """

    @classmethod
    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
    def edges(cls) -> Set[TargetEdgeReqs]:

        raise NotImplementedError()

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

        raise NotImplementedError()

    def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTarget]:
        logger.debug(f"Starting {self} on {target.target}")
        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
            logger.trace(f"Rejected probable root: {target}")
            return False
        acceptance_type = self.acceptance()[target.link_reqs]
        b = (

            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)
        )
        x = "accepted" if b else "rejected"

        logger.trace(f"{x.capitalize()}: {target}")
        return b


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 = regex.compile(pat, flags=regex.V1)
        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: MutableMapping[TargetEdgeReqs, Acceptance] = {}
        for line in lines:
            match = pat.fullmatch(line)
            if match is None:
                raise ParsingError(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 regex.compile(match.group(5), flags=regex.V1)
                )
                dest_pat = (
                    None
                    if match.group(6) is None or match.group(6) == ""
                    else regex.compile(match.group(6), flags=regex.V1)
                )
            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.dir("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 = ReflectionTools.injection(fully_qualified, TargetTraversalStrategy)
        logger.info(f"Loaded strategy {clazz} by injection: {fully_qualified}")
        return cls.create(clazz, api)

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

        path = MandosResources.file("strategies", name, suffix=".strat")
        return cls.from_file(path, api)

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

        lines = StandardStrategyParser.read_lines(path)
        logger.debug(f"Loaded strategy from {path} with {len(lines)} lines")
        return cls._from_lines(lines, api, name="TraversalStrategy" + path.stem.capitalize())

    @classmethod
    def from_lines(

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

    ) -> TargetTraversalStrategy:
        return cls._from_lines(lines, api, name=name)

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

    ) -> TargetTraversalStrategy:
        edges, accept = StandardStrategyParser.parse(lines)
        logger.info(f"Loaded strategy {name} with {len(edges)} edge types")
        for edge in edges:
            logger.trace(f"Edge: {edge} ({accept[edge]})")

        class Strategy(StandardTargetTraversalStrategy):

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

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

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

        Strategy.__name__ = name
        return Strategy()

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

        class NullStrategy(NullTargetTraversalStrategy):

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

        NullStrategy.__name__ = "NullStrategy"
        return NullStrategy()

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

        @decorateme.auto_utils()

        class X(clz):
            @classmethod
            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
3			import abc
4			import enum
5			import sre_compile
6			from pathlib import Path
7			from typing import Dict, Mapping, MutableMapping, Optional, Sequence, Set
			0 ignored issues – show Unused Code introduced 2021-09-06 00:54 UTC by Report Bug Copy Issue Report Unused Dict imported from typing Loading history... Unused Code introduced 2021-10-28 02:14 UTC by Report Bug Copy Issue Report Unused Optional imported from typing Loading history...
8			from typing import Tuple as Tup
9			from typing import Type
10
11			import decorateme
			0 ignored issues – show introduced 2021-10-28 02:14 UTC by Report Bug Copy Issue Report Unable to import 'decorateme' Loading history...
12			import regex
			0 ignored issues – show introduced 2021-08-07 00:15 UTC by Report Bug Copy Issue Report Unable to import 'regex' Loading history...
13			from pocketutils.core.enums import CleverEnum
			0 ignored issues – show introduced 2021-11-01 19:34 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.core.enums' Loading history...
14			from pocketutils.core.exceptions import ParsingError
			0 ignored issues – show introduced 2021-09-23 03:01 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.core.exceptions' Loading history...
15			from pocketutils.tools.reflection_tools import ReflectionTools
			0 ignored issues – show introduced 2021-10-12 03:37 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.tools.reflection_tools' Loading history...
16
17			from mandos.model.apis.chembl_api import ChemblApi
18			from mandos.model.apis.chembl_support.chembl_target_graphs import (
19			ChemblTargetGraph,
20			TargetEdgeReqs,
21			TargetNode,
22			TargetRelType,
23			)
24			from mandos.model.apis.chembl_support.chembl_targets import ChemblTarget, TargetType
25			from mandos.model.utils.setup import MandosResources, logger
26
27
28			class Acceptance(CleverEnum):
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
29			always = enum.auto()
30			never = enum.auto()
31			at_start = enum.auto()
32			at_end = enum.auto()
33
34
35			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...
36			""" """
37
38			@classmethod
39			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...
40			raise NotImplementedError()
41
42			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...
43			return self.__call__(target)
44
45			def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
46			"""
47			Run the strategy.
48			"""
49			raise NotImplementedError()
50
51			def __repr__(self) -> str:
52			return self.__class__.__name__ + "(" + str(self.api()) + ")"
53
54			def __str__(self) -> str:
55			return repr(self)
56
57
58			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...
59			""" """
60
61			@classmethod
62			def api(cls) -> ChemblApi:
63			raise NotImplementedError()
64
65			def traverse(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
66			return self.__call__(target)
67
68			def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTargetGraph]:
69			return [target]
70
71
72			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...
73			""" """
74
75			@classmethod
76			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...
77			raise NotImplementedError()
78
79			@classmethod
80			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...
81			raise NotImplementedError()
82
83			def __call__(self, target: ChemblTargetGraph) -> Sequence[ChemblTarget]:
84			logger.debug(f"Starting {self} on {target.target}")
85			found = target.traverse(self.edges())
86			return [f.target for f in found if self.accept(f)]
87
88			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...
89			if target.link_reqs is None:
90			# typically for root nodes -- we'll have a self-loop to check, too
91			logger.trace(f"Rejected probable root: {target}")
92			return False
93			acceptance_type = self.acceptance()[target.link_reqs]
94			b = (
			0 ignored issues – show Coding Style Naming introduced 2021-11-02 03:04 UTC by Report Bug Copy Issue Report Variable name "b" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,\|_[^\\WA-Z]*\|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' 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...
95			acceptance_type is Acceptance.always
96			or (acceptance_type is Acceptance.at_start and target.is_start)
97			or (acceptance_type is Acceptance.at_end and target.is_end)
98			)
99			x = "accepted" if b else "rejected"
			0 ignored issues – show Coding Style Naming introduced 2021-11-02 03:04 UTC by Report Bug Copy Issue Report Variable name "x" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,\|_[^\\WA-Z]*\|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' 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...
100			logger.trace(f"{x.capitalize()}: {target}")
101			return b
102
103
104			class StandardStrategyParser:
			0 ignored issues – show introduced 2021-03-13 01:12 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
105			@classmethod
106			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...
107			return [
108			line
109			for line in path.read_text(encoding="utf8").splitlines()
110			if not line.startswith("#") and len(line.strip()) > 0
111			]
112
113			@classmethod
114			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...
115			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...
116			) -> Tup[Set[TargetEdgeReqs], Mapping[TargetEdgeReqs, Acceptance]]:
117			pat_type = r"(@?[a-z_]+)"
118			pat_rel = r"([<>~=.*])"
119			pat_accept = r"(?:accept:([\-*^$]))?"
120			pat_src_words = r"(?:src:'''(.+?)''')?"
121			pat_dest_words = r"(?:dest:'''(.+?)''')?"
122			comment = r"(?:#(.*))?"
123			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...
124			pat = regex.compile(pat, flags=regex.V1)
125			to_rel = {
126			">": TargetRelType.superset_of,
127			"<": TargetRelType.subset_of,
128			"~": TargetRelType.overlaps_with,
129			"=": TargetRelType.equivalent_to,
130			"*": TargetRelType.any_link,
131			".": TargetRelType.self_link,
132			}
133			to_accept = {
134			"*": Acceptance.always,
135			"-": Acceptance.never,
136			"^": Acceptance.at_start,
137			"$": Acceptance.at_end,
138			}
139			edges = set()
140			edge_to_acceptance: MutableMapping[TargetEdgeReqs, Acceptance] = {}
141			for line in lines:
142			match = pat.fullmatch(line)
143			if match is None:
144			raise ParsingError(f"Could not parse line '{line}'")
145			try:
146			sources = TargetType.resolve(match.group(1))
147			rel = to_rel[match.group(2)]
148			dests = TargetType.resolve(match.group(3))
149			accept = to_accept[match.group(4).lower()]
150			src_pat = (
151			None
152			if match.group(5) is None or match.group(5) == ""
153			else regex.compile(match.group(5), flags=regex.V1)
154			)
155			dest_pat = (
156			None
157			if match.group(6) is None or match.group(6) == ""
158			else regex.compile(match.group(6), flags=regex.V1)
159			)
160			except (KeyError, TypeError, sre_compile.error):
161			raise AssertionError(f"Could not parse line '{line}'")
162			for source in sources:
163			for dest in dests:
164			edge = TargetEdgeReqs(
165			src_type=source,
166			src_pattern=src_pat,
167			rel_type=rel,
168			dest_type=dest,
169			dest_pattern=dest_pat,
170			)
171			edges.add(edge)
172			edge_to_acceptance[edge] = accept
173			return edges, edge_to_acceptance
174
175
176			class TargetTraversalStrategies:
177			"""
178			Factory.
179			"""
180
181			@classmethod
182			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...
183			return {p.stem for p in MandosResources.dir("strategies").iterdir() if p.suffix == ".strat"}
184
185			@classmethod
186			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...
187			if name == "@null": # just slightly more efficient
188			return cls.null(api)
189			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...
190			return cls.from_resource(name, api)
191			elif name.endswith(".strat"):
192			return cls.from_file(Path(name), api)
193			return cls.by_classname(name, api)
194
195			@classmethod
196			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...
197			clazz = ReflectionTools.injection(fully_qualified, TargetTraversalStrategy)
198			logger.info(f"Loaded strategy {clazz} by injection: {fully_qualified}")
199			return cls.create(clazz, api)
200
201			@classmethod
202			def from_resource(cls, name: str, 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...
203			path = MandosResources.file("strategies", name, suffix=".strat")
204			return cls.from_file(path, api)
205
206			@classmethod
207			def from_file(cls, path: Path, 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...
208			lines = StandardStrategyParser.read_lines(path)
209			logger.debug(f"Loaded strategy from {path} with {len(lines)} lines")
210			return cls._from_lines(lines, api, name="TraversalStrategy" + path.stem.capitalize())
211
212			@classmethod
213			def from_lines(
			0 ignored issues – show introduced 2021-03-15 02:29 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
214			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...
215			) -> TargetTraversalStrategy:
216			return cls._from_lines(lines, api, name=name)
217
218			@classmethod
219			def _from_lines(
220			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...
221			) -> TargetTraversalStrategy:
222			edges, accept = StandardStrategyParser.parse(lines)
223			logger.info(f"Loaded strategy {name} with {len(edges)} edge types")
224			for edge in edges:
225			logger.trace(f"Edge: {edge} ({accept[edge]})")
226
227			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...
228			@classmethod
229			def edges(cls) -> Set[TargetEdgeReqs]:
230			return edges
231
232			@classmethod
233			def acceptance(cls) -> Mapping[TargetEdgeReqs, Acceptance]:
234			return accept
235
236			@classmethod
237			def api(cls) -> ChemblApi:
238			return api
239
240			Strategy.__name__ = name
241			return Strategy()
242
243			@classmethod
244			def null(cls, api: ChemblApi) -> TargetTraversalStrategy:
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
245			class NullStrategy(NullTargetTraversalStrategy):
			0 ignored issues – show introduced 2021-04-04 05:57 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
246			@classmethod
247			def api(cls) -> ChemblApi:
248			return api
249
250			NullStrategy.__name__ = "NullStrategy"
251			return NullStrategy()
252
253			# noinspection PyAbstractClass
254			@classmethod
255			def create(cls, clz: Type[TargetTraversalStrategy], 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...
256			@decorateme.auto_utils()
			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-03-15 02:29 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
257			class X(clz):
258			@classmethod
259			def api(cls) -> ChemblApi:
			0 ignored issues – show introduced 2021-10-28 02:14 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
260			return api
261
262			X.__name__ = clz.__name__
263			return X()
264
265
266			__all__ = ["TargetTraversalStrategy", "TargetTraversalStrategies"]
267

dmyersturnbull / mandos

Push — dependabot/pip/selenium-4.0.0 ( 3d45c5...314fb9 )

StandardTargetTraversalStrategy.acceptance() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like