m-strat 0.0.2__tar.gz

m_strat-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pharez Vitalis
+
+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.

m_strat-0.0.2/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: m_strat
+Version: 0.0.2
+Summary: A Directed Acyclic Graph Automated Machine Learning Tool using Entity-Component Systems concepts.
+Author-email: Pharez Vitalis <orcid.conceded130@passinbox.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: datasets
+Requires-Dist: dearpygui
+Requires-Dist: loguru
+Requires-Dist: numpy
+Requires-Dist: omegaconf
+Requires-Dist: pandas
+Requires-Dist: rapidfuzz
+Requires-Dist: scikit-learn
+Requires-Dist: torch
+Dynamic: license-file
+
+# m-strat
+
+This project was done by Pharez Vitalis for a Master's of AI at Queen Mary's University of London.
+
+Please [Give me some feedback!](https://forms.gle/sw6MmfX8j3cNiwi9A), the docs are available [here]( https://m-strat-e0776b.gitlab.io/m_strat.html)
+
+# Project Description
+The project represents the implementation of an AutoML GUI system with DAGs fusing with the Entity-Component System framework implemented in python.  The project inspirations were drawn from the idea of "What would a game engine to game developer look like for an ML developer?". A system where a developer can extend and alter components in order to produce more complex ML algorithms but also, able to lean into existing systems to fill in gaps in their knowledge.
+
+# Benefits and Architechture
+The project is in pre-alpha concept of what is being dubbed a Machine Intelligence Learning Environment (MILE). The system is designed for rapid ML prototyping and works under the followoing core ethos':
+1. **State agnostice processing**: There is a main data pipeline called "context" which keeps the current running variables, and node_params which only show the parameterised running of the current node. By using this operational system the nodes remains independent and very reuasable across different projects.
+2. **Fully Moddable**: The project is designed under a tenant of glassboxing, so that you the user can create your own Nodes within the AutoML graph simply and easily. And because you are using open source code with open source blueprints, there is a glass sandbox of alterations that can be done to your project, you could even go into the code and write your own execution system and your own custom templates!
+3. **Rapid Prototyping**: Create Models quickly and on the Fly using Pipeline features from both PyTorch and SkLearn's libraries using yaml files only! Plug in a url and a local project location and download datasets from HF and anywhere easily. Don't like the way something works? Copy it and change it your way!
+
+#### Note: A full manual is supplied in **user_manual.md**
+
+## Setup and Installation
+1. Download and extract the project if it is in a zip folder.
+2. Open a command window in the root project folder (in `m_strat` **NOT** 'm_strat/m_strat'!)
+3. `pip install .` does a standard installation. `pip install -e .` Is recommended for developers
+   The `-e` flag means editable, this allows the project to customised at source without needing to reinstall the package
+4. to open the gui now, type in a command window anywhere `m_strat gui`  your GUI should now open!
+5. you can also do `m_strat init` or any standard command using the command line interface yourself
+ 
+# Usage
+Once the project is installed using `pip install .`, you can launch the app in command terminal by simply typing `m_strat` anywhere.
+
+
+
+## Libraries
+- **Loguru**: Was used because it is a simple, well-designed logging system. You can use the observer class to help you make simple attachers in api/logger, but you don't have to and you can attach your own stuff.Additionally, when using blueprints it is recommended that you use loguru, which will log to the observers created by m-strat
+- **DearPyGui**: Rescued my project when I lost faith in coding GUIs in python! The OOTB Node Space really helped me somewhat land this thing, their use of GPU based rending using C++ bridging is most well implemented.
+- **OmegaConf**: A comprehensive but simple to use library that does indeed elegantly do yaml. 
+- **RapidFuzz**: Had a query text problem, remembered  a library I used and, to be honest very straightforward.
+- **PyTorch, Pandas, NumPy & Scikit-learn**: This is ML, of course they are here!
+
+### Package Citations
+```bibtex
+@Misc{Yadan2019Hydra,
+  author =       {Omry Yadan},
+  title =        {Hydra - A framework for elegantly configuring complex applications},
+  howpublished = {Github},
+  year =         {2019},
+  url =          {https://github.com/facebookresearch/hydra}
+}
+
+@misc{DearPyGui,
+  author = {Hoffstadt, Jonathan and Cothren, Preston},
+  title = {Dear PyGui: A fast and powerful Graphical User Interface Toolkit for Python},
+  year = {2026},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  howpublished = {\url{https://github.com/hoffstadt/DearPyGui}},
+}
+
+@inproceedings{paszke2019pytorch,
+  title={PyTorch: An Imperative Style, High-Performance Deep Learning Library},
+  author={Paszke, Adam and Gross, Sam and Massa, Francisco and Lerer, Adam and Bradbury, James and Chanan, Gregory and Killeen, Trevor and Lin, Zeming and Gimelshein, Natalia and Antiga, Luca and Desmaison, Alban and K{\"o}pf, Andreas and Yang, Edward and DeVito, Zachary and Raison, Martin and Tejani, Alykhan and Chilamkurthy, Sasank and Steiner, Benoit and Fang, Lu and Bai, Junjie and Chintala, Soumith},
+  booktitle={Advances in Neural Information Processing Systems (NeurIPS)},
+  pages={8024--8035},
+  year={2019}
+}
+
+@article{scikit-learn,
+ title={Scikit-learn: Machine Learning in {P}ython},
+ author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
+ journal={Journal of Machine Learning Research},
+ volume={12},
+ pages={2825--2830},
+ year={2011}
+}
+
+@inproceedings{lhoest-etal-2021-datasets,
+  title = {Datasets: A Community Library for Natural Language Processing},
+  author = {Lhoest, Quentin and Villanova del Moral, Albert and Jernite, Yacine and Thakur, Abhishek and von Platen, Patrick and Patil, Suraj and Chaumond, Julien and Moro, Mariama and Sutawika, Julien},
+  year = {2021},
+  publisher = {Association for Computational Linguistics},
+  booktitle = {Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing: System Demonstrations},
+  pages = {175--184},
+  url = {https://aclanthology.org/2021.emnlp-demo.21}
+}
+
+@software{max_bachmann_rapidfuzz,
+  author       = {Max Bachmann},
+  title        = {rapidfuzz/RapidFuzz},
+  publisher    = {Zenodo},
+  doi          = {10.5281/zenodo.15133267},
+  url          = {https://doi.org/10.5281/zenodo.15133267}
+}
+
+@Article{harris2020array,
+  title = {Array programming with {NumPy}},
+  author = {Charles R. Harris and K. Jarrod Millman and St{\'{e}}fan J. van der Walt and Ralf Gommers and Pauli Virtanen and David Cournapeau and Eric Wieser and Julian Taylor and Sebastian Berg and Nathaniel J. Smith and Robert Kern and Matti Picus and Stephan Hoyer and Marten H. van Kerkwijk and Matthew Brett and Allan Haldane and Jaime Fern{\'{a}}ndez del R{\'{i}}o and Mark Wiebe and Pearu Peterson and Pierre G{\'{e}}rard-Marchant and Kevin Sheppard and Tyler Reddy and Warren Weckesser and Hameer Abbasi and Christoph Gohlke and Travis E. Oliphant},
+  year = {2020},
+  month = sep,
+  journal = {Nature},
+  volume = {585},
+  number = {7825},
+  pages = {357--362},
+  doi = {10.1038/s41586-020-2649-2},
+  publisher = {Springer Science and Business Media {LLC}},
+  url = {https://doi.org/10.1038/s41586-020-2649-2}
+}
+
+@software{reback2020pandas,
+  author       = {The pandas development team},
+  title        = {pandas-dev/pandas: Pandas},
+  month        = feb,
+  year         = 2020,
+  publisher    = {Zenodo},
+  version      = {latest},
+  doi          = {10.5281/zenodo.3509134},
+  url          = {https://doi.org/10.5281/zenodo.3509134}
+}
+```

m_strat-0.0.2/m_strat/__init__.py

@@ -0,0 +1 @@
+# Init

m_strat-0.0.2/m_strat/api/__init__.py

@@ -0,0 +1 @@
+# init

m_strat-0.0.2/m_strat/api/dag/__init__.py

@@ -0,0 +1,4 @@
+from .blueprint_register import *
+from .executor import *
+from .graph_manager import *
+from .node import *

m_strat-0.0.2/m_strat/api/dag/blueprint_register.py

@@ -0,0 +1,197 @@
+import importlib.util
+import inspect
+import json
+import os
+
+from m_strat.api.dag.node import BlueprintNode
+from m_strat.api.logger import m_log
+
+
+class BlueprintRegister:
+    """Manages Blueprint Nodes in a project"""
+
+    def __init__(self, meta_file_path: str = "configs/bp_files_meta.jsonl"):
+        self.blueprints = {}
+        self.schemas = {}
+        self.files_found = []
+
+        if meta_file_path:
+            self.load_from_meta_file(meta_file_path)
+        self.meta_file_path = meta_file_path
+
+    def register_node(
+        self, name: str, func: callable, schema: dict, overwrite: bool = True
+    ):
+        """Adds a method to the project registry
+        Args:
+            name (str): The new name of the blueprint node being created (can be given via BlueprintNode decorator)
+            func (callable): The function that will be used to execute the node logic
+            schema (dict[str, type]): Used to guide the UI and create an automated form in the application, not enforced
+            overwrite (bool, optional): Allows a node to be overwritten if the name already exists. Defaults to True.
+        """
+        assert overwrite or self.blueprints.get(name, None) is None, (
+            f"blueprint of '{name}' already exists, overwrite not allowed"
+        )
+        self.blueprints[name] = func
+        self.schemas[name] = schema
+
+    def unregister_node(self, name: str):
+        """Remove a node from the registry by name
+        Returns:
+           tuple[dict,dict] : blueprint callable and schema respectively
+        """
+        return (self.blueprints.pop(name, None), self.schemas.pop(name, None))
+
+    def get_blueprint(self, name: str):
+        """Get the callable of a blueprint by name"""
+        return self.blueprints.get(name, None)
+
+    def refresh_blueprints(self):
+        self.blueprints = {}
+        self.schemas = {}
+        old_files_found = list(self.files_found)
+        self.files_found = []
+        for f in old_files_found:
+            self.add_from_file(f)
+
+    def save_meta_file(self, meta_file_path="configs/bp_files_meta.jsonl"):
+        """Generates a jsonl file of where all the blueprints were retrieved from, so they can be loaded easily
+        Args:
+            meta_file_path (str, optional): relative path of wheree this generated file will save. Defaults to "configs/bp_files_meta.jsonl".
+        """
+        if not self.files_found:
+            m_log.info("Attempted to save blueprints, but no blueprints registered")
+            return
+        with open(meta_file_path, "w", encoding="utf-8") as meta_f:
+            meta_f.writelines(
+                json.dumps(bp_file_path) + "\n"
+                for bp_file_path in set(self.files_found)
+            )
+        m_log.info(f"Blueprint data saved {meta_file_path}")
+
+    def load_from_meta_file(self, meta_file_path: str | None = None):
+        """Loads and use each line as a path to retrieve saved blueprint reference from py files .
+        Args:
+            meta_file_path (str, optional): The path where the meta file resides. Defaults to "configs/bp_files_meta.jsonl".
+        Returns:
+           list[str] : Returns a list of all the names of the blueprints that were added
+        """
+        m_log.info("Loading Blueprint Configuration Data...")
+        if meta_file_path is None:
+            meta_file_path = self.meta_file_path
+        if not os.path.exists(meta_file_path):
+            m_log.warning(f"bp_reg: path does not exist:: {meta_file_path}")
+            return []
+        added = []
+        with open(meta_file_path, "r", encoding="utf8") as meta_f:
+            for i, line in enumerate(meta_f):
+                if not line.strip():
+                    continue
+                try:
+                    next_path = json.loads(line.strip())
+                    added.extend(self.add_from_file(next_path))
+                except (OSError, ValueError, json.JSONDecodeError) as e:
+                    m_log.warning(
+                        f"Line at {i} in {meta_file_path} failed to read: {e}"
+                    )
+        return added
+
+    def get_schema(self, name: str):
+        """Gets the (dict[str,type]) schema given a name of a Blueprint Node"""
+        return self.schemas.get(name, None)
+
+    def add_from_file(self, file_path: str):
+        """uses importlib to check for any Blueprint Nodes and attempts to add them to the system
+        Args:
+            file_path (str): relative path of the .py blueprint file resides
+        Returns:
+            list[str] : Returns a list of all the names of the blueprints that were added
+        """
+        if not os.path.exists(file_path):
+            m_log.warning(f"bp_reg: path does not exist:: {file_path}")
+            return []
+
+        module_name = os.path.splitext(os.path.basename(file_path))[0]
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        added = []
+        assert (
+            spec is not None and spec.loader
+        ), f"""Provided file does not have a spec or spec loader: ||{file_path} ||
+            This can happen because:
+            1. If the file exstension is wrong (not .py)
+            2. File permission issues such as file locked (in use elsewhere e.g )
+            3. Unfriendly path characters: path contains unusual unicode characters or file name is not python friendly
+            4. Some issue which I simply have not thought of in this moment.
+            """
+        module = importlib.util.module_from_spec(spec)
+        module.BlueprintNode = BlueprintNode
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            # flagrantly assume the error is because the module should not be run like this!
+            m_log.debug(
+                f"Spec Loader did not like something when bp register used exec_module (can ignore typically): {e}"
+            )
+
+        for _, obj in inspect.getmembers(module, inspect.isfunction):
+            if getattr(obj, "__is_m_strat_node__", False):
+                self.register_node(
+                    obj.__m_strat_node_name__, obj, obj.__m_strat_node_schema__
+                )
+                added.append(obj.__m_strat_node_name__)
+
+        if len(added) > 0:
+            self.files_found.append(file_path)
+        return added
+
+    def add_from_folder(self, folder_path, add_subfolders=True):
+        """
+            From a directory, adds all Blueprint Nodes to the register
+        Args:
+            folder_path (str): The relative directory path
+            add_subfolders (bool, optional): Whether to add Blueprint Nodes from subdirectories (of any depth) . Defaults to True.
+        Returns:
+            list[str] : Returns a list of all the names of the blueprints that were added
+        """
+        if not os.path.isdir(folder_path):
+            m_log.warning(f"bp_reg: path does not exist:: {folder_path}")
+            return []
+        added_nodes = []
+        m_log.info(f"Adding folder blueprint folder: {folder_path}")
+        if add_subfolders:
+            for root, _, files in os.walk(folder_path):
+                for f_name in files:
+                    if f_name.endswith(".py") and not f_name.startswith("__"):
+                        full_path = os.path.join(root, f_name)
+                        next_added = []
+                        try:
+                            next_added = self.add_from_file(full_path)
+                        except Exception as e:
+                            m_log.error(
+                                f"Blueprint tried to add Blueprints from |{f_name}| in directory |{root}| but failed: \n {e} \n{'*' * 12}\n ...Skipping!"
+                            )
+                            continue
+
+                        added_nodes.extend(next_added)
+        else:
+            for f_name in os.listdir(folder_path):
+                if f_name.endswith(".py") and not f_name.startswith("__"):
+                    full_path = os.path.join(folder_path, f_name)
+                    if os.path.isfile(full_path):
+                        added_nodes.extend(self.add_from_file(full_path))
+        m_log.info(
+            f"Finished adding blueprint director, {len(added_nodes)} blueprint(s) found"
+        )
+        return added_nodes
+
+    def get_all_blueprints(self):
+        """Copies the blueprint callable dictionary, returning all blueprints
+        NB: Blueprints are given by reference, modifications will alter them!
+        """
+        return dict(self.blueprints)
+
+    def get_all_schemas(self):
+        """Copies the schema dictionary, returning all blueprint schemas
+        NB: Blueprints are given by reference, modifications will alter them!
+        """
+        return dict(self.schemas)

m_strat-0.0.2/m_strat/api/dag/executor.py

@@ -0,0 +1,34 @@
+from m_strat.api.logger import m_log
+
+_EXECUTORS = {}
+
+
+# Defines an exectuion method for Node system. Must have (targetnodes, init_context) as arguments. Must return context
+# name muse be unique
+def Executor(name: str):
+    def decorator(func):
+        assert _EXECUTORS.get(name, None) is None, f"Executor {name} already exists"
+        _EXECUTORS[name] = func
+        return func
+
+    return decorator
+
+
+# Standard linear-non parallelised running, executes in same thread without modification
+@Executor(name="Sequential")
+def execute_sequential(target_nodes: list[tuple], init_context: dict):
+    context = init_context
+    m_log.info("Started Sequential running")
+    for func, params, node_info in target_nodes:
+        m_log.debug(f"Running Node {node_info.id}")
+        try:
+            context = func(context, params)
+        except Exception as e:
+            m_log.error(
+                f"Pipeline execution failed at '{node_info.id}' using blueprint '{node_info.blueprint_name}':\n {e}"
+            )
+            raise  # NB you should always raiserrors when making your own Executor!!
+        m_log.debug(f"Node{node_info.id} Completed")
+
+    m_log.info(f"Finished Executing {len(target_nodes)} node(s)")
+    return context

m_strat-0.0.2/m_strat/api/dag/graph_manager.py

@@ -0,0 +1,232 @@
+import json
+import os
+from collections import defaultdict, deque
+from dataclasses import asdict
+
+from m_strat.api.project_management.wrappers import Serializable
+
+from .node import ExecutionNode
+
+
+class GraphManager(Serializable):
+    """Manages a single DAG which is used to build a ML pipeline from Blueprint Nodes"""
+
+    def __init__(
+        self,
+        name: str,
+        load_path: str | None = None,
+        load: bool = False,
+        dir: str = "exec_graphs",
+    ):
+        """Instansiates a Graphmanager object used to manage a DAG
+        Args:
+            name (str): The designated label of this DAG
+            load_path (str, optional): Path to json config . Defaults to None.
+            load (bool, optional): If true attemps to load the graph by name or load path. Defaults to False.
+            dir (str, optional): Path to where this graph is stored. Defaults to "exec_graphs".
+
+        Raises:
+            ValueError: if no name or load_path is supplied and load is true as no data can be loaded.
+        """
+        self.nodes = {"start": ExecutionNode("start", "", "")}
+        self.edges = defaultdict(list)
+        self.name = name
+        self.dir = dir
+        if load and (name or load_path):
+            self.load(name=name, load_path=load_path)
+        elif load:
+            raise ValueError("GraphManager cannot load without a valid graph name")
+
+    @staticmethod
+    def get_file_path(name: str, dir: str):
+        """From the name and directory, returns what the graph data file should be"""
+        return os.path.join(dir, f"gm_{name}.json")
+
+    @staticmethod
+    def get_name_from_filename(path: str):
+        """if given a standardised graph data file, extracts the name of the graph"""
+        base_name: str = os.path.splitext(os.path.basename(path))[0]
+        return base_name[3:]
+
+    def create_add_new_node(self, node_id: str, blueprint_name: str, param_id: str):
+        """From data supplied, creates an ExecutionNode and adds it to the graph
+        Args:
+            node_id (str): human readable name of node
+            blueprint_name (str): name of the blueprint in blueprint Register
+            param_id (str): name of node params from paramater manager
+        """
+        new_node = ExecutionNode(
+            id=node_id, blueprint_name=blueprint_name, param_id=param_id
+        )
+        self.add_node(new_node)
+
+    def add_node(self, new_node: ExecutionNode):
+        """Adds a node to the graph"""
+        assert self.nodes.get(new_node.id, None) is None, "Node Already exists"
+        self.nodes[new_node.id] = new_node
+
+    def change_node_param_template(self, node_id: str, new_param_id: str):
+        """Changes a node parameter template (i.e. the "params" parsed into the ExecutionNode at runtime)
+        Args:
+            node_id (str): instance name of the node within the DAG
+            new_param_id (str): the new parameter id for the node to use
+        """
+        assert isinstance(new_param_id, str) and new_param_id, (
+            "New Parameter id Invalid"
+        )
+        node = self.nodes.get(node_id, None)
+        assert node is not None, "Node not found"
+        node.param_id = new_param_id
+
+    def remove_node(self, node_id: str):
+        """
+            Removes a node from the DAG (and its edges)
+        Args:
+            node_id(str): the target node to be removed (DAG name not blueprint name!)
+        """
+        assert node_id != "start", (
+            "Cannot Remove or Alter Start Node, alter it's edges, or parse different start point to build_execution instead"
+        )
+        self.edges.pop(node_id, [])
+        self.nodes.pop(node_id)
+        for e_v_lst in self.edges.values():
+            if node_id in e_v_lst:
+                e_v_lst.remove(node_id)
+
+    def add_edge(self, node_from: str, node_to: str):
+        """Connects 2 nodes together, representing execution order
+        Args:
+            node_from (str): Node from which the connection is to be made
+            node_to (str): Node the connection ends at.
+        """
+        assert node_to != "start", "All edges on start node must be outgoing"
+        assert node_from != node_to, "A node cannot have an edge connecting to itself"
+        assert self.nodes.get(node_from, None) is not None, (
+            f"Add Edge From Node {node_from} not present in manager"
+        )
+        assert self.nodes.get(node_to, None) is not None, (
+            f"Add Edge To Node {node_to} not present in manager"
+        )
+        neighbours = self.edges[node_from]
+        if node_to not in neighbours:
+            neighbours.append(node_to)
+
+    def remove_edge(self, node_from: str, node_to: str, allow_inverse: bool = False):
+        """Removes 2 connecting edges of a node, allow inverse checks with the nodes in the opposite direction"""
+        self.edges[node_from].remove(node_to)
+        if allow_inverse:
+            inverse_edge = self.edges.get(node_to, None)
+            if not inverse_edge:
+                return
+            if node_from in inverse_edge:
+                inverse_edge.remove(node_from)
+
+    def get_edges(self):
+        """Gets all edges as a set of  tuples  (of -> from, to) and returns them
+        Returns:
+            set: tuple of (node_from, node_to)
+        """
+        edge_tuples = set()
+        for node_from, neighbours in self.edges.items():
+            for node_to in neighbours:
+                edge_tuples.add((node_from, node_to))
+        return edge_tuples
+
+    def get_nodes(self):
+        """Returns a shallow copy of all nodes"""
+        return dict(self.nodes)
+
+    def get_node(self, node_id: str):
+        """Gets a node via node_id from this dag, returns None if not present"""
+        return self.nodes.get(node_id, None)
+
+    def build_execution(self, start_node_id="start"):
+        """Generates a linear execution of nodes from star_node_id until there are ends
+        Args:
+            start_node_id (str, optional): String of first node_id. Defaults to "start".
+        Returns:
+            list[ExecutionNode]: returns the order of nodes by execution from start->finish
+        NB: Currently does not detect loops, parallelisation is flattened currently.
+        """
+        in_degree = {node_id: 0 for node_id in self.nodes}
+
+        for neighbors in self.edges.values():
+            for n in neighbors:
+                in_degree[n] += 1
+
+        queue = deque([start_node_id])
+        exec_order = []
+
+        while queue:
+            current = queue.popleft()
+
+            exec_order.append(self.nodes.get(current))
+
+            for neighbor in self.edges.get(current, []):
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        return exec_order
+
+    def load(self, name: str | None = None, load_path: str | None = None):
+        """using the load path primarily or the name if not supplied. load selection order: load_path->name->self.name
+        Args:
+            name (str, optional): Name of graph manager. Defaults to None.
+            load_path (str, optional): Path to graph configuration file. Priortised. Defaults to None.
+        """
+        assert load_path is not None or name is not None or self.name is not None, (
+            "At least one identifier required to find the graph manager"
+        )
+        if load_path is None:
+            load_path = self.get_file_path(name, self.dir)
+
+        with open(load_path, "r", encoding="utf-8") as load_file:
+            load_data = json.load(load_file)
+            self.edges = defaultdict(list, load_data["edges"])
+            self.name = load_data["name"] if name is None else name
+            node_data = {}
+            for node_id, exec_dict in load_data["nodes"].items():
+                node_data[node_id] = ExecutionNode(
+                    id=node_id,
+                    blueprint_name=exec_dict["blueprint_name"],
+                    param_id=exec_dict["param_id"],
+                    pos=exec_dict.get("pos", None),
+                )
+            self.nodes = node_data
+
+    def save(self):
+        """using the name of the current graph, generates a name and saves the configuration as json"""
+        save_path = self.get_file_path(self.name, self.dir)
+        save_data = {"edges": self.edges, "name": self.name}
+        save_data["nodes"] = {
+            node_id: asdict(exec_node) for node_id, exec_node in self.nodes.items()
+        }
+        with open(save_path, "w", encoding="utf-8") as save_file:
+            json.dump(save_data, save_file)
+
+    def duplicate(self, new_name=""):
+        """Duplicates the current graph manager into another"""
+        if not new_name:
+            new_name = f"{self.name}_copy"
+        dupe = GraphManager(name=new_name, load=False, dir=self.dir)
+        for n in self.nodes.values():
+            if n.id == "start":
+                if n.pos:
+                    dupe.nodes["start"].pos = list(n.pos)
+                continue
+            n_copy = ExecutionNode(
+                id=n.id,
+                blueprint_name=n.blueprint_name,
+                param_id=n.param_id,
+                pos=list(n.pos) if n.pos else None,
+            )
+            dupe.add_node(n_copy)
+        for node_name, neighbours in self.edges.items():
+            for neigh in neighbours:
+                dupe.add_edge(node_name, neigh)
+        return dupe
+
+    @classmethod
+    def file_type(cls):
+        return "json"