simstack 0.2.0__py3-none-any.whl

simstack/util/minimal_route_finder.py

@@ -0,0 +1,72 @@
+from collections import deque
+from typing import List, Dict
+
+
+def find_minimal_route(
+    routes: List[Dict[str, str]], source: str, target: str
+) -> List[Dict[str, str]]:
+    """
+    Find the minimal (shortest) route from source to target.
+
+    Args:
+        routes: List of route dictionaries with 'source', 'target', and 'host'
+        source: The starting node
+        target: The destination node
+
+    Returns:
+        A list of route dictionaries representing the shortest path from source to target,
+        or an empty list if no path exists
+    """
+    if not routes:
+        return []
+
+    # Build the graph and route map
+    adj: Dict[str, List[str]] = {}
+    route_map: Dict[tuple, Dict[str, str]] = {}
+    nodes = set()
+
+    for route in routes:
+        src = route["source"]
+        dst = route["target"]
+        nodes.add(src)
+        nodes.add(dst)
+
+        if src not in adj:
+            adj[src] = []
+
+        # Avoid adding duplicates to adjacency list, but allow route_map update (last one wins)
+        if dst not in adj[src]:
+            adj[src].append(dst)
+
+        route_map[(src, dst)] = route
+
+    if source not in nodes or target not in nodes:
+        return []
+
+    # BFS to find shortest path
+    queue = deque([(source, [source])])
+    visited = {source}
+
+    while queue:
+        current_node, path = queue.popleft()
+
+        if current_node == target:
+            # Convert the path of nodes to a list of route dictionaries
+            path_routes = []
+            for i in range(len(path) - 1):
+                u = path[i]
+                v = path[i + 1]
+                path_routes.append(route_map[(u, v)])
+            return path_routes
+
+        if current_node in adj:
+            for neighbor in adj[current_node]:
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    queue.append((neighbor, path + [neighbor]))
+
+    return []
+
+
+# Add an alias for find_minimal_route as find_shortest_route for compatibility
+find_shortest_route = find_minimal_route

simstack/util/mock_db.py

