From aad2395a3a49e31912bdf5ec41d847ed8b545b5b Mon Sep 17 00:00:00 2001 From: Bertrand Benjamin Date: Sat, 9 Oct 2021 06:30:38 +0200 Subject: [PATCH] Fix: format with black --- mapytex/calculus/random/core/generate.py | 29 ++--- mapytex/calculus/random/core/grammar.py | 10 +- mapytex/calculus/random/core/int_gene.py | 129 ++++++++++---------- mapytex/calculus/random/core/leaf.py | 6 +- mapytex/calculus/random/core/random_tree.py | 29 +++-- mapytex/calculus/random/core/str2.py | 16 ++- mapytex/calculus/random/expression.py | 20 ++- mapytex/calculus/random/list.py | 20 ++- 8 files changed, 140 insertions(+), 119 deletions(-) diff --git a/mapytex/calculus/random/core/generate.py b/mapytex/calculus/random/core/generate.py index 6835a92..70cddf8 100644 --- a/mapytex/calculus/random/core/generate.py +++ b/mapytex/calculus/random/core/generate.py @@ -10,8 +10,10 @@ from random import choice -def complete_variable_configs(variables, global_config:dict={}, configs:dict={})->dict: - """ Completes variables configurations with the global configuration +def complete_variable_configs( + variables, global_config: dict = {}, configs: dict = {} +) -> dict: + """Completes variables configurations with the global configuration :param variables: list of random variables to generate :param global_config: global parameters @@ -26,7 +28,7 @@ def complete_variable_configs(variables, global_config:dict={}, configs:dict={}) ... "b": {"min_max": (-5, 0)}, ... "c": {"rejected": [2], "min_max": (0, 5)} ... }) - >>> completed["a"] == {'rejected': [0, 1], 'min_max': (-10, 10)} + >>> completed["a"] == {'rejected': [0, 1], 'min_max': (-10, 10)} True >>> completed["b"] == {'rejected': [], 'min_max': (-5, 0)} True @@ -45,11 +47,14 @@ def complete_variable_configs(variables, global_config:dict={}, configs:dict={}) complete_configs[variable] = dict(global_config, **configs[variable]) return complete_configs - + def random_generator( - variables:list[str], conditions:list[str]=[], global_config:dict={}, configs:dict={}, -)-> dict[str, int]: - """ Generate random variables + variables: list[str], + conditions: list[str] = [], + global_config: dict = {}, + configs: dict = {}, +) -> dict[str, int]: + """Generate random variables :param variables: list of random variables to generate :param conditions: condition over variables @@ -58,7 +63,7 @@ def random_generator( :return: dictionnary of generated variables :example: - >>> gene = random_generator(["a", "b"], + >>> gene = random_generator(["a", "b"], ... ["a > 0"], ... {"rejected": [0], "min_max":(-10, 10)}, ... {"a": {"rejected": [0, 1]}, @@ -70,7 +75,7 @@ def random_generator( True >>> gene["b"] < 0 True - >>> gene = random_generator(["a", "b"], + >>> gene = random_generator(["a", "b"], ... ["a % b == 0"], ... {"rejected": [0, 1], "min_max":(-10, 10)} ... ) @@ -81,9 +86,7 @@ def random_generator( >>> gene["a"] % gene["b"] 0 """ - complete_scope = complete_variable_configs( - variables, global_config, configs - ) + complete_scope = complete_variable_configs(variables, global_config, configs) choices_list = { v: list( set( @@ -105,5 +108,3 @@ def random_generator( generate_variable = {v: choice(choices_list[v]) for v in variables} return generate_variable - - diff --git a/mapytex/calculus/random/core/grammar.py b/mapytex/calculus/random/core/grammar.py index f1ec288..be5a462 100644 --- a/mapytex/calculus/random/core/grammar.py +++ b/mapytex/calculus/random/core/grammar.py @@ -1,6 +1,5 @@ - -def extract_letters(words:list[str])->set[str]: - """ Extracts unique letters from a list of words +def extract_letters(words: list[str]) -> set[str]: + """Extracts unique letters from a list of words :param words: list of leafs :return: set of letters @@ -18,8 +17,8 @@ def extract_letters(words:list[str])->set[str]: return letters -def eval_words(words:list[str], values:dict[str,int]) -> dict[str, int]: - """ Evaluate words replacing letters with values +def eval_words(words: list[str], values: dict[str, int]) -> dict[str, int]: + """Evaluate words replacing letters with values :param words: list of words :param values: Dictionary of letters:value @@ -32,4 +31,3 @@ def eval_words(words:list[str], values:dict[str,int]) -> dict[str, int]: {'a': 2, 'a*k': 6} """ return {word: eval(word, values) for word in words} - diff --git a/mapytex/calculus/random/core/int_gene.py b/mapytex/calculus/random/core/int_gene.py index b33d40b..956e7c2 100644 --- a/mapytex/calculus/random/core/int_gene.py +++ b/mapytex/calculus/random/core/int_gene.py @@ -16,38 +16,38 @@ __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 + """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 + :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 + :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 @@ -60,38 +60,38 @@ def reject_random(min_value=-10, max_value=10, rejected=[0, 1], accept_callbacks def filter_random(min_value=-10, max_value=10, rejected=[0, 1], accept_callbacks=[]): - """ Generate a random integer by filtering then choosing a candidate + """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 + :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 + :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} @@ -111,8 +111,7 @@ def filter_random(min_value=-10, max_value=10, rejected=[0, 1], accept_callbacks class FilterRandom(object): - """ Integer random generator which filter then choose candidate - """ + """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 @@ -133,7 +132,7 @@ class FilterRandom(object): } def add_candidates(self, low, high): - """ Add candidates between low and high to _candidates """ + """Add candidates between low and high to _candidates""" if low < self._min: self._min = low useless_low = False @@ -157,11 +156,11 @@ class FilterRandom(object): ) def candidates(self, min_value=-10, max_value=10): - """ Return candidates between min_value and max_value """ + """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 """ + """Randomly choose on candidate""" self.add_candidates(min_value, max_value) return random.choice(self.candidates(min_value, max_value)) diff --git a/mapytex/calculus/random/core/leaf.py b/mapytex/calculus/random/core/leaf.py index 7be0e65..19e4636 100644 --- a/mapytex/calculus/random/core/leaf.py +++ b/mapytex/calculus/random/core/leaf.py @@ -14,7 +14,7 @@ from ...core.coroutine import coroutine, STOOOP @coroutine def look_for_rdleaf(target): - """ Coroutine which look to "{...}" which are RdLeaf + """Coroutine which look to "{...}" which are RdLeaf :example: >>> from ...core.str2 import list_sink @@ -53,9 +53,7 @@ def look_for_rdleaf(target): class RdLeaf: - """ Random leaf - - """ + """Random leaf""" def __init__(self, name): self._name = name diff --git a/mapytex/calculus/random/core/random_tree.py b/mapytex/calculus/random/core/random_tree.py index 891953e..a96b993 100644 --- a/mapytex/calculus/random/core/random_tree.py +++ b/mapytex/calculus/random/core/random_tree.py @@ -4,8 +4,9 @@ from .grammar import extract_letters, eval_words from .generate import random_generator from .str2 import rdstr2 + class RandomTree(MutableTree): - """ MutableTree that accept {a} syntax for random generation + """MutableTree that accept {a} syntax for random generation :example: >>> t = RandomTree() @@ -15,7 +16,7 @@ class RandomTree(MutableTree): @classmethod def from_str(cls, expression): - """ Initiate a random tree from a string that need to be parsed + """Initiate a random tree from a string that need to be parsed :exemple: >>> t = RandomTree.from_str("{b}*x+{c}") @@ -40,7 +41,7 @@ class RandomTree(MutableTree): @property def random_leaves(self) -> list[str]: - """ Get list of random leaves + """Get list of random leaves :example: >>> from .leaf import RdLeaf @@ -61,10 +62,9 @@ class RandomTree(MutableTree): rd_leafs.append(leaf.name) return rd_leafs - @property def random_value(self) -> set[str]: - """ Get set of random values to generate + """Get set of random values to generate :example: >>> from .leaf import RdLeaf @@ -77,9 +77,8 @@ class RandomTree(MutableTree): """ return extract_letters(self.random_leaves) - - def eval_random_leaves(self, leaves_value:dict[str, int]): - """ Given random leaves value get the tree + def eval_random_leaves(self, leaves_value: dict[str, int]): + """Given random leaves value get the tree :example: >>> from .leaf import RdLeaf @@ -93,21 +92,27 @@ class RandomTree(MutableTree): > 2 > 6 """ + def replace(leaf): try: return leaf.replace(leaves_value) except AttributeError: return leaf + return self.map_on_leaf(replace).map_on_leaf(moify) - - def generate(self, conditions:list[str]=[], global_config:dict={} , configs:dict={}) -> Tree: - """ Generate a random version of self + + def generate( + self, conditions: list[str] = [], global_config: dict = {}, configs: dict = {} + ) -> Tree: + """Generate a random version of self :param conditions: list of conditions :param config: global configuration for generated values :param configs: specific configuration for each generated values """ - generated_values = random_generator(self.random_value, conditions, global_config, configs) + generated_values = random_generator( + self.random_value, conditions, global_config, configs + ) leaves = eval_words(self.random_leaves, generated_values) return self.eval_random_leaves(leaves) diff --git a/mapytex/calculus/random/core/str2.py b/mapytex/calculus/random/core/str2.py index 08ee776..5a7c46d 100644 --- a/mapytex/calculus/random/core/str2.py +++ b/mapytex/calculus/random/core/str2.py @@ -1,13 +1,19 @@ - from ...core.operator import is_operator from functools import partial -from ...core.str2 import concurent_broadcast, lookforNumbers, pparser, missing_times, lookfor +from ...core.str2 import ( + concurent_broadcast, + lookforNumbers, + pparser, + missing_times, + lookfor, +) from ...core.coroutine import STOOOP from ...core.MO import moify_cor from .leaf import look_for_rdleaf + def rdstr2(sink): - """ Return a pipeline which parse random expression and with sink as endpoint + """Return a pipeline which parse random expression and with sink as endpoint :example: >>> from ...core.str2 import list_sink @@ -22,8 +28,7 @@ def rdstr2(sink): def pipeline(expression): str2_corout = look_for_rdleaf( - lookforNumbers(operator_corout( - missing_times(moify_cor(pparser(sink))))) + lookforNumbers(operator_corout(missing_times(moify_cor(pparser(sink))))) ) for i in expression.replace(" ", ""): @@ -33,4 +38,3 @@ def rdstr2(sink): return a return pipeline - diff --git a/mapytex/calculus/random/expression.py b/mapytex/calculus/random/expression.py index 758f128..7c72c93 100644 --- a/mapytex/calculus/random/expression.py +++ b/mapytex/calculus/random/expression.py @@ -2,12 +2,18 @@ from ..API.expression import Expression from .core.random_tree import RandomTree DEFAUTL_CONFIG = { - "rejected": [0, 1], - "min_max": (-10, 10), - } + "rejected": [0, 1], + "min_max": (-10, 10), +} -def expression_generator(template:str, conditions:list[str]=[], global_config:dict={}, configs:dict={}): - """ Generate a random expression + +def expression_generator( + template: str, + conditions: list[str] = [], + global_config: dict = {}, + configs: dict = {}, +): + """Generate a random expression :param template: the template of the expression :param conditions: conditions on randomly generate variable @@ -31,5 +37,7 @@ def expression_generator(template:str, conditions:list[str]=[], global_config:di """ rd_tree = RandomTree.from_str(template) - generated_tree = rd_tree.generate(conditions, dict(DEFAUTL_CONFIG, **global_config), configs) + generated_tree = rd_tree.generate( + conditions, dict(DEFAUTL_CONFIG, **global_config), configs + ) return Expression._post_processing(generated_tree) diff --git a/mapytex/calculus/random/list.py b/mapytex/calculus/random/list.py index bb6378c..acdfb69 100644 --- a/mapytex/calculus/random/list.py +++ b/mapytex/calculus/random/list.py @@ -13,12 +13,18 @@ from .core.generate import random_generator from .core.grammar import extract_letters, eval_words DEFAUTL_CONFIG = { - "rejected": [0], - "min_max": (-10, 10), - } + "rejected": [0], + "min_max": (-10, 10), +} -def list_generator(var_list:list[str], conditions:list[str]=[], global_config:dict={}, configs:dict={})->list[int]: - """ Generate random computed values from the list + +def list_generator( + var_list: list[str], + conditions: list[str] = [], + global_config: dict = {}, + configs: dict = {}, +) -> list[int]: + """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 @@ -51,6 +57,8 @@ def list_generator(var_list:list[str], conditions:list[str]=[], global_config:di True """ rv = extract_letters(var_list) - rv_gen = random_generator(rv, conditions, dict(DEFAUTL_CONFIG, **global_config), configs) + rv_gen = random_generator( + rv, conditions, dict(DEFAUTL_CONFIG, **global_config), configs + ) generated = eval_words(var_list, rv_gen) return [generated[v] for v in var_list]