Source code for molfoundry.derivation

from typing import List, Optional

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

_class_ref_Derivation = TSObject.get_class_ref("Derivation")
_class_ref_Derivations = TSObject.get_class_ref("Derivations")




class Derivation(TSObject):
    def __init__(self) -> None:
        super().__init__(_class_ref_Derivation)

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

    @left.setter
    def left(self, left: List[Graph]):
        self._ref.setLeft([g._ref for g in left])

    @property
    def rule(self) -> "rule.Rule":
        return rule.Rule.wrap(self._ref.getRule())

    @rule.setter
    def rule(self, rule: "rule.Rule"):
        self._ref.setRule(rule._ref)

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

    @right.setter
    def right(self, right: List[Graph]):
        self._ref.setRight([g._ref for g in right])





class Derivations(TSObject):
    def __init__(self, derivation: Optional[Derivation] = None) -> None:
        super().__init__(_class_ref_Derivations, derivation._ref if derivation is not None else None)

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

    @left.setter
    def left(self, left: List[Graph]):
        self._ref.setLeft([g._ref for g in left])

    @property
    def rules(self) -> List["rule.Rule"]:
        return [rule.Rule.wrap(r) for r in self._ref.getRules()]

    @rules.setter
    def rules(self, rules: List["rule.Rule"]):
        self._ref.setRules([r._ref for r in rules])

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

    @right.setter
    def right(self, right: List[Graph]):
        self._ref.setRight([g._ref for g in right])