SmartMDAO 1.1.0__py3-none-any.whl

smartmdao/__init__.py

@@ -0,0 +1,24 @@
+from .core import Pipeline
+from .models import Step
+from .solvers import Solver, DAGSolver, IterativeSolver, HybridSolver
+from .cache import cached, MemoryBackend, HistoryBackend, HDF5Backend, PickleDiskBackend
+from .logging_config import configure_logging
+
+# Expose the configuration helper so users can easily do: 
+# import pipeline; pipeline.configure_logging()
+
+__all__ = [
+    "Pipeline", 
+    "Step", 
+    "Solver", 
+    "DAGSolver", 
+    "IterativeSolver", 
+    "HybridSolver",
+    "cached", 
+    "MemoryBackend", 
+    "HistoryBackend", 
+    "HDF5Backend", 
+    "PickleDiskBackend",
+    "configure_logging",
+    "PipelineEvaluator"
+]

smartmdao/cache.py

@@ -0,0 +1,150 @@
+import functools
+import hashlib
+import pickle
+import os
+import logging
+from abc import ABC, abstractmethod
+from collections import defaultdict
+
+# Initialize module-level logger
+logger = logging.getLogger(__name__)
+
+# --- 1. Abstract Backend Interface ---
+class CacheBackend(ABC):
+    @abstractmethod
+    def get(self, func_name, key):
+        pass
+
+    @abstractmethod
+    def set(self, func_name, key, value):
+        pass
+
+    @abstractmethod
+    def has(self, func_name, key):
+        pass
+
+# --- 2. In-Memory Backend (Dictionary) ---
+class MemoryBackend(CacheBackend):
+    def __init__(self):
+        self.store = {}
+
+    def _make_key(self, func_name, key):
+        return f"{func_name}::{key}"
+
+    def has(self, func_name, key):
+        return self._make_key(func_name, key) in self.store
+
+    def get(self, func_name, key):
+        logger.debug(f"[Memory] Cache hit for {func_name}")
+        return self.store[self._make_key(func_name, key)]
+
+    def set(self, func_name, key, value):
+        self.store[self._make_key(func_name, key)] = value
+
+class HistoryBackend(MemoryBackend):
+    """
+    A simple extension of MemoryBackend that keeps a chronological 
+    list of all values computed by the cached functions.
+    """
+    def __init__(self):
+        super().__init__()
+        # Dictionary mapping function_name -> list of values
+        self.history = defaultdict(list)
+
+    def set(self, func_name, key, value):
+        # 1. Store in the standard cache (MemoryBackend logic)
+        super().set(func_name, key, value)
+        
+        # 2. Append to our history list for plotting
+        self.history[func_name].append(value)
+
+# --- 3. HDF5 Backend ---
+class HDF5Backend(CacheBackend):
+    """
+    Best for Large Numpy Arrays. 
+    Limitation: Can only store data types HDF5 supports (scalars, strings, numpy arrays).
+    For generic Python objects (classes, dicts), use Pickle instead.
+    """
+    def __init__(self, filepath):
+        self.filepath = filepath
+        import h5py 
+        self.h5py = h5py # lazy import
+
+    def has(self, func_name, key):
+        if not os.path.exists(self.filepath):
+            return False
+        with self.h5py.File(self.filepath, 'r') as f:
+            return f"{func_name}/{key}" in f
+
+    def get(self, func_name, key):
+        logger.debug(f"[HDF5] Cache hit for {func_name}")
+        with self.h5py.File(self.filepath, 'r') as f:
+            dataset = f[f"{func_name}/{key}"]
+            # Convert back to numpy or scalar
+            if dataset.shape == ():
+                return dataset[()] # scalar
+            return dataset[:] # array
+
+    def set(self, func_name, key, value):
+        with self.h5py.File(self.filepath, 'a') as f:
+            group_path = f"{func_name}"
+            if group_path not in f:
+                f.create_group(group_path)
+            
+            # Delete if exists to overwrite
+            if key in f[group_path]:
+                del f[group_path][key]
+            
+            f[group_path].create_dataset(key, data=value)
+
+class PickleDiskBackend(CacheBackend):
+    def __init__(self, directory="cache_dir"):
+        self.directory = directory
+        os.makedirs(directory, exist_ok=True)
+
+    def _path(self, func_name, key):
+        return os.path.join(self.directory, f"{func_name}_{key}.pkl")
+
+    def has(self, func_name, key):
+        return os.path.exists(self._path(func_name, key))
+
+    def get(self, func_name, key):
+        logger.debug(f"[Pickle] Cache hit for {func_name}")
+        with open(self._path(func_name, key), 'rb') as f:
+            return pickle.load(f)
+
+    def set(self, func_name, key, value):
+        with open(self._path(func_name, key), 'wb') as f:
+            pickle.dump(value, f)
+
+# --- 4. The Decorator ---
+def generate_cache_key(kwargs):
+    """
+    Creates a stable hash of the input arguments.
+    We use pickle to serialize args -> hash to handle complex types.
+    """
+    # Sort kwargs to ensure order doesn't matter: f(a=1, b=2) == f(b=2, a=1)
+    sorted_items = sorted(kwargs.items())
+    serialized = pickle.dumps(sorted_items)
+    return hashlib.sha256(serialized).hexdigest()
+
+def cached(backend: CacheBackend):
+    def decorator(fn):
+        @functools.wraps(fn)
+        def wrapper(**kwargs):
+            # 1. Generate Key based on function input
+            key = generate_cache_key(kwargs)
+            
+            # 2. Check Backend
+            if backend.has(fn.__name__, key):
+                return backend.get(fn.__name__, key)
+            
+            # 3. Run Function
+            logger.debug(f"Cache miss for {fn.__name__}. Executing...")
+            result = fn(**kwargs)
+            
+            # 4. Save Result
+            backend.set(fn.__name__, key, result)
+            return result
+        return wrapper
+    return decorator

smartmdao/core.py

