async_btree 1.3.0__tar.gz

async_btree-1.3.0/LICENSE.md

@@ -0,0 +1,23 @@
+# License
+
+**The MIT License (MIT)**
+
+Copyright © 2019, Jerome Guibert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

async_btree-1.3.0/PKG-INFO

@@ -0,0 +1,231 @@
+Metadata-Version: 2.1
+Name: async_btree
+Version: 1.3.0
+Summary: Async behavior tree
+Home-page: https://pypi.org/project/async_btree
+License: MIT
+Keywords: behavior-tree,asyncio
+Author: Jerome Guibert
+Author-email: jguibert@gmail.com
+Requires-Python: >=3.8,<3.12
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Provides-Extra: curio
+Requires-Dist: curio (>=1.4,<2.0) ; extra == "curio"
+Requires-Dist: typing-extensions (>=4.5.0,<5.0.0)
+Project-URL: Documentation, https://geronimo-iia.github.io/async-btree/
+Project-URL: Repository, https://github.com/geronimo-iia/async-btree
+Description-Content-Type: text/markdown
+
+# Async Behaviour Tree for Python
+
+
+[![Unix Build Status](https://img.shields.io/travis/geronimo-iia/async-btree/master.svg?label=unix)](https://travis-ci.com/geronimo-iia/async-btree)
+[![Coverage Status](https://img.shields.io/coveralls/geronimo-iia/async-btree/master.svg)](https://coveralls.io/r/geronimo-iia/async-btree)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/fe669a02b4aa46b5b1faf619ba2bf382)](https://www.codacy.com/app/geronimo-iia/async-btree?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=geronimo-iia/async-btree&amp;utm_campaign=Badge_Grade)
+[![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/g/geronimo-iia/async-btree.svg)](https://scrutinizer-ci.com/g/geronimo-iia/async-btree/?branch=master)
+[![PyPI Version](https://img.shields.io/pypi/v/async-btree.svg)](https://pypi.org/project/async-btree)
+[![PyPI License](https://img.shields.io/pypi/l/async-btree.svg)](https://pypi.org/project/async-btree)
+
+Versions following [Semantic Versioning](https://semver.org/)
+
+See [documentation](https://geronimo-iia.github.io/async-btree).
+
+
+## Overview
+
+
+### What's a behavior tree ?
+
+> Unlike a Finite State Machine, a Behaviour Tree is a tree of hierarchical nodes that controls the flow of decision and the execution of "tasks" or, as we will call them further, "Actions".
+> -- <cite>[behaviortree](https://www.behaviortree.dev/bt_basics/)</cite>
+
+If your new (or not) about behavior tree, you could spend some time on this few links:
+
+- [Behavior trees for AI: How they work](https://www.gamasutra.com/blogs/ChrisSimpson/20140717/221339/Behavior_trees_for_AI_How_they_work.php) by Chris Simpson
+- [Introduction to BTs](https://www.behaviortree.dev/bt_basics/)
+
+Few implementation libraries:
+
+- [task_behavior_engine](https://github.com/ToyotaResearchInstitute/task_behavior_engine) A behavior tree based task engine written in Python
+- [pi_trees](https://github.com/pirobot/pi_trees/) a Python/ROS library for implementing Behavior Trees
+- [pr_behavior_tree](https://github.com/personalrobotics/pr_behavior_tree) A simple python behavior tree library based on coroutines
+- [btsk](https://github.com/aigamedev/btsk) Behavior Tree Starter Kit
+- [behave](https://github.com/fuchen/behave) A behavior tree implementation in Python
+
+
+### Why another library so ?
+
+__SIMPLICITY__
+
+When you study behavior tree implementation, reactive node, dynamic change, runtime execution, etc ...
+At a moment you're build more or less something that mimic an evaluator 'eval/apply' or a compilator, with a complex hierachical set of class.
+
+All complexity came with internal state management, using tree of blackboard to avoid global variable, multithreading issue, maybe few callback etc ...
+
+This break the simplicity and beauty of your initial design.
+
+What I find usefull with behavior tree:
+
+- clarity of expression
+- node tree representation
+- possibility to reuse behavior
+- add external measure to dynamicaly change a behavior, a first step on observable pattern...
+
+As I've used OOP for years (very long time), I will try to avoid class tree and prefer using the power of functionnal programming to obtain what I want: add metadata on a sematic construction, deal with closure, use function in parameters or in return value...
+
+And a last reason, more personal, it that i would explore python expressivity.
+
+__SO HOW ?__
+
+In this module, I purpose you to use the concept of coroutines, and their mecanisms to manage the execution flow.
+By this way:
+
+- we reuse simple language idiom to manage state, parameter, etc
+- no design constraint on action implementation
+- most of language build block could be reused
+
+You could build expression like this:
+
+```python
+
+async def a_func():
+    """A great function"""
+    return "a"
+
+async def b_decorator(child_value, other=""):
+    """A great decorator..."""
+    return f"b{child_value}{other}"
+
+assert run(decorate(a_func, b_decorator)) == "ba"
+
+```
+This expression apply ```b_decorator``` on function ```a_func```. 
+Note that ```decorate(a_func, b_decorator)``` is not an async function, only action, or condition are async function.
+
+
+Few guidelines of this implementation:
+
+- In order to mimic all NodeStatus (success, failure, running), I replace this by truthy/falsy meaning of evaluation value.
+  A special dedicated exception decorate standard exception in order to give them a Falsy meaning (`ControlFlowException`).
+  By default, exception are raised like happen usually until you catch them.
+- Blackboard pattern, act as a manager of context variable for behavior tree.
+  With python 3, please... simply use [contextvars](https://docs.python.org/3/library/contextvars.html) !
+- In order to be able to build a sematic tree, I've introduce a metadata tuple added on function implementation.
+
+The rest is just implementation details..
+
+
+
+A little note:
+
+> You should not use this until you're ready to think about what you're doing :)
+
+
+### Note about 'async' framework
+
+As we use async function as underlaying mechanism to manage the execution flow, the standard library asyncio is pretty fine.
+But, (always a but somewhere isn't it...), you should read this [amazing blog post](https://vorpus.org/blog/some-thoughts-on-asynchronous-api-design-in-a-post-asyncawait-world/) by Nathaniel J. Smith.
+And next study [curio](https://github.com/dabeaz/curio) framework in deep.
+
+As curio say:
+> Don't Use Curio if You're Allergic to Curio
+
+Personaly, after few time of testing and reading curio code, I'm pretty addict.
+
+If `curio` is not present, we default to `asyncio`.
+
+## Installation
+
+Install this library directly into an activated virtual environment with pip or [Poetry](https://poetry.eustace.io/) :
+
+ - `python -m pip install async-btree` or '`poetry add async-btree`
+ - with with curio extention: `python -m pip install async-btree[curio]` or '`poetry add async-btree[curio]`
+
+
+## Usage
+
+After installation, the package can imported:
+
+```text
+$ python
+>>> import async_btree
+>>> async_btree.__version__
+```
+
+See [API Reference documentation](https://geronimo-iia.github.io/async-btree).
+
+
+With this framework, you didn't find any configuration file, no Xml, no json, no yaml.
+
+The main reason (oriented and personal point of view) is that you did not need to introduce an extra level of abtraction 
+to declare a composition of functions. I think it's true for most of main use case (except using an editor to wrote behaviour tree for example).
+
+So "If you wrote your function with python, wrote composition in python"... 
+_(remember that you did not need XML to do SQL, just write good sql...)_
+
+
+So, the goal is to:
+ - define your business function wich implements actions or conditions, with all test case that you wish/need
+ - compose them using those provided by this framework like ```sequence```, ```selector```, ...
+ - use them as it is or create a well define python module to reuse them
+
+
+Wanna style have an abtract tree of our behaviour tree ?
+
+Functions from async-btree build an abstract tree for you. 
+If you lookup in code, you should see an annotation "node_metadata" on internal implementation. 
+This decorator add basic information like function name, parameters, and children relation ship.
+
+This abstract tree can be retreived and stringified with ```analyze``` and ```stringify_analyze```.
+Here the profile:
+
+```python
+  def analyze(target: CallableFunction) -> Node: # here we have our "abtract tree code"
+    ...
+```
+
+For example:
+
+```python
+
+# your behaviour tree, or a sub tree:
+my_func = alias(child=repeat_until(child=action(hello), condition=success_until_zero), name="btree_1")
+
+# retrieve meta information and build a Node tree
+abstract_tree_tree_1 = analyze(my_func) 
+
+# output the tree:
+print(stringify_analyze(abstract_tree_tree_1))
+```
+
+This should print:
+
+```text
+ --> btree_1:
+     --(child)--> repeat_until:
+         --(condition)--> success_until_zero:
+         --(child)--> action:
+                      target: hello
+```
+
+
+Note about action and condition method:
+
+ - you could use sync or async function
+ - you could specify a return value with SUCCESS or FAILURE
+ - function with no return value will be evaluated as FAILURE until you decorate them with a `always_success`or `always_failure`
+
+See this [example/tutorial_1.py](https://raw.githubusercontent.com/geronimo-iia/async-btree/master/examples/tutorial_1.py) for more information.

async_btree-1.3.0/README.md

@@ -0,0 +1,200 @@
+# Async Behaviour Tree for Python
+
+
+[![Unix Build Status](https://img.shields.io/travis/geronimo-iia/async-btree/master.svg?label=unix)](https://travis-ci.com/geronimo-iia/async-btree)
+[![Coverage Status](https://img.shields.io/coveralls/geronimo-iia/async-btree/master.svg)](https://coveralls.io/r/geronimo-iia/async-btree)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/fe669a02b4aa46b5b1faf619ba2bf382)](https://www.codacy.com/app/geronimo-iia/async-btree?utm_source=github.com&utm_medium=referral&utm_content=geronimo-iia/async-btree&utm_campaign=Badge_Grade)
+[![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/g/geronimo-iia/async-btree.svg)](https://scrutinizer-ci.com/g/geronimo-iia/async-btree/?branch=master)
+[![PyPI Version](https://img.shields.io/pypi/v/async-btree.svg)](https://pypi.org/project/async-btree)
+[![PyPI License](https://img.shields.io/pypi/l/async-btree.svg)](https://pypi.org/project/async-btree)
+
+Versions following [Semantic Versioning](https://semver.org/)
+
+See [documentation](https://geronimo-iia.github.io/async-btree).
+
+
+## Overview
+
+
+### What's a behavior tree ?
+
+> Unlike a Finite State Machine, a Behaviour Tree is a tree of hierarchical nodes that controls the flow of decision and the execution of "tasks" or, as we will call them further, "Actions".
+> -- <cite>[behaviortree](https://www.behaviortree.dev/bt_basics/)</cite>
+
+If your new (or not) about behavior tree, you could spend some time on this few links:
+
+- [Behavior trees for AI: How they work](https://www.gamasutra.com/blogs/ChrisSimpson/20140717/221339/Behavior_trees_for_AI_How_they_work.php) by Chris Simpson
+- [Introduction to BTs](https://www.behaviortree.dev/bt_basics/)
+
+Few implementation libraries:
+
+- [task_behavior_engine](https://github.com/ToyotaResearchInstitute/task_behavior_engine) A behavior tree based task engine written in Python
+- [pi_trees](https://github.com/pirobot/pi_trees/) a Python/ROS library for implementing Behavior Trees
+- [pr_behavior_tree](https://github.com/personalrobotics/pr_behavior_tree) A simple python behavior tree library based on coroutines
+- [btsk](https://github.com/aigamedev/btsk) Behavior Tree Starter Kit
+- [behave](https://github.com/fuchen/behave) A behavior tree implementation in Python
+
+
+### Why another library so ?
+
+__SIMPLICITY__
+
+When you study behavior tree implementation, reactive node, dynamic change, runtime execution, etc ...
+At a moment you're build more or less something that mimic an evaluator 'eval/apply' or a compilator, with a complex hierachical set of class.
+
+All complexity came with internal state management, using tree of blackboard to avoid global variable, multithreading issue, maybe few callback etc ...
+
+This break the simplicity and beauty of your initial design.
+
+What I find usefull with behavior tree:
+
+- clarity of expression
+- node tree representation
+- possibility to reuse behavior
+- add external measure to dynamicaly change a behavior, a first step on observable pattern...
+
+As I've used OOP for years (very long time), I will try to avoid class tree and prefer using the power of functionnal programming to obtain what I want: add metadata on a sematic construction, deal with closure, use function in parameters or in return value...
+
+And a last reason, more personal, it that i would explore python expressivity.
+
+__SO HOW ?__
+
+In this module, I purpose you to use the concept of coroutines, and their mecanisms to manage the execution flow.
+By this way:
+
+- we reuse simple language idiom to manage state, parameter, etc
+- no design constraint on action implementation
+- most of language build block could be reused
+
+You could build expression like this:
+
+```python
+
+async def a_func():
+    """A great function"""
+    return "a"
+
+async def b_decorator(child_value, other=""):
+    """A great decorator..."""
+    return f"b{child_value}{other}"
+
+assert run(decorate(a_func, b_decorator)) == "ba"
+
+```
+This expression apply ```b_decorator``` on function ```a_func```. 
+Note that ```decorate(a_func, b_decorator)``` is not an async function, only action, or condition are async function.
+
+
+Few guidelines of this implementation:
+
+- In order to mimic all NodeStatus (success, failure, running), I replace this by truthy/falsy meaning of evaluation value.
+  A special dedicated exception decorate standard exception in order to give them a Falsy meaning (`ControlFlowException`).
+  By default, exception are raised like happen usually until you catch them.
+- Blackboard pattern, act as a manager of context variable for behavior tree.
+  With python 3, please... simply use [contextvars](https://docs.python.org/3/library/contextvars.html) !
+- In order to be able to build a sematic tree, I've introduce a metadata tuple added on function implementation.
+
+The rest is just implementation details..
+
+
+
+A little note:
+
+> You should not use this until you're ready to think about what you're doing :)
+
+
+### Note about 'async' framework
+
+As we use async function as underlaying mechanism to manage the execution flow, the standard library asyncio is pretty fine.
+But, (always a but somewhere isn't it...), you should read this [amazing blog post](https://vorpus.org/blog/some-thoughts-on-asynchronous-api-design-in-a-post-asyncawait-world/) by Nathaniel J. Smith.
+And next study [curio](https://github.com/dabeaz/curio) framework in deep.
+
+As curio say:
+> Don't Use Curio if You're Allergic to Curio
+
+Personaly, after few time of testing and reading curio code, I'm pretty addict.
+
+If `curio` is not present, we default to `asyncio`.
+
+## Installation
+
+Install this library directly into an activated virtual environment with pip or [Poetry](https://poetry.eustace.io/) :
+
+ - `python -m pip install async-btree` or '`poetry add async-btree`
+ - with with curio extention: `python -m pip install async-btree[curio]` or '`poetry add async-btree[curio]`
+
+
+## Usage
+
+After installation, the package can imported:
+
+```text
+$ python
+>>> import async_btree
+>>> async_btree.__version__
+```
+
+See [API Reference documentation](https://geronimo-iia.github.io/async-btree).
+
+
+With this framework, you didn't find any configuration file, no Xml, no json, no yaml.
+
+The main reason (oriented and personal point of view) is that you did not need to introduce an extra level of abtraction 
+to declare a composition of functions. I think it's true for most of main use case (except using an editor to wrote behaviour tree for example).
+
+So "If you wrote your function with python, wrote composition in python"... 
+_(remember that you did not need XML to do SQL, just write good sql...)_
+
+
+So, the goal is to:
+ - define your business function wich implements actions or conditions, with all test case that you wish/need
+ - compose them using those provided by this framework like ```sequence```, ```selector```, ...
+ - use them as it is or create a well define python module to reuse them
+
+
+Wanna style have an abtract tree of our behaviour tree ?
+
+Functions from async-btree build an abstract tree for you. 
+If you lookup in code, you should see an annotation "node_metadata" on internal implementation. 
+This decorator add basic information like function name, parameters, and children relation ship.
+
+This abstract tree can be retreived and stringified with ```analyze``` and ```stringify_analyze```.
+Here the profile:
+
+```python
+  def analyze(target: CallableFunction) -> Node: # here we have our "abtract tree code"
+    ...
+```
+
+For example:
+
+```python
+
+# your behaviour tree, or a sub tree:
+my_func = alias(child=repeat_until(child=action(hello), condition=success_until_zero), name="btree_1")
+
+# retrieve meta information and build a Node tree
+abstract_tree_tree_1 = analyze(my_func) 
+
+# output the tree:
+print(stringify_analyze(abstract_tree_tree_1))
+```
+
+This should print:
+
+```text
+ --> btree_1:
+     --(child)--> repeat_until:
+         --(condition)--> success_until_zero:
+         --(child)--> action:
+                      target: hello
+```
+
+
+Note about action and condition method:
+
+ - you could use sync or async function
+ - you could specify a return value with SUCCESS or FAILURE
+ - function with no return value will be evaluated as FAILURE until you decorate them with a `always_success`or `always_failure`
+
+See this [example/tutorial_1.py](https://raw.githubusercontent.com/geronimo-iia/async-btree/master/examples/tutorial_1.py) for more information.

async_btree-1.3.0/async_btree/__init__.py

@@ -0,0 +1,67 @@
+"""Declare async btree api."""
+
+from .analyze import Node, analyze, stringify_analyze
+from .control import decision, fallback, repeat_until, selector, sequence
+from .decorator import (
+    alias,
+    always_failure,
+    always_success,
+    decorate,
+    ignore_exception,
+    inverter,
+    is_failure,
+    is_success,
+    retry,
+    retry_until_failed,
+    retry_until_success,
+)
+from .definition import (
+    FAILURE,
+    SUCCESS,
+    AsyncInnerFunction,
+    CallableFunction,
+    ControlFlowException,
+    NodeMetadata,
+    node_metadata,
+)
+from .leaf import action, condition
+from .parallele import parallele
+from .runner import BTreeRunner
+from .utils import afilter, amap, run
+
+__all__ = [
+    'Node',
+    'analyze',
+    'stringify_analyze',
+    'decision',
+    'fallback',
+    'repeat_until',
+    'selector',
+    'sequence',
+    'alias',
+    'always_failure',
+    'always_success',
+    'ignore_exception',
+    'decorate',
+    'inverter',
+    'is_failure',
+    'is_success',
+    'retry',
+    'retry_until_failed',
+    'retry_until_success',
+    'FAILURE',
+    'SUCCESS',
+    'AsyncInnerFunction',
+    'CallableFunction',
+    'ExceptionDecorator',
+    'NodeMetadata',
+    'node_metadata',
+    'ControlFlowException',
+    'action',
+    'condition',
+    'parallele',
+    'afilter',
+    'amap',
+    'run',
+    'BTreeRunner',
+]

async_btree-1.3.0/async_btree/analyze.py

@@ -0,0 +1,125 @@
+"""Analyze definition."""
+from inspect import getclosurevars
+from typing import Any, List, NamedTuple, Optional, Tuple, no_type_check
+
+from .definition import CallableFunction, get_function_name, get_node_metadata
+
+__all__ = ["analyze", "stringify_analyze", "Node"]
+
+_DEFAULT_EDGES = ['child', 'children', '_child', '_children']
+
+
+class Node(NamedTuple):
+    """Node aggregate node definition implemented with NamedTuple.
+
+    A Node is used to keep information on name, properties, and relations ship
+    between a hierachical construct of functions.
+    It's like an instance of NodeMetadata.
+
+    Attributes:
+        name (str): named operation.
+        properties (List[Tuple[str, Any]]): a list of tuple (name, value) for definition.
+        edges (List[Tuple[str, List[Any]]]): a list of tuple (name, node list) for
+            definition.
+
+    Notes:
+        Edges attribut should be edges: ```List[Tuple[str, List['Node']]]```
+        But it is impossible for now, see [mypy issues 731](https://github.com/python/mypy/issues/731)
+    """
+
+    name: str
+    properties: List[Tuple[str, Any]]
+    # edges: List[Tuple[str, List['Node']]]
+    # https://github.com/python/mypy/issues/731
+    edges: List[Tuple[str, List[Any]]]
+
+    def __str__(self):
+        return stringify_analyze(target=self)
+
+
+def _get_target_propertie_name(value):
+    if value and callable(value):
+        return (
+            get_node_metadata(target=value).name
+            if hasattr(value, "__node_metadata")
+            else get_function_name(target=value)
+        )
+    return value
+
+
+def _analyze_target_edges(edges):
+    if edges:
+        # it could be a collection of node or a single node
+        return list(map(analyze, edges if hasattr(edges, "__iter__") else [edges]))
+    return None
+
+
+# pylint: disable=protected-access
+@no_type_check  # it's a shortcut for hasattr ...
+def analyze(target: CallableFunction) -> Node:
+    """Analyze specified target and return a Node representation.
+
+    Args:
+        target (CallableFunction): async function to analyze.
+
+    Returns:
+        (Node): a node instance representation of target function
+    """
+
+    nonlocals = getclosurevars(target).nonlocals
+
+    def _get_nonlocals_value_for(name):
+        return nonlocals.get(name, None)
+
+    def _analyze_property(p):
+        """Return a tuple (name, value) or (name, function name) as property."""
+        value = _get_nonlocals_value_for(name=p)
+        return p.lstrip('_'), _get_target_propertie_name(value=value)
+
+    def _analyze_edges(egde_name):
+        """Lookup children node from egde_name local var."""
+        edges = _get_nonlocals_value_for(name=egde_name)
+        return (egde_name.lstrip('_'), _analyze_target_edges(edges=edges))
+
+    if hasattr(target, "__node_metadata"):
+        node = get_node_metadata(target=target)
+        return Node(
+            name=node.name,
+            properties=list(map(_analyze_property, node.properties)) if node.properties else [],
+            edges=list(filter(lambda p: p is not None, map(_analyze_edges, node.edges or _DEFAULT_EDGES))),
+        )
+
+    # simple function
+    return Node(
+        name=get_function_name(target=target), properties=list(map(_analyze_property, nonlocals.keys())), edges=[]
+    )
+
+
+def stringify_analyze(target: Node, indent: int = 0, label: Optional[str] = None) -> str:
+    """Stringify node representation of specified target.
+
+    Args:
+        target (CallableFunction): async function to analyze.
+        indent (int): level identation (default to zero).
+        label (Optional[str]): label of current node (default None).
+
+    Returns:
+        (str): a string node representation.
+    """
+    _ident = '    '
+    _space = f'{_ident * indent} '
+    result: str = ''
+    if label:
+        result += f'{_space}--({label})--> {target.name}:\n'
+        _space += f"{_ident}{' ' * len(label)}"
+    else:
+        result += f'{_space}--> {target.name}:\n'
+
+    for k, v in target.properties:
+        result += f'{_space}    {k}: {v}\n'
+
+    for _label, children in target.edges:
+        if children:
+            for child in children:
+                result += stringify_analyze(target=child, indent=indent + 1, label=_label)
+    return result