PyDecisionGraph 0.1.0__tar.gz → 0.1.2__tar.gz

pydecisiongraph-0.1.2/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.2
+Name: PyDecisionGraph
+Version: 0.1.2
+Summary: A rule-based decision tree implementation for Python
+Home-page: https://github.com/BolunHan/PyDecisionGraph
+Author: Han Bolun
+Author-email: Han Bolun <Bolun.Han@outlook.com>
+License: MIT
+Project-URL: Homepage, https://github.com/BolunHan/PyDecisionGraph
+Project-URL: Repository, https://github.com/BolunHan/PyDecisionGraph
+Project-URL: Issues, https://github.com/BolunHan/PyDecisionGraph/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
+Provides-Extra: visualization
+Requires-Dist: pyvis; extra == "visualization"
+Requires-Dist: networkx; extra == "visualization"
+
+# PyDecisionGraph
+
+`PyDecisionGraph` is an easy-to-use library to create custom decision trees, primarily designed for trading and financial decision-making. This package helps you build rule-based decision processes and visualize them effectively.
+
+## Installation
+
+To install the package, run:
+
+```bash
+pip install PyDecisionGraph
+```
+
+# Requirements
+
+- Python 3.12 or higher
+
+# Documentation
+
+For detailed documentation, visit https://pydecisiongraph.readthedocs.io/.
+
+# Quick Start
+
+Here is a quick demo on how to use `PyDecisionGraph` for building a decision tree based on various conditions:
+
+```python
+from decision_graph.decision_tree import LogicNode, LOGGER, AttrExpression, LongAction, ShortAction, NoAction, RootLogicNode, LogicMapping
+
+# Mapping of attribute names to their values
+LogicMapping.AttrExpression = AttrExpression
+
+state = {
+    "exposure": 0,  # Current exposure
+    "working_order": 0,  # Current working order
+    "up_prob": 0.8,  # Probability of price going up
+    "down_prob": 0.2,  # Probability of price going down
+    "volatility": 0.24,  # Current market volatility
+    "ttl": 15.3  # Time to live (TTL) of the decision tree
+}
+
+# Root of the logic tree
+with RootLogicNode() as root:
+    # Define root logic mapping with state data
+    with LogicMapping(name='Root', data=state) as lg_root:
+        lg_root: LogicMapping
+
+        # Condition for zero exposure
+        with lg_root.exposure == 0:
+            root: LogicNode
+            with LogicMapping(name='check_open', data=state) as lg:
+                with lg.working_order != 0:
+                    break_point = NoAction()  # No action if there's a working order
+                    lg.break_(scope=lg)  # Exit the current scope
+
+                with lg.volatility > 0.25:  # Check if volatility is high
+                    with lg.down_prob > 0.1:  # Action for down probability
+                        LongAction()
+
+                    with lg.up_prob < -0.1:  # Action for up probability
+                        ShortAction()
+
+        # Condition when TTL is greater than 30
+        with lg_root.ttl > 30:
+            with lg_root.working_order > 0:
+                ShortAction()  # Action to short if working order exists
+            LongAction()  # Always take long action
+            lg_root.break_(scope=lg_root)  # Exit scope
+
+        # Closing logic based on exposure and probabilities
+        with LogicMapping(name='check_close', data=state) as lg:
+            with (lg.exposure > 0) & (lg.down_prob > 0.):
+                ShortAction()  # Short action for positive exposure and down probability
+
+            with (lg.exposure < 0) & (lg.up_prob > 0.):
+                LongAction()  # Long action for negative exposure and up probability
+
+# Visualize the decision tree
+root.to_html()
+
+# Log the evaluation result
+LOGGER.info(root())
+```
+
+## Explanation of the Script:
+
+- LogicNode & LogicMapping:
+    - LogicNode: Represents a node in the decision tree where conditions are evaluated.
+    - LogicMapping: Associates logical conditions with the state (data) used in decision-making.
+
+- State:
+    - A dictionary containing the variables used for decision-making, such as exposure, working_order, up_prob, etc.
+
+- RootLogicNode:
+    - The entry point for the decision tree where all logical decisions are linked.
+
+- Decision Conditions:
+    - Inside each with block, logical conditions are evaluated (e.g., lg.volatility > 0.25, lg.up_prob < -0.1) to determine which action to take.
+    - Actions like LongAction() or ShortAction() are taken based on the conditions.
+
+- Action Handling:
+    - LongAction(), ShortAction(), and NoAction() represent different actions you can trigger in the decision tree based on the conditions.
+
+- Logging:
+    - The result of the tree evaluation is logged using the LOGGER object, which outputs to the console.
+
+- Visualization:
+    - root.to_html() generates an HTML representation of the decision tree for visualization.
+
+# Features
+
+- Easily define custom decision rules.
+- Actionable outcomes like LongAction, ShortAction, and NoAction.
+- Log outputs for debugging and tracking.
+- Visualize decision paths through HTML export.
+
+---
+
+# Contributing
+
+Feel free to fork, submit issues, and create pull requests. Contributions are always welcome!
+
+# License
+
+This project is licensed under the Mozilla Public License 2.0 - see the LICENSE file for details.

