graphmdo 0.1.2__tar.gz → 0.2.0__tar.gz

{graphmdo-0.1.2 → graphmdo-0.2.0}/.github/workflows/security.yml

@@ -11,6 +11,21 @@ jobs:
     name: Build
     runs-on: ubuntu-latest
     steps:
+      - name: Free Disk Space (Ubuntu)
+        uses: jlumbroso/free-disk-space@main
+        with:
+          # This might take a few minutes, but it frees up ~30GB
+          tool-cache: false
+          android: true
+          dotnet: true
+          haskell: true
+          large-packages: true
+          docker-images: true
+          swap-storage: true
+
+      - name: Setup Docker
+        uses: docker/setup-buildx-action@v2
+
       - name: Checkout code
         uses: actions/checkout@v3
 

{graphmdo-0.1.2 → graphmdo-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphmdo
-Version: 0.1.2
+Version: 0.2.0
 Summary: A dynamic, graph-driven Multidisciplinary Design Optimization (MDO) framework integrating FalkorDB, OpenMDAO, and multi-fidelity surrogate models.
 Author-email: jultou-raa <64092886+jultou-raa@users.noreply.github.com>, google-labs-jules-bot <161369871+google-labs-jules-bot@users.noreply.github.com>
 License-File: LICENSE
@@ -95,7 +95,8 @@ Once the graph is populated, you can run the optimization workflow. You need to
 
 ```python
 from mdo_framework.core.translator import GraphProblemBuilder
-from mdo_framework.optimization.optimizer import BayesianOptimizer, LocalEvaluator
+from mdo_framework.optimization.optimizer import BayesianOptimizer
+from mdo_framework.core.evaluators import LocalEvaluator
 from mdo_framework.core.topology import TopologicalAnalyzer
 
 # Define tool implementation

{graphmdo-0.1.2 → graphmdo-0.2.0}/README.md

@@ -74,7 +74,8 @@ Once the graph is populated, you can run the optimization workflow. You need to
 
 ```python
 from mdo_framework.core.translator import GraphProblemBuilder
-from mdo_framework.optimization.optimizer import BayesianOptimizer, LocalEvaluator
+from mdo_framework.optimization.optimizer import BayesianOptimizer
+from mdo_framework.core.evaluators import LocalEvaluator
 from mdo_framework.core.topology import TopologicalAnalyzer
 
 # Define tool implementation

{graphmdo-0.1.2 → graphmdo-0.2.0}/docs/api/optimization/optimizer.md

@@ -8,7 +8,7 @@
 
 # LocalEvaluator
 
-::: mdo_framework.optimization.optimizer.LocalEvaluator
+::: mdo_framework.core.evaluators.LocalEvaluator
 
 # RemoteEvaluator
 

{graphmdo-0.1.2 → graphmdo-0.2.0}/docs/user-guide/quick-start.md

@@ -43,7 +43,8 @@ Once the graph is populated, you can run the optimization.
 
 ```python
 from mdo_framework.core.translator import GraphProblemBuilder
-from mdo_framework.optimization.optimizer import BayesianOptimizer, LocalEvaluator
+from mdo_framework.optimization.optimizer import BayesianOptimizer
+from mdo_framework.core.evaluators import LocalEvaluator
 from mdo_framework.core.topology import TopologicalAnalyzer
 
 # 1. Define Tool Implementation

{graphmdo-0.1.2 → graphmdo-0.2.0}/main.py

@@ -1,13 +1,12 @@
+from mdo_framework.core.evaluators import LocalEvaluator
 from mdo_framework.core.translator import GraphProblemBuilder
 from mdo_framework.db.graph_manager import GraphManager
-from mdo_framework.optimization.optimizer import BayesianOptimizer, LocalEvaluator
+from mdo_framework.optimization.optimizer import BayesianOptimizer
 
 
 # --- Sellar Problem Functions ---
 def paraboloid_func(x, y):
-    """
-    f(x, y) = (x-3)**2 + xy + (y+4)**2 - 3
-    """
+    """f(x, y) = (x-3)**2 + xy + (y+4)**2 - 3"""
     f_xy = (x - 3.0) ** 2 + x * y + (y + 4.0) ** 2 - 3.0
     c_xy = x - y
     return {"f_xy": f_xy, "c_xy": c_xy}
@@ -84,7 +83,8 @@ def main():
     try:
         result = optimizer.optimize(n_steps=10, n_init=5)
         print("Optimization Complete.")
-        print("Best Result:", result)
+        print("Best Result:", result["best_parameters"])
+        print("Best Objectives:", result["best_objectives"])
     except Exception as e:
         print(f"Optimization failed: {e}")
 

{graphmdo-0.1.2 → graphmdo-0.2.0}/pyproject.toml

@@ -43,3 +43,13 @@ dev = [
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/mdo_framework", "src/services"]
+
+[tool.coverage.run]
+source = ["."]
+
+[tool.coverage.report]
+omit = [
+    "test/*",
+    "tests/*",
+    "**/__init__.py"
+]

{graphmdo-0.1.2 → graphmdo-0.2.0}/src/mdo_framework/core/components.py

@@ -2,16 +2,16 @@ import openmdao.api as om
 
 
 class ToolComponent(om.ExplicitComponent):
-    """
-    Generic OpenMDAO component that wraps a Python function.
-    """
+    """Generic OpenMDAO component that wraps a Python function."""
 
     def initialize(self):
         self.options.declare("name", types=str, desc="Name of the tool")
         self.options.declare("func", types=object, desc="The function to execute")
         self.options.declare("inputs", types=list, desc="List of input variable names")
         self.options.declare(
-            "outputs", types=list, desc="List of output variable names"
+            "outputs",
+            types=list,
+            desc="List of output variable names",
         )
         self.options.declare(
             "derivatives",
@@ -52,6 +52,7 @@ class ToolComponent(om.ExplicitComponent):
             # If func is: def my_func(x): return {"y": x * 2}
             # This compute block sets outputs["y"] = inputs["x"] * 2
             ```
+
         """
         func = self.options["func"]
         # Prepare inputs as a dictionary
@@ -69,14 +70,13 @@ class ToolComponent(om.ExplicitComponent):
         if len(self.options["outputs"]) == 1:
             output_name = self.options["outputs"][0]
             outputs[output_name] = result
+        elif isinstance(result, dict):
+            for name in self.options["outputs"]:
+                outputs[name] = result[name]
         else:
-            if isinstance(result, dict):
-                for name in self.options["outputs"]:
-                    outputs[name] = result[name]
-            else:
-                # If result is a tuple/list, assume order matches outputs
-                for i, name in enumerate(self.options["outputs"]):
-                    outputs[name] = result[i]
+            # If result is a tuple/list, assume order matches outputs
+            for i, name in enumerate(self.options["outputs"]):
+                outputs[name] = result[i]
 
     def compute_partials(self, inputs, partials):
         if self.options["derivatives"]:

graphmdo-0.2.0/src/mdo_framework/core/evaluators.py

@@ -0,0 +1,33 @@
+from typing import Any
+
+import openmdao.api as om
+
+
+class LocalEvaluator:
+    """Evaluates the design parameters locally using an OpenMDAO Problem instance.
+
+    Args:
+        problem: An instantiated OpenMDAO Problem object.
+
+    """
+
+    def __init__(self, problem: om.Problem):
+        self.problem = problem
+
+    def evaluate(
+        self,
+        parameters: dict[str, Any],
+        objectives: list[str],
+    ) -> dict[str, float]:
+        for name, val in parameters.items():
+            self.problem.set_val(name, val)
+        self.problem.run_model()
+
+        results = {}
+        for obj in objectives:
+            results[obj] = (
+                float(self.problem.get_val(obj)[0])
+                if hasattr(self.problem.get_val(obj), "__iter__")
+                else float(self.problem.get_val(obj))
+            )
+        return results

{graphmdo-0.1.2 → graphmdo-0.2.0}/src/mdo_framework/core/surrogates.py

@@ -4,9 +4,7 @@ from smt.surrogate_models import KPLS, KRG
 
 
 class SMTSurrogate:
-    """
-    Wrapper for SMT surrogate models, supporting single and multi-fidelity.
-    """
+    """Wrapper for SMT surrogate models, supporting single and multi-fidelity."""
 
     def __init__(self, model_type="KRG", multi_fidelity=False):
         self.model_type = model_type
@@ -20,14 +18,14 @@ class SMTSurrogate:
         x_lf: np.ndarray = None,
         y_lf: np.ndarray = None,
     ):
-        """
-        Trains the surrogate model.
+        """Trains the surrogate model.
 
         Args:
             xt: High-fidelity training inputs.
             yt: High-fidelity training outputs.
             x_lf: Low-fidelity training inputs (for multi-fidelity).
             y_lf: Low-fidelity training outputs (for multi-fidelity).
+
         """
         n_dims = xt.shape[1]
 
@@ -48,7 +46,9 @@ class SMTSurrogate:
                 # Default n_comp=1 in SMT KPLS.
                 n_comp = 1
                 self.model = KPLS(
-                    theta0=[1e-2] * n_comp, n_comp=n_comp, print_global=False
+                    theta0=[1e-2] * n_comp,
+                    n_comp=n_comp,
+                    print_global=False,
                 )
             else:
                 raise ValueError(f"Unknown model type: {self.model_type}")

{graphmdo-0.1.2 → graphmdo-0.2.0}/src/mdo_framework/core/topology.py

@@ -2,18 +2,17 @@ from typing import Any
 
 
 class TopologicalAnalyzer:
-    """
-    Analyzes a KADMOS/CMDOWS-style graph schema recursively to extract
+    """Analyzes a KADMOS/CMDOWS-style graph schema recursively to extract
     the independent design variables and sub-graph components required
     to evaluate a specific target output.
     """
 
     def __init__(self, schema: dict[str, Any]):
-        """
-        Initializes the analyzer with the provided graph schema.
+        """Initializes the analyzer with the provided graph schema.
 
         Args:
             schema: Dictionary representing the full graph tools and variables.
+
         """
         self.schema = schema
         self.tools = {t["name"]: t for t in schema.get("tools", [])}
@@ -28,10 +27,10 @@ class TopologicalAnalyzer:
                 self.var_sources[out_var].append(tool_name)
 
     def resolve_dependencies(
-        self, target_outputs: list[str]
+        self,
+        target_outputs: list[str],
     ) -> tuple[list[str], list[dict[str, Any]]]:
-        """
-        Recursively resolve all dependencies needed to compute target_outputs.
+        """Recursively resolve all dependencies needed to compute target_outputs.
         Returns a tuple containing:
             1. A list of independent design variables (inputs without any tool source).
             2. A list of tool configurations required for execution.
@@ -67,9 +66,7 @@ class TopologicalAnalyzer:
         return design_vars, req_tools
 
     def extract_parameters(self, design_vars: list[str]) -> list[dict[str, Any]]:
-        """
-        Formats design variables into Ax-Platform ready parameter structures.
-        """
+        """Formats design variables into Ax-Platform ready parameter structures."""
         parameters = []
         for var_name in design_vars:
             var_data = self.variables.get(var_name)
@@ -84,7 +81,7 @@ class TopologicalAnalyzer:
                         "type": "choice",
                         "values": var_data.get("choices", []),
                         "value_type": var_data.get("value_type", "float"),
-                    }
+                    },
                 )
             else:
                 parameters.append(
@@ -96,7 +93,7 @@ class TopologicalAnalyzer:
                             var_data.get("upper", 1.0),
                         ],
                         "value_type": var_data.get("value_type", "float"),
