lafrite/Mapytex
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix: format with black

Browse Source
This commit is contained in:
Bertrand Benjamin 2021-10-09 06:30:38 +02:00
parent a267acd7b3
commit aad2395a3a
8 changed files with 140 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
mapytex/calculus/random/core/generate.py
View File

@ -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

10
mapytex/calculus/random/core/grammar.py
View File

@ -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}

129
mapytex/calculus/random/core/int_gene.py
View File

@ -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))

6
mapytex/calculus/random/core/leaf.py
View File

@ -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

29
mapytex/calculus/random/core/random_tree.py
View File

@ -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)

16
mapytex/calculus/random/core/str2.py
View File

@ -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

20
mapytex/calculus/random/expression.py
View File

@ -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)

20
mapytex/calculus/random/list.py
View File

@ -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]