pydecisiongraph-0.1.2/PyDecisionGraph.egg-info/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.2
+Name: PyDecisionGraph
+Version: 0.1.2
+Summary: A rule-based decision tree implementation for Python
+Home-page: https://github.com/BolunHan/PyDecisionGraph
+Author: Han Bolun
+Author-email: Han Bolun <Bolun.Han@outlook.com>
+License: MIT
+Project-URL: Homepage, https://github.com/BolunHan/PyDecisionGraph
+Project-URL: Repository, https://github.com/BolunHan/PyDecisionGraph
+Project-URL: Issues, https://github.com/BolunHan/PyDecisionGraph/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
+Provides-Extra: visualization
+Requires-Dist: pyvis; extra == "visualization"
+Requires-Dist: networkx; extra == "visualization"
+
+# PyDecisionGraph
+
+`PyDecisionGraph` is an easy-to-use library to create custom decision trees, primarily designed for trading and financial decision-making. This package helps you build rule-based decision processes and visualize them effectively.
+
+## Installation
+
+To install the package, run:
+
+```bash
+pip install PyDecisionGraph
+```
+
+# Requirements
+
+- Python 3.12 or higher
+
+# Documentation
+
+For detailed documentation, visit https://pydecisiongraph.readthedocs.io/.
+
+# Quick Start
+
+Here is a quick demo on how to use `PyDecisionGraph` for building a decision tree based on various conditions:
+
+```python
+from decision_graph.decision_tree import LogicNode, LOGGER, AttrExpression, LongAction, ShortAction, NoAction, RootLogicNode, LogicMapping
+
+# Mapping of attribute names to their values
+LogicMapping.AttrExpression = AttrExpression
+
+state = {
+    "exposure": 0,  # Current exposure
+    "working_order": 0,  # Current working order
+    "up_prob": 0.8,  # Probability of price going up
+    "down_prob": 0.2,  # Probability of price going down
+    "volatility": 0.24,  # Current market volatility
+    "ttl": 15.3  # Time to live (TTL) of the decision tree
+}
+
+# Root of the logic tree
+with RootLogicNode() as root:
+    # Define root logic mapping with state data
+    with LogicMapping(name='Root', data=state) as lg_root:
+        lg_root: LogicMapping
+
+        # Condition for zero exposure
+        with lg_root.exposure == 0:
+            root: LogicNode
+            with LogicMapping(name='check_open', data=state) as lg:
+                with lg.working_order != 0:
+                    break_point = NoAction()  # No action if there's a working order
+                    lg.break_(scope=lg)  # Exit the current scope
+
+                with lg.volatility > 0.25:  # Check if volatility is high
+                    with lg.down_prob > 0.1:  # Action for down probability
+                        LongAction()
+
+                    with lg.up_prob < -0.1:  # Action for up probability
+                        ShortAction()
+
+        # Condition when TTL is greater than 30
+        with lg_root.ttl > 30:
+            with lg_root.working_order > 0:
+                ShortAction()  # Action to short if working order exists
+            LongAction()  # Always take long action
+            lg_root.break_(scope=lg_root)  # Exit scope
+
+        # Closing logic based on exposure and probabilities
+        with LogicMapping(name='check_close', data=state) as lg:
+            with (lg.exposure > 0) & (lg.down_prob > 0.):
+                ShortAction()  # Short action for positive exposure and down probability
+
+            with (lg.exposure < 0) & (lg.up_prob > 0.):
+                LongAction()  # Long action for negative exposure and up probability
+
+# Visualize the decision tree
+root.to_html()
+
+# Log the evaluation result
+LOGGER.info(root())
+```
+
+## Explanation of the Script:
+
+- LogicNode & LogicMapping:
+    - LogicNode: Represents a node in the decision tree where conditions are evaluated.
+    - LogicMapping: Associates logical conditions with the state (data) used in decision-making.
+
+- State:
+    - A dictionary containing the variables used for decision-making, such as exposure, working_order, up_prob, etc.
+
+- RootLogicNode:
+    - The entry point for the decision tree where all logical decisions are linked.
+
+- Decision Conditions:
+    - Inside each with block, logical conditions are evaluated (e.g., lg.volatility > 0.25, lg.up_prob < -0.1) to determine which action to take.
+    - Actions like LongAction() or ShortAction() are taken based on the conditions.
+
+- Action Handling:
+    - LongAction(), ShortAction(), and NoAction() represent different actions you can trigger in the decision tree based on the conditions.
+
+- Logging:
+    - The result of the tree evaluation is logged using the LOGGER object, which outputs to the console.
+
+- Visualization:
+    - root.to_html() generates an HTML representation of the decision tree for visualization.
+
+# Features
+
+- Easily define custom decision rules.
+- Actionable outcomes like LongAction, ShortAction, and NoAction.
+- Log outputs for debugging and tracking.
+- Visualize decision paths through HTML export.
+
+---
+
+# Contributing
+
+Feel free to fork, submit issues, and create pull requests. Contributions are always welcome!
+
+# License
+
+This project is licensed under the Mozilla Public License 2.0 - see the LICENSE file for details.