-                    }
+                    },
                 )
 
         return parameters

{graphmdo-0.1.2 → graphmdo-0.2.0}/src/mdo_framework/core/translator.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 import openmdao.api as om
 
@@ -6,16 +7,14 @@ from mdo_framework.core.components import ToolComponent
 
 
 class GraphProblemBuilder:
-    """
-    Builds an OpenMDAO Problem from a graph schema dictionary.
-    """
+    """Builds an OpenMDAO Problem from a graph schema dictionary."""
 
     def __init__(self, schema: dict[str, Any]):
-        """
-        Initializes the builder with the given graph schema.
+        """Initializes the builder with the given graph schema.
 
         Args:
             schema: Dictionary representing tools, inputs, and outputs.
+
         """
         """
         Args:
@@ -25,14 +24,14 @@ class GraphProblemBuilder:
         self.schema = schema
 
     def build_problem(self, tool_registry: dict[str, Callable]) -> om.Problem:
-        """
-        Constructs an OpenMDAO problem from the parsed schema.
+        """Constructs an OpenMDAO problem from the parsed schema.
 
         Args:
             tool_registry: Mapping of tool names to Python callables.
 
         Returns:
             An instantiated OpenMDAO Problem object.
+
         """
         """
         Constructs and sets up the OpenMDAO problem.

