Source code for molfoundry.dgstrat

from typing import List, Callable, Any

from .derivation import Derivation
from .graph import Graph
import molfoundry.rule as rule
from .core import TSObject

_class_ref_DGStrat = TSObject.get_class_ref("DGStrat")
_class_ref_GraphState = TSObject.get_class_ref("GraphState")


# noinspection PyPep8Naming

[docs]
class DGStrat(TSObject):
    # Injectable dgStrat util
    _dg_strat: Callable[[Any], "DGStrat"]

    def __init__(self) -> None:
        super().__init__(_class_ref_DGStrat)


[docs]
    @staticmethod
    def makeAddStatic(onlyUniverse: bool, graphs: List[Graph]) -> "DGStrat":
        return DGStrat.wrap(
            TSObject.call_static(_class_ref_DGStrat, "makeAddStatic", onlyUniverse, [g._ref for g in graphs]))



[docs]
    @staticmethod
    def makeAddDynamic(onlyUniverse: bool, graphsFunc: Callable[[], List[Graph]]) -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeAddDynamic", onlyUniverse,
                                                 lambda: [g._ref for g in graphsFunc()]))



[docs]
    @staticmethod
    def makeSequence(strats: List["DGStrat"]) -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeSequence", [s._ref for s in strats]))



[docs]
    @staticmethod
    def makeParallel(strats: List["DGStrat"]) -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeParallel", [s._ref for s in strats]))



[docs]
    @staticmethod
    def makeFilter(alsoUniverse: bool, p: Callable[[Graph, "GraphState", bool], bool]) -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeFilter", alsoUniverse,
                                                 lambda g, s, f: p(Graph.wrap(g), GraphState.wrap(s), f)))



[docs]
    @staticmethod
    def makeExecute(func: Callable[["GraphState"], None]) -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeExecute", lambda s: func(GraphState.wrap(s))))



[docs]
    @staticmethod
    def makeRule(r: "rule.Rule") -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeRule", r._ref))



[docs]
    @staticmethod
    def makeLeftPredicate(p: Callable[[Derivation], bool], strat: "DGStrat") -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeLeftPredicate",
                                                 lambda d: p(Derivation.wrap(d)), strat._ref))



[docs]
    @staticmethod
    def makeRightPredicate(p: Callable[[Derivation], bool], strat: "DGStrat") -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeRightPredicate",
                                                 lambda d: p(Derivation.wrap(d)), strat._ref))



[docs]
    @staticmethod
    def makeRevive(strat: "DGStrat") -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeRevive", strat._ref))



[docs]
    @staticmethod
    def makeRepeat(limit: int, strat: "DGStrat") -> "DGStrat":
        return DGStrat.wrap(TSObject.call_static(_class_ref_DGStrat, "makeRepeat", limit, strat._ref))


    def __rshift__(self, other) -> "DGStrat":
        return DGStrat.makeSequence([DGStrat._dg_strat(self), DGStrat._dg_strat(other)])

    def __rrshift__(self, other) -> "DGStrat":
        return DGStrat.makeSequence([DGStrat._dg_strat(other), DGStrat._dg_strat(self)])




[docs]
class GraphState(TSObject):
    def __init__(self) -> None:
        super().__init__(_class_ref_GraphState)

    @property
    def universe(self) -> List[Graph]:
        return [Graph.wrap(g) for g in self._ref.getUniverse()]

    @property
    def subset(self) -> List[Graph]:
        return [Graph.wrap(g) for g in self._ref.getSubset()]