@@ -0,0 +1,74 @@
+import logging
+from dataclasses import dataclass, field
+from typing import Callable, List, Literal
+
+from .models import Step
+from .solvers import Solver, DAGSolver
+from .visualization import visualize_pipeline
+
+# Initialize module-level logger
+logger = logging.getLogger(__name__)
+
+@dataclass
+class Pipeline:
+    steps: list[Step] = field(default_factory=list)
+    solver: Solver = field(default_factory=DAGSolver)
+
+    def add(self, fn: Callable, outputs: list[str] = None):
+        """
+        Add a step to the pipeline.
+        :param fn: The function to execute.
+        :param outputs: Optional list of variable names this function produces. 
+        """
+        step = Step(fn, outputs)
+        self.steps.append(step)
+        logger.debug(f"Added step '{step.name}' to pipeline.")
+        return self
+
+    def step(self, fn: Callable = None, *, outputs: List[str] = None):
+        """
+        Decorator to register a step.
+        """
+        if fn is not None and callable(fn):
+            self.add(fn, outputs=outputs)
+            return fn
+
+        def wrapper(func):
+            self.add(func, outputs=outputs)
+            return func
+        
+        return wrapper
+
+    def run(self, **inputs):
+        """
+        Delegates the execution to the configured Solver.
+        """
+        logger.info(f"Starting pipeline execution with {len(self.steps)} steps and inputs: {list(inputs.keys())}")
+        try:
+            result = self.solver.solve(self.steps, inputs)
+            logger.info("Pipeline execution completed successfully.")
+            return result
+        except Exception as e:
+            logger.error(f"Pipeline execution failed: {e}")
+            raise
+
+    def visualize(self, 
+                  inputs: List[str] = None, 
+                  output_path: str = None, 
+                  orientation: Literal["TB", "LR"] = "TB",
+                  graph_type: Literal["flow", "bipartite"] = "flow",
+                  view: bool = True):
+        """
+        Generates a Graphviz diagram of the pipeline.
+        """
+        input_set = set(inputs or [])
+        logger.debug(f"Generating visualization ({graph_type}) for pipeline.")
+        
+        visualize_pipeline(
+            steps=self.steps,
+            inputs=input_set,
+            output_path=output_path,
+            orientation=orientation,
+            graph_type=graph_type,
+            view=view
+        )

smartmdao/executor.py

@@ -0,0 +1,90 @@
+import inspect
+import logging
+from dataclasses import is_dataclass, asdict
+from typing import Dict, Any
+from .models import Step
+
+# Initialize module-level logger
+logger = logging.getLogger(__name__)
+
+class StepExecutor:
+    """
+    Static helper responsible for binding arguments from memory 
+    and updating memory with results.
+    """
+    @staticmethod
+    def run_step(step: Step, memory: Dict[str, Any]):
+        logger.debug(f"Preparing to execute step '{step.name}'")
+        
+        # Use the robust unwrapped signature to find expected parameters
+        sig = step.get_signature()
+        
+        # 1. Bind Arguments
+        params = {}
+        missing_required = []
+        
+        for name, param in sig.parameters.items():
+            if name in memory:
+                params[name] = memory[name]
+            elif param.default == inspect.Parameter.empty:
+                missing_required.append(name)
+        
+        if missing_required:
+            error_msg = (f"Step '{step.name}' cannot run. Missing inputs: {missing_required}. "
+                         f"Available in memory: {list(memory.keys())}")
+            logger.error(error_msg)
+            raise KeyError(error_msg)
+        
+        # 2. Execute
+        try:
+            logger.debug(f"Invoking '{step.name}' with inputs: {list(params.keys())}")
+            result = step.fn(**params)
+        except Exception as e:
+            logger.error(f"Error executing step '{step.name}': {e}", exc_info=True)
+            raise RuntimeError(f"Error executing step '{step.name}': {e}") from e
+
+        # 3. Store Result
+        StepExecutor._update_memory(step, result, memory)
+        logger.debug(f"Finished step '{step.name}'.")
+
+    @staticmethod
+    def _update_memory(step: Step, result: Any, memory: Dict[str, Any]):
+        output_keys = step.resolve_output_names()
+
+        if result is None:
+             logger.debug(f"Step '{step.name}' returned None. No outputs stored.")
+             return
+
+        # Case A: Explicit Manual Outputs (e.g. outputs=['a', 'b'])
+        if step.manual_outputs:
+            if len(output_keys) == 1:
+                memory[output_keys[0]] = result
+                return
+            
+            # Handle Dictionary Return with Manual Outputs
+            if isinstance(result, dict):
+                for k in output_keys:
+                    if k not in result:
+                        logger.error(f"Step '{step.name}' missing output key '{k}' in returned dict.")
+                        raise KeyError(f"Step '{step.name}' expected output key '{k}' but it was missing in returned dict.")
+                    memory[k] = result[k]
+                return
+
+            # Handle Tuple/List Return with Manual Outputs
+            if not isinstance(result, (list, tuple)):
+                raise TypeError(f"Step '{step.name}' expected iterable (or dict) output for keys {output_keys}, got {type(result)}")
+            
+            if len(result) != len(output_keys):
+                raise ValueError(f"Step '{step.name}' returned {len(result)} items, expected {len(output_keys)}")
+            
+            for k, v in zip(output_keys, result):
+                memory[k] = v
+            return
+
+        # Case B: Dataclass Expansion (Auto-unpacking based on type hint/runtime check)
+        if is_dataclass(result):
+            memory.update(asdict(result))
+            return
+
+        # Case C: Single Default Output
+        memory[output_keys[0]] = result

smartmdao/logging_config.py

