Fix: format with black

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:
+def complete_variable_configs(
-    """ Completes variables configurations with the global configuration
+    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={},
+    variables: list[str],
-)-> dict[str, int]:
+    conditions: list[str] = [],
-    """ Generate random variables
+    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(
+    complete_scope = complete_variable_configs(variables, global_config, 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
-
-

mapytex/calculus/random/core/grammar.py

@@ -1,6 +1,5 @@
-
+def extract_letters(words: list[str]) -> set[str]:
-def extract_letters(words:list[str])->set[str]:
+    """Extracts unique letters from a list of words
-    """ 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]:
+def eval_words(words: list[str], values: dict[str, int]) -> dict[str, int]:
-    """ Evaluate words replacing letters with values
+    """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}
-

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 name: name of the Integer
-        :param min_value: minimum value
+    :param min_value: minimum value
-        :param max_value: maximum value
+    :param max_value: maximum value
-        :param rejected: rejected values
+    :param rejected: rejected values
-        :param accept_callbacks: list of function for value rejection
+    :param accept_callbacks: list of function for value rejection
 
-        :example:
+    :example:
-        >>> a = reject_random()
+    >>> a = reject_random()
-        >>> a not in [0, 1]
+    >>> a not in [0, 1]
-        True
+    True
-        >>> a >= -10
+    >>> a >= -10
-        True
+    True
-        >>> a <= 10
+    >>> a <= 10
-        True
+    True
-        >>> a = reject_random(min_value=3, max_value=11, rejected=[5, 7])
+    >>> a = reject_random(min_value=3, max_value=11, rejected=[5, 7])
-        >>> a not in [5, 7]
+    >>> a not in [5, 7]
-        True
+    True
-        >>> a >= 3
+    >>> a >= 3
-        True
+    True
-        >>> a <= 11
+    >>> a <= 11
-        True
+    True
-        >>> a = reject_random(accept_callbacks=[lambda x: x%2])
+    >>> a = reject_random(accept_callbacks=[lambda x: x%2])
-        >>> a%2
+    >>> a%2
-        1
+    1
-        >>> random.seed(0)
+    >>> random.seed(0)
-        >>> reject_random()
+    >>> reject_random()
-        2
+    2
-        >>> random.seed(1)
+    >>> random.seed(1)
-        >>> reject_random()
+    >>> reject_random()
-        -6
+    -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 name: name of the Integer
-        :param min_value: minimum value
+    :param min_value: minimum value
-        :param max_value: maximum value
+    :param max_value: maximum value
-        :param rejected: rejected values
+    :param rejected: rejected values
-        :param accept_callbacks: list of function for value rejection
+    :param accept_callbacks: list of function for value rejection
 
-        :example:
+    :example:
-        >>> a = filter_random()
+    >>> a = filter_random()
-        >>> a not in [0, 1]
+    >>> a not in [0, 1]
-        True
+    True
-        >>> a >= -10
+    >>> a >= -10
-        True
+    True
-        >>> a <= 10
+    >>> a <= 10
-        True
+    True
-        >>> a = filter_random(min_value=3, max_value=11, rejected=[5, 7])
+    >>> a = filter_random(min_value=3, max_value=11, rejected=[5, 7])
-        >>> a not in [5, 7]
+    >>> a not in [5, 7]
-        True
+    True
-        >>> a >= 3
+    >>> a >= 3
-        True
+    True
-        >>> a <= 11
+    >>> a <= 11
-        True
+    True
-        >>> a = filter_random(accept_callbacks=[lambda x: x%2])
+    >>> a = filter_random(accept_callbacks=[lambda x: x%2])
-        >>> a%2
+    >>> a%2
-        1
+    1
-        >>> random.seed(0)
+    >>> random.seed(0)
-        >>> filter_random()
+    >>> filter_random()
-        -7
+    -7
-        >>> random.seed(1)
+    >>> random.seed(1)
-        >>> filter_random()
+    >>> filter_random()
-        6
+    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))
 

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

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]):
-    def eval_random_leaves(self, leaves_value:dict[str, int]):
+        """Given random leaves value get the tree
-        """ 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:
+    def generate(
-        """ Generate a random version of self 
+        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)

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(
+            lookforNumbers(operator_corout(missing_times(moify_cor(pparser(sink)))))
-                missing_times(moify_cor(pparser(sink)))))
         )
 
         for i in expression.replace(" ", ""):
@@ -33,4 +38,3 @@ def rdstr2(sink):
         return a
 
     return pipeline
-

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],
+    "rejected": [0, 1],
-        "min_max": (-10, 10),
+    "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)

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],
+    "rejected": [0],
-        "min_max": (-10, 10),
+    "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]