@@ -0,0 +1,144 @@
+import asyncio
+from typing import Type, TypeVar, Dict, List, Optional
+
+from odmantic import Model, ObjectId
+
+T = TypeVar("T", bound=Model)
+
+
+class InMemoryCollection:
+    def __init__(self, engine: "InMemoryAIOEngine"):
+        self._engine = engine
+        self._store: List[Dict] = []
+
+    def __getitem__(self, index: int) -> Dict:
+        return self._store[index]
+
+    def __setitem__(self, index: int, value: Dict):
+        self._store[index] = value
+
+    def __iter__(self):
+        return iter(self._store)
+
+
+class InMemoryAIOEngine:
+    def __init__(self):
+        # Stores data as {collection_name: [documents]}
+        self._store: Dict[str, InMemoryCollection] = {}
+
+    async def save(self, instance: T) -> T:
+        collection_name = (
+            instance.__collection__
+            if hasattr(instance, "__collection__")
+            else instance.__class__.__name__.lower()
+        )
+
+        obj_dict = instance.model_dump()
+
+        # Ensure the instance has an ObjectId assigned
+        if not instance.id:
+            instance.id = ObjectId()
+            obj_dict["id"] = instance.id
+
+        # Initialize collection if it doesn't exist
+        if collection_name not in self._store:
+            self._store[collection_name] = InMemoryCollection(self)
+
+        # Update if already exists
+        existing_index = next(
+            (
+                i
+                for i, obj in enumerate(self._store[collection_name])
+                if obj["id"] == instance.id
+            ),
+            None,
+        )
+        if existing_index is not None:
+            self._store[collection_name][existing_index] = obj_dict
+        else:
+            self._store[collection_name].append(obj_dict)
+
+        return instance
+
+    async def find(self, model: Type[T], **query) -> List[T]:
+        collection_name = (
+            model.__collection__
+            if hasattr(model, "__collection__")
+            else model.__name__.lower()
+        )
+        all_objects = self._store.get(collection_name, [])
+        results = []
+
+        for obj_dict in all_objects:
+            if all(obj_dict.get(k) == v for k, v in query.items()):
+                results.append(model.model_validate(obj_dict))
+        return results
+
+
+async def find_one(self, model: Type[T], condition=None, **query) -> Optional[T]:
+    # Handle both keyword arguments and condition objects
+    if condition is not None:
+        # For conditions like ModelMapping.name == class_name
+        # This is a more robust approach to extract field name and value
+        condition_str = str(condition)
+
+        # Look for the pattern: field_name == value or field_name: {$eq: value}
+        if "==" in condition_str:
+            # Handle direct comparison like ModelMapping.name == 'TestClass'
+            parts = condition_str.split("==")
+            if len(parts) == 2:
+                field_name = parts[0].strip().split(".")[-1]
+                value = parts[1].strip().strip("'\"")
+                query[field_name] = value
+        elif "$eq" in condition_str:
+            # Handle MongoDB-style query like {'mapping': {'$eq': 'tests.core.test_import_class.TestClass'}}
+            import re
+
+            # Extract field name and value using regex
+            field_match = re.search(
+                r"'(\w+)':\s*\{'?\$eq'?:\s*'([^']+)'", condition_str
+            )
+            if field_match:
+                field_name = field_match.group(1)
+                value = field_match.group(2)
+                query[field_name] = value
+            else:
+                # Fallback - try to extract from the string representation
+                # Look for pattern like "ModelMapping.field_name"
+                field_match = re.search(r"(\w+)\.(\w+)", condition_str)
+                if field_match:
+                    field_name = field_match.group(2)
+                    # Try to extract the value (this is still a fallback)
+                    value_match = re.search(r"'([^']+)'(?:[^']*$)", condition_str)
+                    if value_match:
+                        value = value_match.group(1)
+                        query[field_name] = value
+
+    found = await self.find(model, **query)
+    return found[0] if found else None
+
+
+# Example Usage:
+if __name__ == "__main__":
+    from odmantic import Model
+
+    class BinaryOperationInput(Model):
+        arg1: int
+        arg2: int
+
+    async def test_engine():
+        engine = InMemoryAIOEngine()
+        obj = BinaryOperationInput(arg1=1, arg2=2)
+
+        # Saving object
+        await engine.save(obj)
+
+        # Finding objects
+        found_objs = await engine.find(BinaryOperationInput, arg1=1)
+        print("Found objects:", found_objs)
+
+        # Find one object
+        found_one = await engine.find_one(BinaryOperationInput, arg2=2)
+        print("Found single object:", found_one)
+
+    asyncio.run(test_engine())

simstack/util/module_path_checker.py

@@ -0,0 +1,38 @@
+import os
+from pathlib import Path
+
+from simstack.util.project_root_finder import find_project_root
+
+
+def is_module_subpath_of_path(module_path: str, path_info_path: str) -> bool:
+    """
+    Check whether a dot-separated module path is a subpath of an absolute path.
+
+    Args:
+        module_path: A dot-separated path relative to the project root (e.g., "src.simstack.core.artifacts")
+        path_info_path: An absolute path below the project root (e.g., "/path/to/project/src/simstack/core")
+
+    Returns:
+        True if the module path corresponds to a location under the given absolute path, False otherwise
+    """
+
+    # Convert the module path to file system path
+    # Replace dots with path separators
+    module_file_path = module_path.replace(".", os.sep)
+
+    # Convert path_info_path to Path object for easier manipulation
+    path_info_path_obj = Path(path_info_path)
+
+    # Get the project root using the existing utility function
+    project_root = Path(find_project_root())
+
+    # Convert module path to absolute path relative to project root
+    module_absolute_path = project_root / module_file_path
+
+    try:
+        # Check if the module path is under the given path_info_path
+        module_absolute_path.relative_to(path_info_path_obj)
+        return True
+    except ValueError:
+        # If relative_to raises ValueError, the module path is not under path_info_path
+        return False

simstack/util/path_manager.py