pydecisiongraph-0.1.2/PyDecisionGraph.egg-info/SOURCES.txt

@@ -0,0 +1,32 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+./decision_graph/__init__.py
+./decision_graph/decision_tree/__init__.py
+./decision_graph/decision_tree/abc.py
+./decision_graph/decision_tree/collection.py
+./decision_graph/decision_tree/exc.py
+./decision_graph/decision_tree/expression.py
+./decision_graph/decision_tree/node.py
+./decision_graph/logic_group/__init__.py
+./decision_graph/logic_group/base.py
+./decision_graph/logic_group/pending_request.py
+PyDecisionGraph.egg-info/PKG-INFO
+PyDecisionGraph.egg-info/SOURCES.txt
+PyDecisionGraph.egg-info/dependency_links.txt
+PyDecisionGraph.egg-info/not-zip-safe
+PyDecisionGraph.egg-info/requires.txt
+PyDecisionGraph.egg-info/top_level.txt
+decision_graph/__init__.py
+decision_graph/decision_tree/__init__.py
+decision_graph/decision_tree/abc.py
+decision_graph/decision_tree/collection.py
+decision_graph/decision_tree/exc.py
+decision_graph/decision_tree/expression.py
+decision_graph/decision_tree/node.py
+decision_graph/logic_group/__init__.py
+decision_graph/logic_group/base.py
+decision_graph/logic_group/pending_request.py

pydecisiongraph-0.1.2/PyDecisionGraph.egg-info/requires.txt

@@ -0,0 +1,9 @@
+
+[docs]
+sphinx
+sphinx-rtd-theme
+sphinx-autodoc-typehints
+
+[visualization]
+pyvis
+networkx

pydecisiongraph-0.1.2/PyDecisionGraph.egg-info/top_level.txt

@@ -0,0 +1 @@
+decision_graph

pydecisiongraph-0.1.2/README.md