{graphmdo-0.1.2 → graphmdo-0.2.0}/src/mdo_framework/db/client.py

@@ -4,22 +4,18 @@ from falkordb import FalkorDB
 
 
 class FalkorDBClient:
-    """
-    Singleton class to manage the connection to the FalkorDB database.
-    """
+    """Singleton class to manage the connection to the FalkorDB database."""
 
     _instance = None
 
     def __new__(cls):
         if cls._instance is None:
-            cls._instance = super(FalkorDBClient, cls).__new__(cls)
+            cls._instance = super().__new__(cls)
             cls._instance._initialize()
         return cls._instance
 
     def _initialize(self):
-        """
-        Initializes the FalkorDB connection.
-        """
+        """Initializes the FalkorDB connection."""
         host = os.getenv("FALKORDB_HOST", "localhost")
         port = int(os.getenv("FALKORDB_PORT", 6379))
         self.client = FalkorDB(host=host, port=port)
@@ -27,15 +23,10 @@ class FalkorDBClient:
         self.graph = self.client.select_graph(self.graph_name)
 
     def get_graph(self):
-        """
-        Returns the graph object for executing queries.
-        """
+        """Returns the graph object for executing queries."""
         return self.graph
 
     def close(self):
-        """
-        Closes the connection.
-        """
+        """Closes the connection."""
         # FalkorDB client handles connection pooling, but explicit close might be needed
         # depending on the implementation. For now, we rely on the client's management.
