Refact: move random function away from core
This commit is contained in:
@@ -66,7 +66,6 @@ from .tree import Tree, AssocialTree
|
||||
from .compute import compute
|
||||
from .typing import typing, TypingError
|
||||
from .renders import tree2txt, tree2tex
|
||||
from .random import list_generator as random_list
|
||||
|
||||
|
||||
# -----------------------------
|
||||
|
||||
@@ -1,288 +0,0 @@
|
||||
#! /usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
# vim:fenc=utf-8
|
||||
#
|
||||
# Copyright © 2017 lafrite <lafrite@Poivre>
|
||||
#
|
||||
# Distributed under terms of the MIT license.
|
||||
|
||||
"""
|
||||
Tools to extract random leafs, random variables, generate random values and
|
||||
fill new trees
|
||||
|
||||
Flow
|
||||
----
|
||||
|
||||
Tree with RdLeaf
|
||||
|
|
||||
| Extract rdLeaf
|
||||
|
|
||||
List of leafs to generate
|
||||
|
|
||||
| extract_rv
|
||||
|
|
||||
List random variables to generate
|
||||
|
|
||||
| Generate
|
||||
|
|
||||
Dictionnary of generated random variables
|
||||
|
|
||||
| Compute leafs
|
||||
|
|
||||
Dictionnary of computed leafs
|
||||
|
|
||||
| Replace
|
||||
|
|
||||
Tree with RdLeaf replaced by generated values
|
||||
|
||||
:example:
|
||||
|
||||
>>> from ..tree import Tree
|
||||
>>> rd_t = Tree("/", RdLeaf("a"), RdLeaf("a*k"))
|
||||
>>> print(rd_t)
|
||||
/
|
||||
> {a}
|
||||
> {a*k}
|
||||
>>> leafs = extract_rdleaf(rd_t)
|
||||
>>> leafs
|
||||
['a', 'a*k']
|
||||
>>> rd_varia = extract_rv(leafs)
|
||||
>>> sorted(list(rd_varia))
|
||||
['a', 'k']
|
||||
>>> generated = random_generator(rd_varia, conditions=['a%2+1'])
|
||||
>>> generated # doctest: +SKIP
|
||||
{'a': 7, 'k': 4}
|
||||
>>> computed = compute_leafs(leafs, generated)
|
||||
>>> computed # doctest: +SKIP
|
||||
{'a': 7, 'a*k': 28}
|
||||
>>> replaced = replace_rdleaf(rd_t, computed)
|
||||
>>> print(replaced) # doctest: +SKIP
|
||||
/
|
||||
> 7
|
||||
> 28
|
||||
|
||||
List generator
|
||||
--------------
|
||||
|
||||
This function ignores tree structure and works with lists
|
||||
|
||||
>>> values = list_generator(["a", "a*b", "b", "c"], conditions=["b%c==1"])
|
||||
>>> values # doctest: +SKIP
|
||||
{'a': -8, 'a*b': -40, 'b': 5, 'c': 4}
|
||||
"""
|
||||
|
||||
__all__ = ["list_generator"]
|
||||
|
||||
from random import choice
|
||||
from functools import reduce
|
||||
from .leaf import RdLeaf
|
||||
|
||||
|
||||
def extract_rdleaf(tree):
|
||||
""" Extract rdLeaf in a Tree
|
||||
|
||||
:example:
|
||||
>>> from ..tree import Tree
|
||||
>>> rd_t = Tree("+", RdLeaf("a"), RdLeaf("a*k"))
|
||||
>>> extract_rdleaf(rd_t)
|
||||
['a', 'a*k']
|
||||
>>> rd_t = Tree("+", RdLeaf("a"), 2)
|
||||
>>> extract_rdleaf(rd_t)
|
||||
['a']
|
||||
"""
|
||||
rd_leafs = []
|
||||
for leaf in tree.get_leafs():
|
||||
try:
|
||||
leaf.rdleaf
|
||||
except AttributeError:
|
||||
pass
|
||||
else:
|
||||
rd_leafs.append(leaf.name)
|
||||
return rd_leafs
|
||||
|
||||
|
||||
def extract_rv(leafs):
|
||||
""" Extract the set of random values from the leaf list
|
||||
|
||||
:param leafs: list of leafs
|
||||
:return: set of random values
|
||||
|
||||
:example:
|
||||
>>> leafs = ["a", "a*k"]
|
||||
>>> extract_rv(leafs) == {'a', 'k'}
|
||||
True
|
||||
"""
|
||||
rd_values = set()
|
||||
for leaf in leafs:
|
||||
for c in leaf:
|
||||
if c.isalpha():
|
||||
rd_values.add(c)
|
||||
return rd_values
|
||||
|
||||
|
||||
def compute_leafs(leafs, generated_values):
|
||||
""" Compute leafs from generated random values
|
||||
|
||||
:param generated_values: Dictionnary of name:generated value
|
||||
:param leafs: list of leafs
|
||||
:return: Dictionnary of evaluated leafs from generated values
|
||||
|
||||
:example:
|
||||
>>> leafs = ["a", "a*k"]
|
||||
>>> generated_values = {"a":2, "k":3}
|
||||
>>> compute_leafs(leafs, generated_values)
|
||||
{'a': 2, 'a*k': 6}
|
||||
"""
|
||||
return {leaf: eval(leaf, generated_values) for leaf in leafs}
|
||||
|
||||
|
||||
def replace_rdleaf(tree, computed_leafs):
|
||||
""" Replace RdLeaf by the corresponding computed value
|
||||
|
||||
>>> from ..tree import Tree
|
||||
>>> rd_t = Tree("+", RdLeaf("a"), RdLeaf("a*k"))
|
||||
>>> computed_leafs = {'a': 2, 'a*k': 6}
|
||||
>>> print(replace_rdleaf(rd_t, computed_leafs))
|
||||
+
|
||||
> 2
|
||||
> 6
|
||||
"""
|
||||
|
||||
def replace(leaf):
|
||||
try:
|
||||
return leaf.replace(computed_leafs)
|
||||
except AttributeError:
|
||||
return leaf
|
||||
|
||||
return tree.map_on_leaf(replace)
|
||||
|
||||
|
||||
def random_generator(
|
||||
rd_variables, conditions=[], rejected=[0], min_max=(-10, 10), variables_scope={}
|
||||
):
|
||||
""" Generate random variables
|
||||
|
||||
:param rd_variables: list of random variables to generate
|
||||
:param conditions: condition over variables
|
||||
:param rejected: Rejected values for the generator (default [0])
|
||||
:param min_max: (min, max) limits in between variables will be generated
|
||||
:param variables_scope: rejected and min_max define for individual variables
|
||||
:return: dictionnary of generated variables
|
||||
|
||||
:example:
|
||||
>>> gene = random_generator(["a", "b"],
|
||||
... ["a > 0"],
|
||||
... [0], (-10, 10),
|
||||
... {"a": {"rejected": [0, 1]},
|
||||
... "b": {"min_max": (-5, 0)}})
|
||||
>>> gene["a"] > 0
|
||||
True
|
||||
>>> gene["a"] != 0
|
||||
True
|
||||
>>> gene["b"] < 0
|
||||
True
|
||||
>>> gene = random_generator(["a", "b"],
|
||||
... ["a % b == 0"],
|
||||
... [0, 1], (-10, 10))
|
||||
>>> gene["a"] not in [0, 1]
|
||||
True
|
||||
>>> gene["b"] in list(range(-10, 11))
|
||||
True
|
||||
>>> gene["a"] % gene["b"]
|
||||
0
|
||||
"""
|
||||
complete_scope = build_variable_scope(
|
||||
rd_variables, rejected, min_max, variables_scope
|
||||
)
|
||||
choices_list = {
|
||||
v: list(
|
||||
set(
|
||||
range(
|
||||
complete_scope[v]["min_max"][0], complete_scope[v]["min_max"][1] + 1
|
||||
)
|
||||
).difference(complete_scope[v]["rejected"])
|
||||
)
|
||||
for v in rd_variables
|
||||
}
|
||||
|
||||
# quantity_choices = reduce(lambda x,y : x*y,
|
||||
# [len(choices_list[v]) for v in choices_list])
|
||||
# TODO: améliorer la méthode de rejet avec un cache |dim. mai 12 17:04:11 CEST 2019
|
||||
|
||||
generate_variable = {v: choice(choices_list[v]) for v in rd_variables}
|
||||
|
||||
while not all([eval(c, __builtins__, generate_variable) for c in conditions]):
|
||||
generate_variable = {v: choice(choices_list[v]) for v in rd_variables}
|
||||
|
||||
return generate_variable
|
||||
|
||||
|
||||
def build_variable_scope(rd_variables, rejected, min_max, variables_scope):
|
||||
""" Build variables scope from incomplete one
|
||||
|
||||
:param rd_variables: list of random variables to generate
|
||||
:param rejected: Rejected values for the generator
|
||||
:param min_max: (min, max) limits in between variables will be generated
|
||||
:param variables_scope: rejected and min_max define for individual variables
|
||||
:return: complete variable scope
|
||||
|
||||
:example:
|
||||
>>> completed = build_variable_scope(["a", "b", "c", "d"], [0], (-10, 10),
|
||||
... {"a": {"rejected": [0, 1]},
|
||||
... "b": {"min_max": (-5, 0)},
|
||||
... "c": {"rejected": [2], "min_max": (0, 5)}})
|
||||
>>> complete = {'a': {'rejected': [0, 1], 'min_max': (-10, 10)},
|
||||
... 'b': {'rejected': [0], 'min_max': (-5, 0)},
|
||||
... 'c': {'rejected': [2], 'min_max': (0, 5)},
|
||||
... 'd': {'rejected': [0], 'min_max': (-10, 10)}}
|
||||
>>> completed == complete
|
||||
True
|
||||
"""
|
||||
complete_scope = variables_scope.copy()
|
||||
for v in rd_variables:
|
||||
try:
|
||||
complete_scope[v]
|
||||
except KeyError:
|
||||
complete_scope[v] = {"rejected": rejected, "min_max": min_max}
|
||||
else:
|
||||
try:
|
||||
complete_scope[v]["rejected"]
|
||||
except KeyError:
|
||||
complete_scope[v]["rejected"] = rejected
|
||||
try:
|
||||
complete_scope[v]["min_max"]
|
||||
except KeyError:
|
||||
complete_scope[v]["min_max"] = min_max
|
||||
return complete_scope
|
||||
|
||||
|
||||
def list_generator(var_list, conditions=[], rejected=[0], min_max=(-10, 10), variables_scope={}, dictionnary=False):
|
||||
""" Generate random computed values from the list
|
||||
|
||||
:param rd_variables: list of random variables to generate (can be computed value - "a*b")
|
||||
:param conditions: condition over variables
|
||||
:param rejected: Rejected values for the generator (default [0])
|
||||
:param min_max: (min, max) limits in between variables will be generated
|
||||
:param variables_scope: rejected and min_max define for individual variables
|
||||
:param dictionnary: the return value will be a dictionnary with var_list as keys (default False)
|
||||
:return: dictionnary of generated variables
|
||||
|
||||
:example:
|
||||
>>> a, ab, b, c = list_generator(["a", "a*b", "b", "c"])
|
||||
>>> a, ab, b, c # doctest: +SKIP
|
||||
(5, -20, -4, -3)
|
||||
>>> a * b == ab
|
||||
True
|
||||
>>> ab # doctest: +SKIP
|
||||
-20
|
||||
>>> a, b # doctest: +SKIP
|
||||
5, -4
|
||||
>>> list_generator(["a", "a*b", "b", "c"], dictionnary=True) # doctest: +SKIP
|
||||
{'a': -3, 'a*b': 18, 'b': -6, 'c': -4}
|
||||
"""
|
||||
rv = extract_rv(var_list)
|
||||
rv_gen = random_generator(rv, conditions, rejected, min_max, variables_scope)
|
||||
generated = compute_leafs(var_list, rv_gen)
|
||||
if dictionnary:
|
||||
return generated
|
||||
return [generated[v] for v in var_list]
|
||||
@@ -1,172 +0,0 @@
|
||||
#! /usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
# vim:fenc=utf-8
|
||||
#
|
||||
# Copyright © 2017 lafrite <lafrite@Poivre>
|
||||
#
|
||||
# Distributed under terms of the MIT license.
|
||||
|
||||
"""
|
||||
Function to create random integer
|
||||
|
||||
"""
|
||||
import random
|
||||
|
||||
__all__ = ["reject_random", "filter_random", "FilterRandom"]
|
||||
|
||||
|
||||
def reject_random(min_value=-10, max_value=10, rejected=[0, 1], accept_callbacks=[]):
|
||||
""" Generate a random integer with the rejection method
|
||||
|
||||
:param name: name of the Integer
|
||||
:param min_value: minimum value
|
||||
:param max_value: maximum value
|
||||
:param rejected: rejected values
|
||||
:param accept_callbacks: list of function for value rejection
|
||||
|
||||
:example:
|
||||
>>> a = reject_random()
|
||||
>>> a not in [0, 1]
|
||||
True
|
||||
>>> a >= -10
|
||||
True
|
||||
>>> a <= 10
|
||||
True
|
||||
>>> a = reject_random(min_value=3, max_value=11, rejected=[5, 7])
|
||||
>>> a not in [5, 7]
|
||||
True
|
||||
>>> a >= 3
|
||||
True
|
||||
>>> a <= 11
|
||||
True
|
||||
>>> a = reject_random(accept_callbacks=[lambda x: x%2])
|
||||
>>> a%2
|
||||
1
|
||||
>>> random.seed(0)
|
||||
>>> reject_random()
|
||||
2
|
||||
>>> random.seed(1)
|
||||
>>> reject_random()
|
||||
-6
|
||||
|
||||
"""
|
||||
conditions = [lambda x: x not in rejected] + accept_callbacks
|
||||
|
||||
candidate = random.randint(min_value, max_value)
|
||||
while not all(c(candidate) for c in conditions):
|
||||
candidate = random.randint(min_value, max_value)
|
||||
|
||||
return candidate
|
||||
|
||||
|
||||
def filter_random(min_value=-10, max_value=10, rejected=[0, 1], accept_callbacks=[]):
|
||||
""" Generate a random integer by filtering then choosing a candidate
|
||||
|
||||
:param name: name of the Integer
|
||||
:param min_value: minimum value
|
||||
:param max_value: maximum value
|
||||
:param rejected: rejected values
|
||||
:param accept_callbacks: list of function for value rejection
|
||||
|
||||
:example:
|
||||
>>> a = filter_random()
|
||||
>>> a not in [0, 1]
|
||||
True
|
||||
>>> a >= -10
|
||||
True
|
||||
>>> a <= 10
|
||||
True
|
||||
>>> a = filter_random(min_value=3, max_value=11, rejected=[5, 7])
|
||||
>>> a not in [5, 7]
|
||||
True
|
||||
>>> a >= 3
|
||||
True
|
||||
>>> a <= 11
|
||||
True
|
||||
>>> a = filter_random(accept_callbacks=[lambda x: x%2])
|
||||
>>> a%2
|
||||
1
|
||||
>>> random.seed(0)
|
||||
>>> filter_random()
|
||||
-7
|
||||
>>> random.seed(1)
|
||||
>>> filter_random()
|
||||
6
|
||||
"""
|
||||
candidates = set(range(min_value, max_value + 1))
|
||||
candidates = {c for c in candidates if c not in rejected}
|
||||
|
||||
candidates = [
|
||||
candidate
|
||||
for candidate in candidates
|
||||
if all(c(candidate) for c in accept_callbacks)
|
||||
]
|
||||
|
||||
if len(candidates) == 0:
|
||||
raise OverflowError(
|
||||
"There is no candidates for this range and those conditions"
|
||||
)
|
||||
return random.choice(candidates)
|
||||
|
||||
|
||||
class FilterRandom(object):
|
||||
|
||||
""" Integer random generator which filter then choose candidate
|
||||
"""
|
||||
|
||||
# TODO: Faire un cache pour éviter de reconstruire les listes à chaque fois |ven. déc. 21 19:07:42 CET 2018
|
||||
|
||||
def __init__(
|
||||
self, rejected=[0, 1], accept_callbacks=[], min_value=-10, max_value=10
|
||||
):
|
||||
self.conditions = (lambda x: x not in rejected,) + tuple(accept_callbacks)
|
||||
|
||||
self._min = min_value
|
||||
self._max = max_value
|
||||
|
||||
candidates = set(range(self._min, self._max + 1))
|
||||
|
||||
self._candidates = {
|
||||
candidate
|
||||
for candidate in candidates
|
||||
if all(c(candidate) for c in self.conditions)
|
||||
}
|
||||
|
||||
def add_candidates(self, low, high):
|
||||
""" Add candidates between low and high to _candidates """
|
||||
if low < self._min:
|
||||
self._min = low
|
||||
useless_low = False
|
||||
else:
|
||||
useless_low = True
|
||||
if high > self._max:
|
||||
self._max = high
|
||||
useless_high = False
|
||||
else:
|
||||
useless_high = True
|
||||
|
||||
if not (useless_low and useless_high):
|
||||
candidates = set(range(low, high + 1))
|
||||
|
||||
self._candidates = self._candidates.union(
|
||||
{
|
||||
candidate
|
||||
for candidate in candidates
|
||||
if all(c(candidate) for c in self.conditions)
|
||||
}
|
||||
)
|
||||
|
||||
def candidates(self, min_value=-10, max_value=10):
|
||||
""" Return candidates between min_value and max_value """
|
||||
return [c for c in self._candidates if (c > min_value and c < max_value)]
|
||||
|
||||
def __call__(self, min_value=-10, max_value=10):
|
||||
""" Randomly choose on candidate """
|
||||
self.add_candidates(min_value, max_value)
|
||||
return random.choice(self.candidates(min_value, max_value))
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
# cursor: 16 del
|
||||
@@ -1,75 +0,0 @@
|
||||
#! /usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
# vim:fenc=utf-8
|
||||
#
|
||||
# Copyright © 2017 lafrite <lafrite@Poivre>
|
||||
#
|
||||
# Distributed under terms of the MIT license.
|
||||
|
||||
"""
|
||||
|
||||
"""
|
||||
from ..coroutine import *
|
||||
|
||||
|
||||
@coroutine
|
||||
def look_for_rdleaf(target):
|
||||
""" Coroutine which look to "{...}" which are RdLeaf
|
||||
|
||||
:example:
|
||||
>>> from ..str2 import list_sink
|
||||
>>> str2list = look_for_rdleaf(list_sink)
|
||||
>>> for i in "{a}+{a*b}-2":
|
||||
... str2list.send(i)
|
||||
>>> a = str2list.throw(STOOOP)
|
||||
>>> a
|
||||
[<RdLeaf a>, '+', <RdLeaf a*b>, '-', '2']
|
||||
|
||||
"""
|
||||
try:
|
||||
target_ = target()
|
||||
except TypeError:
|
||||
target_ = target
|
||||
|
||||
stacking = False
|
||||
try:
|
||||
while True:
|
||||
tok = yield
|
||||
if tok == "{":
|
||||
stack = ""
|
||||
stacking = True
|
||||
elif tok == "}":
|
||||
target_.send(RdLeaf(stack))
|
||||
stack = ""
|
||||
stacking = False
|
||||
else:
|
||||
if stacking:
|
||||
stack += tok
|
||||
else:
|
||||
target_.send(tok)
|
||||
|
||||
except STOOOP as err:
|
||||
yield target_.throw(err)
|
||||
|
||||
|
||||
class RdLeaf:
|
||||
""" Random leaf
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, name):
|
||||
self._name = name
|
||||
self.rdleaf = True
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
return self._name
|
||||
|
||||
def replace(self, computed):
|
||||
return computed[self._name]
|
||||
|
||||
def __str__(self):
|
||||
return "{" + self._name + "}"
|
||||
|
||||
def __repr__(self):
|
||||
return f"<{self.__class__.__name__} {self._name}>"
|
||||
@@ -15,7 +15,6 @@ from decimal import Decimal, InvalidOperation
|
||||
from .coroutine import *
|
||||
from .operator import is_operator
|
||||
from .MO import moify_cor
|
||||
from .random.leaf import look_for_rdleaf, RdLeaf
|
||||
|
||||
__all__ = ["str2"]
|
||||
|
||||
@@ -810,38 +809,7 @@ def str2(sink, convert_to_mo=True):
|
||||
|
||||
return pipeline
|
||||
|
||||
|
||||
def rdstr2(sink):
|
||||
""" Return a pipeline which parse random expression and with sink as endpoint
|
||||
|
||||
:example:
|
||||
>>> rdstr2list = rdstr2(list_sink)
|
||||
>>> rdstr2list("{a}+{a*b}-2")
|
||||
[<RdLeaf a>, '+', <RdLeaf a*b>, '+', <MOnumber -2>]
|
||||
>>> rdstr2list("{a}({b}x+{c})")
|
||||
[<RdLeaf a>, '*', [<RdLeaf b>, '*', <MOstr x>, '+', <RdLeaf c>]]
|
||||
"""
|
||||
lfop = lookfor(is_operator)
|
||||
operator_corout = partial(concurent_broadcast, lookfors=[lfop])
|
||||
|
||||
def pipeline(expression):
|
||||
str2_corout = look_for_rdleaf(
|
||||
lookforNumbers(operator_corout(
|
||||
missing_times(moify_cor(pparser(sink)))))
|
||||
)
|
||||
|
||||
for i in expression.replace(" ", ""):
|
||||
str2_corout.send(i)
|
||||
a = str2_corout.throw(STOOOP)
|
||||
|
||||
return a
|
||||
|
||||
return pipeline
|
||||
|
||||
|
||||
str2nestedlist = str2(list_sink)
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@@ -11,7 +11,7 @@ Tree class
|
||||
|
||||
from .tree_tools import to_nested_parenthesis, postfix_concatenate, show_tree
|
||||
from .coroutine import coroutine, STOOOP
|
||||
from .str2 import str2, rdstr2
|
||||
from .str2 import str2
|
||||
from .operator import OPERATORS, is_operator
|
||||
|
||||
__all__ = ["Tree", "MutableTree"]
|
||||
@@ -51,7 +51,7 @@ class Tree:
|
||||
self.right_value = right_value
|
||||
|
||||
@classmethod
|
||||
def from_str(cls, expression, convert_to_mo=True, random=False):
|
||||
def from_str(cls, expression, convert_to_mo=True):
|
||||
""" Initiate a tree from an string expression
|
||||
|
||||
:example:
|
||||
@@ -77,26 +77,8 @@ class Tree:
|
||||
> *
|
||||
| > 3
|
||||
| > n
|
||||
>>> t = Tree.from_str("2+{n}x", random=True)
|
||||
>>> print(t)
|
||||
+
|
||||
> 2
|
||||
> *
|
||||
| > {n}
|
||||
| > x
|
||||
>>> t = Tree.from_str("{a}({b}x+{c})", random=True)
|
||||
>>> print(t)
|
||||
*
|
||||
> {a}
|
||||
> +
|
||||
| > *
|
||||
| | > {b}
|
||||
| | > x
|
||||
| > {c}
|
||||
|
||||
|
||||
"""
|
||||
t = MutableTree.from_str(expression, convert_to_mo, random)
|
||||
t = MutableTree.from_str(expression, convert_to_mo)
|
||||
return cls.from_any_tree(t)
|
||||
|
||||
@classmethod
|
||||
@@ -907,7 +889,7 @@ class MutableTree(Tree):
|
||||
self.right_value = right_value
|
||||
|
||||
@classmethod
|
||||
def from_str(cls, expression, convert_to_mo=True, random=False):
|
||||
def from_str(cls, expression, convert_to_mo=True):
|
||||
""" Initiate the MutableTree
|
||||
|
||||
:example:
|
||||
@@ -963,29 +945,9 @@ class MutableTree(Tree):
|
||||
| | > 8
|
||||
| | > 3
|
||||
| > x
|
||||
>>> t = MutableTree.from_str("{b}*x+{c}", random=True)
|
||||
>>> print(t)
|
||||
+
|
||||
> *
|
||||
| > {b}
|
||||
| > x
|
||||
> {c}
|
||||
>>> t = MutableTree.from_str("{a}*({b}*x+{c})", random=True)
|
||||
>>> print(t)
|
||||
*
|
||||
> {a}
|
||||
> +
|
||||
| > *
|
||||
| | > {b}
|
||||
| | > x
|
||||
| > {c}
|
||||
"""
|
||||
if random:
|
||||
str_2_mut_tree = rdstr2(cls.sink)
|
||||
return str_2_mut_tree(expression)
|
||||
else:
|
||||
str_2_mut_tree = str2(cls.sink, convert_to_mo)
|
||||
return str_2_mut_tree(expression)
|
||||
str_2_mut_tree = str2(cls.sink, convert_to_mo)
|
||||
return str_2_mut_tree(expression)
|
||||
|
||||
@classmethod
|
||||
@coroutine
|
||||
|
||||
Reference in New Issue
Block a user