@@ -0,0 +1,123 @@
+# PyDecisionGraph
+
+`PyDecisionGraph` is an easy-to-use library to create custom decision trees, primarily designed for trading and financial decision-making. This package helps you build rule-based decision processes and visualize them effectively.
+
+## Installation
+
+To install the package, run:
+
+```bash
+pip install PyDecisionGraph
+```
+
+# Requirements
+
+- Python 3.12 or higher
+
+# Documentation
+
+For detailed documentation, visit https://pydecisiongraph.readthedocs.io/.
+
+# Quick Start
+
+Here is a quick demo on how to use `PyDecisionGraph` for building a decision tree based on various conditions:
+
+```python
+from decision_graph.decision_tree import LogicNode, LOGGER, AttrExpression, LongAction, ShortAction, NoAction, RootLogicNode, LogicMapping
+
+# Mapping of attribute names to their values
+LogicMapping.AttrExpression = AttrExpression
+
+state = {
+    "exposure": 0,  # Current exposure
+    "working_order": 0,  # Current working order
+    "up_prob": 0.8,  # Probability of price going up
+    "down_prob": 0.2,  # Probability of price going down
+    "volatility": 0.24,  # Current market volatility
+    "ttl": 15.3  # Time to live (TTL) of the decision tree
+}
+
+# Root of the logic tree
+with RootLogicNode() as root:
+    # Define root logic mapping with state data
+    with LogicMapping(name='Root', data=state) as lg_root:
+        lg_root: LogicMapping
+
+        # Condition for zero exposure
+        with lg_root.exposure == 0:
+            root: LogicNode
+            with LogicMapping(name='check_open', data=state) as lg:
+                with lg.working_order != 0:
+                    break_point = NoAction()  # No action if there's a working order
+                    lg.break_(scope=lg)  # Exit the current scope
+
+                with lg.volatility > 0.25:  # Check if volatility is high
+                    with lg.down_prob > 0.1:  # Action for down probability
+                        LongAction()
+
+                    with lg.up_prob < -0.1:  # Action for up probability
+                        ShortAction()
+
+        # Condition when TTL is greater than 30
+        with lg_root.ttl > 30:
+            with lg_root.working_order > 0:
+                ShortAction()  # Action to short if working order exists
+            LongAction()  # Always take long action
+            lg_root.break_(scope=lg_root)  # Exit scope
+
+        # Closing logic based on exposure and probabilities
+        with LogicMapping(name='check_close', data=state) as lg:
+            with (lg.exposure > 0) & (lg.down_prob > 0.):
+                ShortAction()  # Short action for positive exposure and down probability
+
+            with (lg.exposure < 0) & (lg.up_prob > 0.):
+                LongAction()  # Long action for negative exposure and up probability
+
+# Visualize the decision tree
+root.to_html()
+
+# Log the evaluation result
+LOGGER.info(root())
+```
+
+## Explanation of the Script:
+
+- LogicNode & LogicMapping:
+    - LogicNode: Represents a node in the decision tree where conditions are evaluated.
+    - LogicMapping: Associates logical conditions with the state (data) used in decision-making.
+
+- State:
+    - A dictionary containing the variables used for decision-making, such as exposure, working_order, up_prob, etc.
+
+- RootLogicNode:
+    - The entry point for the decision tree where all logical decisions are linked.
+
+- Decision Conditions:
+    - Inside each with block, logical conditions are evaluated (e.g., lg.volatility > 0.25, lg.up_prob < -0.1) to determine which action to take.
+    - Actions like LongAction() or ShortAction() are taken based on the conditions.
+
+- Action Handling:
+    - LongAction(), ShortAction(), and NoAction() represent different actions you can trigger in the decision tree based on the conditions.
+
+- Logging:
+    - The result of the tree evaluation is logged using the LOGGER object, which outputs to the console.
+
+- Visualization:
+    - root.to_html() generates an HTML representation of the decision tree for visualization.
+
+# Features
+
+- Easily define custom decision rules.
+- Actionable outcomes like LongAction, ShortAction, and NoAction.
+- Log outputs for debugging and tracking.
+- Visualize decision paths through HTML export.
+
+---
+
+# Contributing
+
+Feel free to fork, submit issues, and create pull requests. Contributions are always welcome!
+
+# License
+
+This project is licensed under the Mozilla Public License 2.0 - see the LICENSE file for details.

pydecisiongraph-0.1.2/decision_graph/__init__.py

@@ -0,0 +1,16 @@
+__version__ = "0.1.2"
+
+import logging
+import sys
+
+LOGGER = logging.getLogger("DecisionGraph")
+LOGGER.setLevel(logging.INFO)
+
+if not LOGGER.hasHandlers():
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.INFO)  # Set handler level
+    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+    ch.setFormatter(formatter)
+    LOGGER.addHandler(ch)
+
+

pydecisiongraph-0.1.2/decision_graph/decision_tree/__init__.py

@@ -0,0 +1,44 @@
+import logging
+
+from .. import LOGGER
+
+LOGGER = LOGGER.getChild("DecisionTree")
+
+__all__ = [
+    'LOGGER', 'set_logger', 'activate_expression_model', 'activate_node_model',
+    'NodeError', 'TooManyChildren', 'TooFewChildren', 'NodeNotFountError', 'NodeValueError', 'EdgeValueError', 'ResolutionError', 'ExpressFalse', 'ContextsNotFound',
+    'LGM', 'LogicGroup', 'SkipContextsBlock', 'LogicExpression', 'ExpressionCollection', 'LogicNode', 'ActionNode', 'ELSE_CONDITION',
+    'NoAction', 'LongAction', 'ShortAction', 'RootLogicNode', 'ContextLogicExpression', 'AttrExpression', 'MathExpression', 'ComparisonExpression', 'LogicalExpression',
+    'LogicMapping', 'LogicGenerator'
+]
+
+from .exc import *
+from .abc import *
+from .node import *
+from .collection import *
+
+
+def set_logger(logger: logging.Logger):
+    global LOGGER
+    LOGGER = logger
+
+    abc.LOGGER = logger.getChild('abc')
+
+
+def activate_expression_model():
+    import importlib
+    importlib.import_module('decision_graph.decision_tree.expression')
+    importlib.reload(collection)
+    collection.LogicMapping.AttrExpression = AttrExpression
+    collection.LogicGenerator.AttrExpression = AttrExpression
+    # importlib.reload(logic_group)
+
+
+def activate_node_model():
+    import importlib
+
+    importlib.import_module('decision_graph.decision_tree.node')
+    importlib.reload(collection)
+    collection.LogicMapping.AttrExpression = AttrExpression
+    collection.LogicGenerator.AttrExpression = AttrExpression
+    # importlib.reload(logic_group)