@@ -0,0 +1,42 @@
+import logging
+import sys
+
+def configure_logging(
+    level: int = logging.INFO,
+    log_format: str = "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+    date_format: str = "%H:%M:%S"
+) -> logging.Logger:
+    """
+    Configures the root logger for the pipeline library.
+    
+    This is a helper for the end-user. Library modules should NOT call this;
+    they should simply use `logging.getLogger(__name__)`.
+    
+    Usage:
+        >>> from pipeline import configure_logging
+        >>> configure_logging(level=logging.DEBUG)
+    """
+    handler = logging.StreamHandler(sys.stdout)
+    formatter = logging.Formatter(log_format, datefmt=date_format)
+    handler.setFormatter(formatter)
+
+    # Get the library root logger (assuming the package is imported as 'pipeline' or similar)
+    # We configure the root logger to catch everything, or specific loggers if preferred.
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+    
+    # Remove existing handlers to avoid duplicates if called multiple times
+    if root_logger.hasHandlers():
+        root_logger.handlers.clear()
+        
+    root_logger.addHandler(handler)
+    return root_logger
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Factory to ensure every module gets a properly namespaced logger.
+    Includes a NullHandler by default so the library is silent unless configured.
+    """
+    logger = logging.getLogger(name)
+    logger.addHandler(logging.NullHandler())
+    return logger

smartmdao/main.py

@@ -0,0 +1,8 @@
+import sys
+
+def main():
+    print("Hello from smartmdao !")
+    print(f"Running with Python: {sys.version}")
+
+if __name__ == "__main__":
+    main()

smartmdao/models.py

@@ -0,0 +1,48 @@
+import inspect
+from dataclasses import dataclass, is_dataclass
+from typing import Callable, Optional, List, get_type_hints
+
+@dataclass(eq=False)
+class Step:
+    """
+    Represents a single node in the computation graph.
+    eq=False ensures hashability is based on object identity.
+    """
+    fn: Callable
+    manual_outputs: Optional[List[str]] = None
+
+    @property
+    def name(self) -> str:
+        return self.fn.__name__
+
+    def get_signature(self) -> inspect.Signature:
+        """
+        Robustly retrieves the signature of the underlying function,
+        peeling off any decorators (like @cached) to find the real inputs.
+        """
+        original_fn = inspect.unwrap(self.fn)
+        return inspect.signature(original_fn)
+
+    def resolve_output_names(self) -> List[str]:
+        """Determines variable names this step produces."""
+        if self.manual_outputs:
+            return self.manual_outputs
+
+        # FIX: Use get_type_hints to correctly resolve string annotations 
+        # (common with 'from __future__ import annotations' or forward refs)
+        try:
+            original_fn = inspect.unwrap(self.fn)
+            hints = get_type_hints(original_fn)
+            ann = hints.get('return')
+        except Exception:
+            # Fallback to standard inspection if get_type_hints fails 
+            # (e.g., closures without global context)
+            sig = self.get_signature()
+            ann = sig.return_annotation
+        
+        # If the function returns a Dataclass, use field names
+        if isinstance(ann, type) and is_dataclass(ann):
+            return list(ann.__dataclass_fields__.keys())
+
+        # Default: use function name
+        return [self.name]

smartmdao/optimization.py

@@ -0,0 +1,69 @@
+import logging
+from typing import List, Dict, Any, Callable
+
+from .core import Pipeline
+
+logger = logging.getLogger(__name__)
+
+class PipelineEvaluator:
+    """
+    A generic, stateful bridge to interface the Pipeline with external optimizers 
+    (SciPy, OpenTURNS, PyOptSparse, etc.).
+    
+    It caches the last evaluation to prevent redundant pipeline runs when optimizers
+    request objectives and constraints independently for the same state.
+    """
+    def __init__(self, 
+                 pipeline: Pipeline, 
+                 design_vars: List[str], 
+                 constants: Dict[str, Any] = None):
+        """
+        :param pipeline: The instantiated smartmdao.
+        :param design_vars: Ordered list of variable names corresponding to the optimizer's input array `x`.
+        :param constants: Optional dictionary of variables that remain fixed during optimization.
+        """
+        self.pipeline = pipeline
+        self.design_vars = design_vars
+        self.constants = constants or {}
+        
+        self.last_x = None
+        self.last_results = None
+        self.eval_count = 0
+
+    def evaluate(self, x) -> Dict[str, Any]:
+        """Runs the pipeline if the design variables have changed."""
+        # Convert to tuple for hashable comparison
+        x_tuple = tuple(x)
+        
+        if self.last_x != x_tuple:
+            self.eval_count += 1
+            
+            # 1. Map the numeric array 'x' back to named variables
+            inputs = dict(zip(self.design_vars, x))
+            
+            # 2. Inject constants
+            inputs.update(self.constants)
+            
+            # 3. Execute
+            self.last_results = self.pipeline.run(**inputs)
+            self.last_x = x_tuple
+            
+        return self.last_results
+
+    def get_objective(self, output_name: str) -> Callable:
+        """
+        Factory method that returns a callable objective function for the optimizer.
+        """
+        def _objective(x):
+            return self.evaluate(x)[output_name]
+        return _objective
+
+    def get_constraint(self, output_name: str, multiplier: float = 1.0) -> Callable:
+        """
+        Factory method that returns a callable constraint function.
+        :param multiplier: Useful for flipping constraint signs. 
+                           (e.g., SciPy expects f(x) >= 0. If pipeline outputs f(x) <= 0, use multiplier=-1.0)
+        """
+        def _constraint(x):
+            return multiplier * self.evaluate(x)[output_name]
+        return _constraint

smartmdao/solvers.py

@@ -0,0 +1,288 @@
+import logging
+from collections import defaultdict, deque
+from dataclasses import dataclass
+from typing import List, Dict, Any, Set, Protocol, Optional
+
+from .models import Step
+from .executor import StepExecutor
+
+# Initialize module-level logger
+logger = logging.getLogger(__name__)
+
+class Solver(Protocol):
+    """Interface for execution logic."""
+    def solve(self, steps: List[Step], inputs: Dict[str, Any]) -> Dict[str, Any]:
+        ...
+
+class DAGSolver:
+    """
+    Standard Topological Sort Solver. 
+    Ideal for linear workflows.
+    """
+    def solve(self, steps: List[Step], inputs: Dict[str, Any]) -> Dict[str, Any]:
+        logger.info("DAGSolver started.")
+        execution_order = self._topological_sort(steps, set(inputs.keys()))
+        logger.debug(f"Topological sort order: {[s.name for s in execution_order]}")
+        
+        memory = inputs.copy()
+        
+        for step in execution_order:
+            StepExecutor.run_step(step, memory)
+            
+        return memory
+
+    def _topological_sort(self, steps: List[Step], input_keys: Set[str]) -> List[Step]:
+        producers_map = _map_producers(steps)
+        adj_list, indegree = _build_dependency_graph(steps, input_keys, producers_map)
+
+        # Kahn's Algorithm
+        queue = deque([s for s, deg in indegree.items() if deg == 0])
+        sorted_steps = []
+
+        while queue:
+            current = queue.popleft()
+            sorted_steps.append(current)
+
+            for neighbor in adj_list[current]:
+                indegree[neighbor] -= 1
+                if indegree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        if len(sorted_steps) != len(steps):
+            logger.error("Cycle detected in DAGSolver.")
+            raise ValueError("Cycle detected in pipeline. Use HybridSolver or IterativeSolver.")
+
+        return sorted_steps
+
+@dataclass
+class IterativeSolver:
+    """
+    Solves systems with feedback loops.
+    """
+    max_iterations: int = 100
+    tolerance: float = 1e-6
+    target_var: Optional[str] = None
+    execution_order: Optional[List[str]] = None
+
+    def solve(self, steps: List[Step], inputs: Dict[str, Any]) -> Dict[str, Any]:
+        memory = inputs.copy()
+        residuals = []
+        
+        run_sequence = self._determine_execution_order(steps)
+        logger.info(f"IterativeSolver started. Sequence: {[s.name for s in run_sequence]}")
+        
+        # Identify variables produced by these steps (for auto-convergence)
+        produced_vars = set()
+        for s in steps:
+            produced_vars.update(s.resolve_output_names())
+
+        for i in range(self.max_iterations):
+            # Snapshot state for convergence check
+            prev_state = {k: memory.get(k) for k in produced_vars if k in memory}
+            
+            # Execute
+            for step in run_sequence:
+                StepExecutor.run_step(step, memory)
+            
+            # Check Convergence
+            diff = self._calculate_residual(prev_state, memory, produced_vars)
+            residuals.append(diff)
+            
+            # Only break if we actually calculated a numeric difference (not inf)
+            if diff != float('inf') and diff < self.tolerance:
+                logger.info(f"Converged at iteration {i+1} with residual {diff:.6e}")
+                break
+            
+            logger.debug(f"Iteration {i+1}: residual {diff:.6e}")
+        else:
+             logger.warning(f"Reached max_iterations ({self.max_iterations}) without converging. Last residual: {residuals[-1]:.6e}")
+        
+        # Store residuals (append to potentially existing history from other cycles)
+        memory.setdefault('residual_history', []).append(residuals)
+        return memory
+
+    def _calculate_residual(self, prev_state: Dict, current_memory: Dict, produced_vars: Set[str]) -> float:
+        """
+        Calculates the maximum change in variables. 
+        """
+        if self.target_var:
+            p = prev_state.get(self.target_var)
+            c = current_memory.get(self.target_var)
+            return abs(c - p) if (isinstance(p, (int, float)) and isinstance(c, (int, float))) else float('inf')
+
+        max_diff = 0.0
+        numeric_vars_found = False
+
+        for k in produced_vars:
+            p = prev_state.get(k)
+            c = current_memory.get(k)
+            
+            # Strictly require both to be numeric
+            if isinstance(p, (int, float)) and isinstance(c, (int, float)):
+                diff = abs(c - p)
+                max_diff = max(max_diff, diff)
+                numeric_vars_found = True
+        
+        if numeric_vars_found:
+            return max_diff
+            
+        # If no numeric variables updated, we can't judge convergence numerically.
+        return float('inf')
+
+    def _determine_execution_order(self, steps: List[Step]) -> List[Step]:
+        if not self.execution_order:
+            return steps 
+        
+        step_map = {s.name: s for s in steps}
+        return [step_map[name] for name in self.execution_order if name in step_map]
+
+
+class HybridSolver:
+    """
+    Advanced solver that automatically decomposes the pipeline into 
+    Linear (DAG) and Iterative (Cyclic) components (Strongly Connected Components).
+    """
+    def __init__(self, max_iterations: int = 100, tolerance: float = 1e-6):
+        self.max_iterations = max_iterations
+        self.tolerance = tolerance
+
+    def solve(self, steps: List[Step], inputs: Dict[str, Any]) -> Dict[str, Any]:
+        logger.info("HybridSolver started.")
+        input_keys = set(inputs.keys())
+        producers_map = _map_producers(steps)
+        
+        # 1. Build Adjacency Graph (Producer -> Consumer)
+        adj_list, _ = _build_dependency_graph(steps, input_keys, producers_map)
+
+        # 2. Find Strongly Connected Components (SCCs)
+        sccs = self._tarjan_scc(steps, adj_list)
+        logger.debug(f"Detected {len(sccs)} execution blocks (SCCs).")
+        
+        # 3. Build Condensation Graph (DAG of SCCs)
+        scc_map = {step: i for i, cluster in enumerate(sccs) for step in cluster}
+        scc_adj = defaultdict(set)
+        scc_indegree = defaultdict(int)
+
+        for u in steps:
+            u_scc = scc_map[u]
+            for v in adj_list[u]:
+                v_scc = scc_map[v]
+                if u_scc != v_scc:
+                    if v_scc not in scc_adj[u_scc]:
+                        scc_adj[u_scc].add(v_scc)
+                        scc_indegree[v_scc] += 1
+        
+        # Ensure all SCCs have an entry
+        for i in range(len(sccs)):
+            if i not in scc_indegree:
+                scc_indegree[i] = 0
+
+        # 4. Topological Sort of SCCs
+        queue = deque([i for i, deg in scc_indegree.items() if deg == 0])
+        execution_plan = []
+        
+        while queue:
+            current_scc_idx = queue.popleft()
+            execution_plan.append(sccs[current_scc_idx])
+            
+            for neighbor_scc in scc_adj[current_scc_idx]:
+                scc_indegree[neighbor_scc] -= 1
+                if scc_indegree[neighbor_scc] == 0:
+                    queue.append(neighbor_scc)
+
+        # 5. Execute
+        memory = inputs.copy()
+        
+        for group in execution_plan:
+            # Case A: Linear
+            if len(group) == 1 and group[0] not in adj_list[group[0]]:
+                step = group[0]
+                StepExecutor.run_step(step, memory)
+                continue
+
+            # Case B: Cyclic
+            # Sort alphabetically to ensure deterministic execution order within the cycle
+            group_sorted = sorted(group, key=lambda s: s.name)
+            
+            logger.info(f"Cyclic Block Detected: {[s.name for s in group_sorted]}")
+            sub_solver = IterativeSolver(
+                max_iterations=self.max_iterations, 
+                tolerance=self.tolerance
+            )
+            
+            cycle_results = sub_solver.solve(group_sorted, memory)
+            memory.update(cycle_results)
+
+        return memory
+
+    def _tarjan_scc(self, steps: List[Step], adj_list: Dict[Step, List[Step]]) -> List[List[Step]]:
+        index = 0
+        indices = {}
+        lowlinks = {}
+        stack = []
+        on_stack = set()
+        sccs = []
+
+        def strongconnect(v):
+            nonlocal index
+            indices[v] = index
+            lowlinks[v] = index
+            index += 1
+            stack.append(v)
+            on_stack.add(v)
+
+            for w in adj_list[v]:
+                if w not in indices:
+                    strongconnect(w)
+                    lowlinks[v] = min(lowlinks[v], lowlinks[w])
+                elif w in on_stack:
+                    lowlinks[v] = min(lowlinks[v], indices[w])
+
+            if lowlinks[v] == indices[v]:
+                new_scc = []
+                while True:
+                    w = stack.pop()
+                    on_stack.remove(w)
+                    new_scc.append(w)
+                    if w == v:
+                        break
+                sccs.append(new_scc)
+
+        for step in steps:
+            if step not in indices:
+                strongconnect(step)
+                
+        return sccs
+
+# --- Helpers ---
+
+def _map_producers(steps: List[Step]) -> Dict[str, Step]:
+    mapping = {}
+    for step in steps:
+        for out in step.resolve_output_names():
+            mapping[out] = step
+    return mapping
+
+def _build_dependency_graph(steps: List[Step], input_keys: Set[str], producers_map: Dict[str, Step]):
+    adj_list = defaultdict(list)
+    indegree = defaultdict(int)
+    
+    for s in steps: 
+        indegree[s] = 0
+
+    for consumer in steps:
+        # --- FIX: Use .get_signature() to see through decorators ---
+        sig = consumer.get_signature() 
+        for param in sig.parameters:
+            
+            # PRIORITY FIX: Check if it's an internal producer FIRST.
+            if param in producers_map:
+                producer = producers_map[param]
+                adj_list[producer].append(consumer)
+                indegree[consumer] += 1
+            
+            # Only if it's NOT produced internally do we check if it's satisfied by inputs.
+            elif param in input_keys:
+                continue 
+
+    return adj_list, indegree

smartmdao/utils.py

@@ -0,0 +1,22 @@
+import inspect
+from dataclasses import is_dataclass
+from typing import List
+from .models import Step
+
+def resolve_output_names(step: Step) -> List[str]:
+    """
+    Determines the variable names a step produces.
+    It checks manual_outputs first, then type hints, then defaults to function name.
+    """
+    if step.manual_outputs:
+        return step.manual_outputs
+
+    sig = inspect.signature(step.fn)
+    ann = sig.return_annotation
+    
+    # If the return type is a Dataclass, use its field names
+    if isinstance(ann, type) and is_dataclass(ann):
+        return list(ann.__dataclass_fields__.keys())
+
+    # Default to the function name
+    return [step.name]

smartmdao/visualization.py

@@ -0,0 +1,313 @@
+import os
+import logging
+from typing import List, Set, Dict, Literal, Optional, Tuple
+
+from .models import Step
+
+# Initialize module-level logger
+logger = logging.getLogger(__name__)
+
+# Try importing graphviz; handle absence gracefully
+try:
+    import graphviz
+except ImportError:
+    graphviz = None
+    logger.warning("Graphviz not found. Visualization features will be unavailable.")
+
+
+class PipelineVisualizer:
+    """
+    A modern, modular visualizer for the Pipeline using Graphviz.
+    Focuses on standardizing workflow visualization with clear separation of concerns.
+    """
+
+    # --- Standard Palette (Material Design Pastels) ---
+    STYLE_INPUT = {
+        "shape": "parallelogram", 
+        "style": "filled", 
+        "fillcolor": "#E3F2FD", # Blue 50
+        "color": "#1565C0",     # Blue 800
+        "penwidth": "1.5",
+        "margin": "0.2"
+    }
+    STYLE_STEP = {
+        "shape": "component", 
+        "style": "filled", 
+        "fillcolor": "#FFF3E0", # Orange 50
+        "color": "#EF6C00",     # Orange 800
+        "penwidth": "1.5",
+        "margin": "0.3"
+    }
+    STYLE_INTERMEDIATE = {
+        "shape": "ellipse", 
+        "style": "filled", 
+        "fillcolor": "#F5F5F5", # Grey 100
+        "color": "#757575",     # Grey 600
+        "penwidth": "1.0",
+        "height": "0.4"
+    }
+    STYLE_FINAL = {
+        "shape": "parallelogram", 
+        "style": "filled", 
+        "fillcolor": "#E8F5E9", # Green 50
+        "color": "#2E7D32",     # Green 800
+        "penwidth": "2.0",      # Thicker border for emphasis
+        "peripheries": "2",     # Double border
+        "margin": "0.2"
+    }
+    STYLE_MISSING = {
+        "shape": "hexagon",
+        "style": "filled",
+        "fillcolor": "#FFEBEE", # Red 50
+        "color": "#C62828",     # Red 800
+        "penwidth": "2.0"
+    }
+
+    def __init__(
+        self, 
+        steps: List[Step], 
+        input_keys: Set[str],
+        orientation: Literal['TB', 'LR'] = 'TB'
+    ):
+        if graphviz is None:
+            raise ImportError(
+                "The 'graphviz' library is required for visualization. "
+                "Please install it using: pip install graphviz"
+            )
+        
+        self.steps = sorted(steps, key=lambda s: s.name)
+        self.input_keys = input_keys
+        self.orientation = orientation
+        
+        # Initialize the graph
+        self.dot = graphviz.Digraph(comment='Pipeline Graph')
+        self._setup_graph_attributes()
+
+    def _setup_graph_attributes(self):
+        """Configures global graph styling for a professional look."""
+        self.dot.attr(rankdir=self.orientation)
+        self.dot.attr(compound='true') # Allow edges between clusters
+        
+        # Global typography
+        self.dot.attr('node', fontname='Helvetica', fontsize='11')
+        self.dot.attr('edge', fontname='Helvetica', fontsize='9', color='#616161')
+        
+        # 'ortho' provides clean, rect-linear lines suitable for technical diagrams
+        # 'splines'='polyline' is also a good option if ortho gets messy.
+        self.dot.attr(splines='ortho') 
+
+    def build(self, graph_type: Literal["flow", "bipartite"] = "flow") -> "PipelineVisualizer":
+        """
+        Builds the nodes and edges.
+        Note: The 'bipartite' (Data Flow) view is recommended for detailed analysis 
+        of Inputs vs Intermediates vs Finals.
+        """
+        if graph_type == "bipartite":
+            self._build_bipartite_standard()
+        else:
+            self._build_flow_standard()
+        return self
+
+    def render(self, output_path: Optional[str] = None, view: bool = True):
+        """
+        Renders the graph to a file or temporary view.
+        """
+        try:
+            if output_path:
+                filename, ext = os.path.splitext(output_path)
+                fmt = ext.lstrip('.').lower() if ext else 'pdf'
+                out_file = self.dot.render(filename, format=fmt, cleanup=True, view=view)
+                if not view:
+                    logger.info(f"Pipeline diagram saved to: {out_file}")
+            else:
+                self.dot.view(cleanup=True)
+                logger.info("Pipeline diagram opened in viewer.")
+        except Exception as e:
+            logger.error(f"Graph rendered successfully, but viewer failed: {e}")
+            if output_path:
+                logger.info(f"File saved at: {output_path}")
+
+    # --- Classification Logic ---
+
+    def _analyze_variables(self) -> Tuple[Set[str], Set[str], Set[str], Set[str], Dict[str, Step]]:
+        """
+        Categorizes all variables in the pipeline.
+        Returns: (inputs, intermediates, finals, missing, producer_map)
+        """
+        producers_map = {}
+        consumed = set()
+        produced = set()
+
+        for step in self.steps:
+            # Outputs
+            for out in step.resolve_output_names():
+                producers_map[out] = step
+                produced.add(out)
+            
+            # Inputs (Use unwrapped signature)
+            sig = step.get_signature()
+            for param in sig.parameters:
+                consumed.add(param)
+
+        # 2. Categorize
+        # Inputs: Variables consumed but NOT produced internally.
+        # (We strictly use input_keys to validate, but graph logic relies on structural dependency)
+        real_inputs = {v for v in consumed if v not in produced}
+        
+        # Missing: Required inputs that are NOT in the provided input_keys
+        missing = {v for v in real_inputs if v not in self.input_keys}
+        
+        # Valid Inputs: Real inputs that exist in input_keys
+        valid_inputs = real_inputs.intersection(self.input_keys)
+        
+        # Intermediates: Produced AND Consumed
+        intermediates = produced.intersection(consumed)
+        
+        # Finals: Produced but NEVER Consumed
+        finals = produced - consumed
+
+        return valid_inputs, intermediates, finals, missing, producers_map
+
+    # --- Bipartite (Data Flow) Strategy ---
+
+    def _build_bipartite_standard(self):
+        """
+        Constructs a Data Flow Diagram (DFD).
+        Strictly separates: Input Nodes -> Step Nodes -> Intermediate Nodes -> Step Nodes -> Final Nodes.
+        """
+        inputs, intermediates, finals, missing, producers = self._analyze_variables()
+
+        # 1. Draw Inputs (Rank Source to force top/left)
+        with self.dot.subgraph(name='cluster_inputs') as c:
+            c.attr(rank='source', style='invis') # Invisible container for grouping
+            for var in inputs:
+                self._add_node(c, f"Var_{var}", var, self.STYLE_INPUT)
+            for var in missing:
+                self._add_node(c, f"Missing_{var}", f"{var} (?)", self.STYLE_MISSING)
+
+        # 2. Draw Finals (Rank Sink to force bottom/right)
+        with self.dot.subgraph(name='cluster_finals') as c:
+            c.attr(rank='sink', style='invis')
+            for var in finals:
+                self._add_node(c, f"Var_{var}", var, self.STYLE_FINAL)
+
+        # 3. Draw Intermediates
+        for var in intermediates:
+            self._add_node(self.dot, f"Var_{var}", var, self.STYLE_INTERMEDIATE)
+
+        # 4. Draw Steps
+        for step in self.steps:
+            self._add_step_node(self.dot, step)
+
+        # 5. Draw Edges
+        for step in self.steps:
+            step_id = self._node_id(step)
+            sig = step.get_signature()
+
+            # Inputs to Step
+            for param in sig.parameters:
+                if param in missing:
+                    self.dot.edge(f"Missing_{param}", step_id, style="dotted", color="#D32F2F")
+                else:
+                    # It's either a valid input or an intermediate/produced var
+                    var_id = f"Var_{param}"
+                    self.dot.edge(var_id, step_id)
+
+            # Step to Outputs
+            for out in step.resolve_output_names():
+                var_id = f"Var_{out}"
+                self.dot.edge(step_id, var_id)
+
+    # --- Flow Strategy (Process Flow) ---
+
+    def _build_flow_standard(self):
+        """
+        Constructs a Process Flow Diagram.
+        Focuses on Steps. Data is shown as explicit nodes ONLY if it is an Input or Final Output.
+        Intermediates are labels on edges.
+        """
+        inputs, intermediates, finals, missing, producers = self._analyze_variables()
+        step_indices = {step: i for i, step in enumerate(self.steps)}
+
+        # 1. Draw Inputs
+        with self.dot.subgraph(name='cluster_inputs') as c:
+            c.attr(rank='source', style='invis')
+            for var in inputs:
+                self._add_node(c, f"Input_{var}", var, self.STYLE_INPUT)
+            for var in missing:
+                self._add_node(c, f"Missing_{var}", f"{var} (?)", self.STYLE_MISSING)
+
+        # 2. Draw Finals
+        with self.dot.subgraph(name='cluster_finals') as c:
+            c.attr(rank='sink', style='invis')
+            for var in finals:
+                 # Note: In flow view, we link the step directly to this final node
+                self._add_node(c, f"Final_{var}", var, self.STYLE_FINAL)
+
+        # 3. Draw Steps
+        for step in self.steps:
+            self._add_step_node(self.dot, step)
+
+        # 4. Draw Edges
+        for step in self.steps:
+            step_id = self._node_id(step)
+            sig = step.get_signature()
+            
+            for param in sig.parameters:
+                # Case A: Missing
+                if param in missing:
+                    self.dot.edge(f"Missing_{param}", step_id, style="dotted", color="#D32F2F")
+                
+                # Case B: External Input
+                elif param in inputs:
+                    self.dot.edge(f"Input_{param}", step_id)
+
+                # Case C: Produced by another step (Intermediate)
+                elif param in producers:
+                    producer = producers[param]
+                    prod_id = self._node_id(producer)
+                    
+                    # Cycle Detection
+                    is_feedback = step_indices[producer] >= step_indices[step]
+                    style = "dashed" if is_feedback else "solid"
+                    color = "#D32F2F" if is_feedback else "#616161"
+                    
+                    self.dot.edge(prod_id, step_id, label=param, style=style, color=color)
+
+        # 5. Link Steps to Final Outputs
+        for step in self.steps:
+            step_id = self._node_id(step)
+            for out in step.resolve_output_names():
+                if out in finals:
+                    self.dot.edge(step_id, f"Final_{out}")
+
+    # --- Helpers ---
+
+    def _node_id(self, step: Step) -> str:
+        return f"Step_{id(step)}"
+
+    def _add_node(self, graph, node_id: str, label: str, style_dict: Dict[str, str]):
+        """Generic node adder using a style dictionary."""
+        # Make a copy to avoid mutating the class constant
+        attrs = style_dict.copy()
+        attrs['label'] = label
+        graph.node(node_id, **attrs)
+
+    def _add_step_node(self, graph, step: Step):
+        """Adds a function/step node."""
+        attrs = self.STYLE_STEP.copy()
+        # HTML label for bold text
+        attrs['label'] = f"<<b>{step.name}</b>>" 
+        graph.node(self._node_id(step), **attrs)
+
+# API adapter
+def visualize_pipeline(
+    steps: List[Step], 
+    inputs: Set[str], 
+    output_path: Optional[str] = None,
+    orientation: str = "TD",
+    graph_type: Literal["flow", "bipartite"] = "flow",
+    view: bool = True
+):
+    viz = PipelineVisualizer(steps, inputs, orientation)
+    viz.build(graph_type).render(output_path, view=view)

smartmdao-1.1.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: SmartMDAO
+Version: 1.1.0
+Summary: Add your description here
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: graphviz>=0.21
+Requires-Dist: h5py>=3.15.1
+Requires-Dist: ipykernel>=7.1.0
+Requires-Dist: matplotlib>=3.10.7
+Requires-Dist: numpy>=2.3.5
+Requires-Dist: openturns>=1.27
+Requires-Dist: scipy>=1.17.1
+Description-Content-Type: text/markdown
+
+# SmartPipeline 🚀
+
+SmartPipeline is a robust, Pythonic framework for building modular computational workflows. It moves beyond simple DAGs (Directed Acyclic Graphs) by supporting automatic dependency injection, cyclic/iterative solving, and integrated caching, all while keeping your code clean and readable using standard Python type hints.
+
+Whether you are running linear data processing or highly coupled Multidisciplinary Design Optimization (MDO) problems, SmartPipeline dynamically maps your functions and solves them efficiently.
+
+# 🌟 Key Features
+
+- **Type-Hint Driven Dependency Injection**: No need to manually define edges. If `Step B` needs a variable `x` and `Step A` returns a variable named `x`, the pipeline connects them automatically.
+
+- **We do the MDA, you do the MDO**: We handle the heavy lifting of Multidisciplinary Analysis (MDA) — automatically isolating and converging feedback loops. Because our architecture is completely optimizer-agnostic, you can plug our dynamic evaluator into SciPy, OpenTURNS, PyOptSparse, or any algorithm you prefer.
+
+- **Hybrid Solver**: Automatically detects whether your pipeline is linear or contains feedback loops (cycles). It solves linear parts topologically and iterates over cyclic parts until convergence using Tarjan's Algorithm.
+
+- **Modular Caching**: Built-in decorators (`@cached`) to cache step results in RAM, HDF5 (for large arrays), or Pickle (for complex objects) with zero boilerplate.
+
+- **Visualization**: One-line generation of Graphviz diagrams (Flow charts or Data-Flow diagrams).
+
+# 📦 Installation
+
+We recommend using `uv` for lightning-fast installation, but standard `pip` works perfectly as well.
+
+Using `uv` (Recommended):
+
+``` bash
+uv pip install git+[https://github.com/wghami/SmartMDAO.git](https://github.com/wghami/SmartMDAO.git)
+```
+
+Using standard `pip`:
+
+``` bash
+pip install git+[https://github.com/wghami/SmartMDAO.git](https://github.com/wghami/SmartMDAO.git)
+```
+
+*Note*: The visualization features require the `graphviz` system binary to be installed on your OS.
+
+# ⚡ The Agnostic MDO Approach
+
+`SmartPipeline` is built to let you define complex physics or engineering problems using pure, readable Python, without being locked into a specific optimization suite.
+
+Here is how easily you can solve the classic **Sellar coupled problem** (a 2-discipline feedback loop) and optimize it using SciPy.
+
+``` python
+import math
+from scipy.optimize import minimize
+from smartmdao import Pipeline, HybridSolver
+from smartmdao.optimization import PipelineEvaluator
+
+# 1. We handle the heavy lifting: Multidisciplinary Analysis (MDA)
+# The HybridSolver automatically detects the cyclic dependency between y1 and y2!
+pipe = Pipeline(solver=HybridSolver())
+
+@pipe.step(outputs=["y1"])
+def discipline_1(z1: float, z2: float, x1: float, y2: float) -> float:
+    return (z1 ** 2) + z2 + x1 - (0.2 * y2)
+
+@pipe.step(outputs=["y2"])
+def discipline_2(z1: float, z2: float, y1: float) -> float:
+    return math.sqrt(abs(y1)) + z1 + z2
+
+@pipe.step(outputs=["objective"])
+def compute_objective(x1: float, z2: float, y1: float, y2: float) -> float:
+    return (x1 ** 2) + z2 + (y1 ** 2) + math.exp(-y2)
+
+
+# 2. You choose the optimizer: Agnostic Multidisciplinary Optimization (MDO)
+# Map the optimizer's numeric array to our named design variables
+evaluator = PipelineEvaluator(
+    pipeline=pipe,
+    design_vars=["z1", "z2", "x1"],
+    constants={"y2": 1.0}  # Initial guess to kick off the cycle
+)
+
+# Pass the dynamically generated objective functions to ANY optimizer (SciPy, OpenTURNS, etc.)
+result = minimize(
+    evaluator.get_objective("objective"), 
+    x0=[1.0, 1.0, 1.0], 
+    method='SLSQP', 
+    bounds=[(-10.0, 10.0), (0.0, 10.0), (0.0, 10.0)]
+)
+
+print(f"Optimization Success! Objective: {result.fun:.4f}")
+```
+
+The user retains full control over the Pythonic equations, while the `PipelineEvaluator` caches the complex cyclic MDA evaluations so the optimizer can request objectives and constraints independently without performance penalties.
+
+# 🛠️ Architecture Overview
+
+- `core.py`: The entry point. Manages steps and delegates execution to solvers.
+
+- `solvers.py`: The brains.
+
+    - `DAGSolver`: For standard linear pipelines.
+
+    - `IterativeSolver`: For fixed-point iteration problems.
+
+    - `HybridSolver`: Uses Tarjan's Algorithm to decompose graphs into linear and cyclic components dynamically.
+
+- `optimization.py`: Contains the stateful `PipelineEvaluator` bridge, providing callable factories for external optimizers.
+
+- `executor.py:` Handles argument binding and runtime memory management.
+
+- `visualization.py`: Generates high-quality PDF/PNG diagrams of your workflow.
+
+# 🚀 Future Improvements & Roadmap
+
+To make `SmartPipeline` even better, the following improvements are planned:
+
+- **Parallel Execution**: Integrating `asyncio` or `ProcessPoolExecutor` to allow independent branches of the DAG to run in parallel.
+
+- **Pydantic Integration**: Replace standard `dataclasses` with Pydantic models for robust runtime data validation and schema generation.
+
+- **Checkpointing**: Allow the pipeline to pause and resume from a specific state in case of failure, serializing the entire memory dictionary.
+
+- **Web UI**: A lightweight Flask/Streamlit dashboard to visualize pipeline progress and convergence plots in real-time.
+
+# 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+# 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/wghami/SmartMDAO/blob/main/LICENSE) file for details.

smartmdao-1.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+smartmdao/__init__.py,sha256=frBsu1Ut9aoD5A18oGiz00M_4N1zY51NMae3nyrHNWA,640
+smartmdao/cache.py,sha256=bJTsV2umVQizv1bWfS5gMbxQgHHjWXaH35K6l2GbEfc,4793
+smartmdao/core.py,sha256=K1aWCsaiq7MqPQ-8nLOORX0st9VW1cL4i8d5noqO4Ww,2396
+smartmdao/executor.py,sha256=pgIZjxKBD7fS7_TcBlM5XsJkkDpJ-ptTpt_Mk0Bf4ZU,3470
+smartmdao/logging_config.py,sha256=rdd2iJ7ThTx0OUD6gGHMo5VO-JWb9ouLMQR9FxZuir0,1486
+smartmdao/main.py,sha256=IFo8fG_pxNYIrobt6b7RzluZcQD0VIDJ4j5DkosTvaM,148
+smartmdao/models.py,sha256=3R73gfirf9qDb7SRyNktlaI7WL6ZxaeXsIUTCRVQyPs,1701
+smartmdao/optimization.py,sha256=sNEk_52zT0PK0GM_MyjIHN4aGp_djqWpkFTK685HWZ4,2519
+smartmdao/solvers.py,sha256=VqB7KBHJ5Rxd1Gj5xr6vPMG-o3q_ivdKQs8EgMKC4tk,10211
+smartmdao/utils.py,sha256=t_uY6MyenWCqqT5Pt-etyUlN_2TEp_c2nRqTdmtnvHA,667
+smartmdao/visualization.py,sha256=5ZkiKy4vs5GNtqSohoNdO-o1Uf60i0xjSXqiED8Daf4,11538
+smartmdao-1.1.0.dist-info/METADATA,sha256=zOv5p6qeBFRXwa674GSviLRTyatluUsV17t55Y2MlJE,5990
+smartmdao-1.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+smartmdao-1.1.0.dist-info/licenses/LICENSE,sha256=9rHf5D9jL0TmxixSU-vbwDFunFbpZFmdSSnwNbYo2-k,1066
+smartmdao-1.1.0.dist-info/RECORD,,

smartmdao-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

smartmdao-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Guilherme Cunha
+
+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.