@@ -0,0 +1,234 @@
+import os
+from pathlib import Path
+from typing import List, Dict, Optional, Iterator, Any
+
+from simstack.util.directory_iterator import DirectoryPath
+from simstack.util.project_root_finder import find_project_root
+
+
+class PathManager:
+    """
+    Manages paths for the SimStack application, providing mechanisms to find Python files
+    and other resources. Uses DirectoryPath for efficient directory traversal.
+    """
+
+    def __init__(self, use_pickle: bool = False):
+        """
+        Initialize the PathManager.
+
+        Args:
+            use_pickle: Boolean flag indicating whether to use pickle for serialization
+        """
+        self.use_pickle = use_pickle
+        self.root_dir = find_project_root()
+        self.paths: Dict[str, Dict[str, str]] = {}
+        self.packages: Dict[str] = {}
+        self.precompiled: Dict[str] = {}
+        self._default_excluded_patterns = [
+            "__pycache__",
+            "*.pyc",
+            ".git",
+            ".venv",
+            "venv",
+        ]
+
+    def add_path(
+        self, name: str, path: str, drops: str = "", use_pickle: bool = False
+    ) -> None:
+        """
+        Add a path to the manager.
+
+        Args:
+            name: Name identifier for the path
+            path: The directory path
+            drops: Prefix to drop from module names (for import paths)
+            use_pickle: Whether to use pickle for this path
+        """
+        if not os.path.isdir(path):
+            raise ValueError(f"'{path}' is not a valid directory")
+
+        self.paths[name] = {"path": path, "drops": drops, "use_pickle": use_pickle}
+
+    def get_path(self, name: str) -> Dict[str, str]:
+        """
+        Get a path by name.
+
+        Args:
+            name: Name of the path to retrieve
+
+        Returns:
+            Dictionary containing path information
+        """
+        if name not in self.paths:
+            raise KeyError(f"Path '{name}' not found in PathManager")
+
+        return self.paths[name]
+
+    def find_python_files(
+        self, path_name: str, excluded_patterns: Optional[List[str]] = None
+    ) -> List[str]:
+        """
+        Find Python files in the specified path, excluding __init__.py files.
+
+        Args:
+            path_name: Name of the path to search in
+            excluded_patterns: Additional patterns to exclude
+
+        Returns:
+            List of absolute file paths to Python files
+        """
+        path_info = self.get_path(path_name)
+        path = path_info["path"]
+
+        # Combine default and additional exclusion patterns
+        all_excluded_patterns = self._default_excluded_patterns.copy()
+        if excluded_patterns:
+            all_excluded_patterns.extend(excluded_patterns)
+
+        # Add __init__.py to excluded patterns
+        all_excluded_patterns.append("__init__.py")
+
+        # Use DirectoryPath to find Python files
+        dir_path = DirectoryPath(path, all_excluded_patterns, [".py"])
+
+        # Convert Path objects to strings for compatibility with existing code
+        return [str(file_path) for file_path in dir_path.get_files_list()]
+
+    def iterate_python_files(
+        self, path_name: str, excluded_patterns: Optional[List[str]] = None
+    ) -> Iterator[Path]:
+        """
+        Iterate over Python files in the specified path, excluding __init__.py files.
+
+        Args:
+            path_name: Name of the path to search in
+            excluded_patterns: Additional patterns to exclude
+
+        Returns:
+            Iterator of Path objects for Python files
+        """
+        path_info = self.get_path(path_name)
+        path = path_info["path"]
+
+        # Combine default and additional exclusion patterns
+        all_excluded_patterns = self._default_excluded_patterns.copy()
+        if excluded_patterns:
+            all_excluded_patterns.extend(excluded_patterns)
+
+        # Add __init__.py to excluded patterns
+        all_excluded_patterns.append("__init__.py")
+
+        # Use DirectoryPath to iterate over Python files
+        dir_path = DirectoryPath(path, all_excluded_patterns, [".py"])
+        return dir_path.iterate_files()
+
+    def get_drops(self, path_name: str) -> str:
+        """
+        Get the drops value for a path.
+
+        Args:
+            path_name: Name of the path
+
+        Returns:
+            The drops value for the path
+        """
+        path_info = self.get_path(path_name)
+        return path_info["drops"]
+
+    @classmethod
+    def from_config(cls, config: Any) -> "PathManager":
+        """
+        Create a PathManager from configuration.
+
+        Args:
+            config: Configuration object containing path information
+
+        Returns:
+            Initialized PathManager instance
+        """
+        # Get use_pickle from config
+        use_pickle = False
+        if hasattr(config, "config"):
+            # If config is a ConfigReader instance
+            use_pickle = (
+                config.config.get("parameters", {})
+                .get("common", {})
+                .get("use_pickle", False)
+            )
+        else:
+            # If config is a dictionary
+            use_pickle = config.get("use_pickle", False)
+
+        path_manager = cls(use_pickle=use_pickle)
+
+        # Get paths from config
+        if hasattr(config, "paths"):
+            # If config is a ConfigReader instance
+            paths = config.paths
+        else:
+            # If config is a dictionary
+            paths = config.get("paths", {})
+
+        # Add paths from configuration if available
+        root_dir = find_project_root()
+        for name, path_info in paths.items():
+            if isinstance(path_info, dict) and "path" in path_info:
+                # Get path, drops, and use_pickle from path_info
+                path = path_info["path"]
+                # Convert Unix-style path to Windows path if on Windows
+                if os.name == "nt":  # Windows OS
+                    path = path.replace("/", "\\")
+
+                drops = path_info.get("drops", "")
+                path_use_pickle = path_info.get("use_pickle", False)
+
+                # Convert relative paths to absolute paths
+                if not os.path.isabs(path):
+                    path = os.path.join(root_dir, path)
+
+                # Add path to PathManager
+                path_manager.add_path(name, path, drops, path_use_pickle)
+
+        return path_manager
+
+    def find_parent_path(self, path: str) -> Optional[str]:
+        """
+        Find the parent path from self.paths that contains the given path.
+
+        Args:
+            path: The path to find the parent of
+
+        Returns:
+            The name of the parent path from self.paths that contains the given path,
+            or None if no parent is found
+        """
+        path_obj = Path(path)
+
+        # Convert to the absolute path if needed
+        if not path_obj.is_absolute():
+            path_obj = self.root_dir / path_obj
+
+        # Search through all paths in self.paths to find the one that contains path_obj
+        best_match = None
+        best_match_depth = -1
+
+        for path_name, path_info in self.paths.items():
+            registered_path = Path(path_info["path"])
+
+            try:
+                # Check if path_obj is under this registered path
+                path_obj.relative_to(registered_path)
+
+                # Calculate depth (number of parent directories)
+                depth = len(registered_path.parts)
+
+                # Keep the deepest match (the most specific parent)
+                if depth > best_match_depth:
+                    best_match = path_name
+                    best_match_depth = depth
+
+            except ValueError:
+                # path_obj is not under this registered path, continue
+                continue
+
+        return best_match

simstack/util/project_root_finder.py

@@ -0,0 +1,36 @@
+import os
+
+
+def find_project_root(
+    current_file=None, marker_files=(".git", "simstack.toml", "setup.py")
+):
+    """
+    Find the project root directory by searching for common marker files
+
+    Args:
+        current_file: Path to the current file, defaults to __file__ if None
+        marker_files: Tuple of files/directories that indicate the project root
+
+    Returns:
+        Absolute path to the project root directory
+    """
+    if current_file is None:
+        current_file = __file__
+
+    # Get the directory of the current file
+    current_dir = os.path.abspath(os.path.dirname(current_file))
+
+    # Walk up the directory tree until we find a marker file
+    prev_dir = None
+    while current_dir != prev_dir:
+        # Check if any marker files/directories exist in the current directory
+        for marker in marker_files:
+            if os.path.exists(os.path.join(current_dir, marker)):
+                return current_dir
+
+        # Move up one directory
+        prev_dir = current_dir
+        current_dir = os.path.abspath(os.path.join(current_dir, os.pardir))
+
+    # If we can't find any markers, return the directory of the current file
+    return os.path.abspath(os.path.dirname(current_file))