Class LSystemGrammar

generative/lsystem/grammar.py:47–183

A context-sensitive and stochastic Lindenmayer System grammar parser. Parses strings of tokens using a set of production rules. Unlike traditional parsing, the rules are applied on the _entire_ string of tokens from left to right _before_ returning to the first symbol in the string.

class LSystemGrammar:
    """A context-sensitive and stochastic Lindenmayer System grammar parser.

    Parses strings of tokens using a set of production rules.
    Unlike traditional parsing, the rules are applied on the _entire_ string of tokens from left to
    right _before_ returning to the first symbol in the string.

    Example:
        Given the rules 'a -> ab', 'b -> a', and the starting axiom 'a',

        1st iteration: a -> ab
        2nd iteration: ab -> aba (apply 'a -> ab' on the first token, then 'b -> a' on the second).
        3rd iteration: aba -> abaab

    The rules may be context-sensitive, and may have at most one token of context to the left,
    right, or both directions.
    Some tokens may optionally be ignored when considering context.

    The rules may be stochastic, with more than one possible replacement for a given token.
    The probabilities for each token can be specified.
    If multiple replacements for the same token are parsed, but probabilities are not given, we
    assume uniform probability.

    The left and right contexts are single tokens.
    The probability may be None, or a float in (0, 1].

    There may be multiple rules for the same token.
    If, after considering context, there are multiple matching rules,
    one will be picked randomly with the probability distribution specified in the rule definitions.
    """

    def __init__(
        self,
        rules: MultiDict[TokenName, RuleMapping],
        ignore: Set[TokenName] = None,
        seed: int = None,
    ):
        """Initialize a Lindenmayer-System grammar parser with the given rules.

        :param rules: A set of production rules. A mapping of token -> replacements.
        """
        self.ignore: Set[TokenName] = ignore if ignore is not None else set()
        self.rules: MultiDict[TokenName, RuleMapping] = rules

        self.seed = seed if seed is not None else random.randint(0, 2**32 - 1)
        np.random.seed(self.seed)
        logger.info(f"Using random seed: {self.seed}")

    def pick_rule(self, rules: List[RuleMapping], token, left_ctx, right_ctx) -> RuleMapping:
        """Pick the right rule based off the probability values or the parametric condition."""
        # If there's not choice, no need to make it a random choice.
        if len(rules) == 1:
            return rules[0]

        for rule in rules:
            if rule.probability is None:
                return rule