-        pass

{graphmdo-0.1.2 → graphmdo-0.2.0}/src/mdo_framework/db/graph_manager.py

@@ -42,6 +42,7 @@ class GraphManager:
             gm.add_variable("wing_span", value=10.0, lower=5.0, upper=15.0, param_type="range", description="Wing span variable")
             gm.add_variable("material", value="aluminum", choices=["aluminum", "composite"], param_type="choice", value_type="str")
             ```
+
         """
         props = {
             "name": name,
@@ -78,6 +79,7 @@ class GraphManager:
             gm.add_tool("CFD_Solver", fidelity="high", version="1.2.0")
             gm.add_tool("Vortex_Lattice", fidelity="low")
             ```
+
         """
         props = {"name": name, "fidelity": fidelity}
         props.update(kwargs)
@@ -101,13 +103,15 @@ class GraphManager:
             ```python
             gm.connect_tool_to_output("CFD_Solver", "drag_coefficient")
             ```
+
         """
         query = """
         MATCH (t:Tool {name: $tool_name}), (v:Variable {name: $variable_name})
         MERGE (t)-[:OUTPUTS]->(v)
         """
         self.graph.query(
-            query, params={"tool_name": tool_name, "variable_name": variable_name}
+            query,
+            params={"tool_name": tool_name, "variable_name": variable_name},
         )
 
     def connect_input_to_tool(self, variable_name: str, tool_name: str):
@@ -121,13 +125,15 @@ class GraphManager:
             ```python
             gm.connect_input_to_tool("wing_span", "CFD_Solver")
             ```
+
         """
         query = """
         MATCH (v:Variable {name: $variable_name}), (t:Tool {name: $tool_name})
         MERGE (v)-[:INPUTS_TO]->(t)
         """
         self.graph.query(
-            query, params={"variable_name": variable_name, "tool_name": tool_name}
+            query,
+            params={"variable_name": variable_name, "tool_name": tool_name},
         )
 
     def get_tools(self) -> list[dict[str, Any]]:
@@ -177,8 +183,7 @@ class GraphManager:
         return [r[0] for r in result.result_set]
 
     def get_graph_schema(self) -> dict[str, Any]:
-        """
-        Returns a serializable dictionary representing the entire graph structure.
+        """Returns a serializable dictionary representing the entire graph structure.
 
         Returns:
             A dictionary containing 'tools' and 'variables' lists defining the topology.
@@ -188,6 +193,7 @@ class GraphManager:
             schema = gm.get_graph_schema()
             print(schema["tools"][0]["name"])
             ```
+
         """
         variables = self.get_variables()
 
@@ -214,7 +220,7 @@ class GraphManager:
                     "fidelity": tool_node.properties.get("fidelity", "high"),
                     "inputs": inputs,
                     "outputs": outputs,
-                }
+                },
             )
 
         return {"tools": tools, "variables": variables}