simstack 2.0.1__py3-none-any.whl

simstack/util/geometry_utils.py

@@ -0,0 +1,118 @@
+import math
+from typing import List
+
+
+def _normalize_vector(v: List[float]) -> List[float]:
+    """Normalize a vector to unit length."""
+    norm = math.sqrt(sum(x * x for x in v))
+    if norm < 1e-10:
+        return [1.0, 0.0, 0.0]  # Default direction for zero vector
+    return [x / norm for x in v]
+
+
+def _cross_product(a: List[float], b: List[float]) -> List[float]:
+    """Calculate cross product of two 3D vectors."""
+    return [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0],
+    ]
+
+
+def _get_perpendicular_direction(v1: List[float]) -> List[float]:
+    """Get a direction perpendicular to v1."""
+    # Find the component with smallest absolute value
+    min_idx = min(range(3), key=lambda i: abs(v1[i]))
+
+    # Create perpendicular vector
+    v2 = [0.0, 0.0, 0.0]
+    v2[min_idx] = 1.0
+
+    # Make it perpendicular using Gram-Schmidt
+    dot_product = sum(v1[i] * v2[i] for i in range(3))
+    for i in range(3):
+        v2[i] -= dot_product * v1[i]
+
+    return v2
+
+
+def _get_principal_direction(matrix: List[List[float]]) -> List[float]:
+    """Get the principal direction (largest eigenvalue direction) using power iteration."""
+    # Start with random vector
+    v = [1.0, 1.0, 1.0]
+
+    # Power iteration
+    for _ in range(10):  # Usually converges quickly
+        # v = matrix * v
+        new_v = [0.0, 0.0, 0.0]
+        for i in range(3):
+            for j in range(3):
+                new_v[i] += matrix[i][j] * v[j]
+
+        # Normalize
+        norm = math.sqrt(sum(x * x for x in new_v))
+        if norm > 1e-10:
+            v = [x / norm for x in new_v]
+
+    return v
+
+
+def _get_eigenvectors_3x3(matrix: List[List[float]]) -> List[List[float]]:
+    """
+    Get eigenvectors of a 3x3 matrix using simplified approach.
+    For the inertia tensor, we'll use a simplified canonical form.
+    """
+    # For molecular hashing, we can use a simplified approach
+    # that still provides rotation invariance
+
+    # Create an orthonormal basis from the inertia tensor
+    # Start with the direction of maximum variance
+    v1 = _get_principal_direction(matrix)
+
+    # Get a perpendicular direction
+    v2 = _get_perpendicular_direction(v1)
+
+    # Third direction is cross product
+    v3 = _cross_product(v1, v2)
+
+    # Normalize all vectors
+    v1 = _normalize_vector(v1)
+    v2 = _normalize_vector(v2)
+    v3 = _normalize_vector(v3)
+
+    # Return as columns of transformation matrix
+    return [[v1[0], v2[0], v3[0]], [v1[1], v2[1], v3[1]], [v1[2], v2[2], v3[2]]]
+
+
+def _get_canonical_orientation(coords: List[List[float]]) -> List[List[float]]:
+    """
+    Get coordinates in a canonical orientation using the inertia tensor.
+
+    :param coords: Centered coordinates of atoms
+    :return: Coordinates in canonical orientation
+    """
+    if len(coords) < 2:
+        return coords
+
+    # Calculate inertia tensor (3x3 matrix)
+    inertia_tensor = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
+
+    for pos in coords:
+        # I_ij = sum(r_k * r_l) where k,l are coordinate indices
+        for i in range(3):
+            for j in range(3):
+                inertia_tensor[i][j] += pos[i] * pos[j]
+
+    # Get eigenvalues and eigenvectors using power iteration method
+    eigenvectors = _get_eigenvectors_3x3(inertia_tensor)
+
+    # Transform coordinates to canonical orientation
+    canonical_coords = []
+    for coord in coords:
+        new_coord = [0.0, 0.0, 0.0]
+        for i in range(3):
+            for j in range(3):
+                new_coord[i] += coord[j] * eigenvectors[j][i]
+        canonical_coords.append(new_coord)
+
+    return canonical_coords

simstack/util/get_module_path.py

@@ -0,0 +1,20 @@
+import os
+from pathlib import Path
+
+from simstack.core.context import context
+from simstack.util.project_root_finder import find_project_root
+
+
+# Get the module name from the current file path
+def get_module_path(file_path: str):
+    # Get the absolute path of the current file
+    file_path = Path(file_path).resolve()
+    # If not found in sys.path, use an alternative approach
+    project_root = context.config.project_root  # Assumes running from project root
+    try:
+        relative_path = file_path.relative_to(project_root)
+
+        module_path = str(relative_path.with_suffix("")).replace(os.sep, ".")
+        return module_path
+    except ValueError:
+        return None

simstack/util/git_pull.py

@@ -0,0 +1,65 @@
+import logging
+import os
+import subprocess
+import time
+from datetime import datetime
+
+logger = logging.getLogger("git_pull")
+
+
+def git_pull_periodically(repo_path, interval_minutes=1, log_file=None):
+    """
+    Performs git pull in the specified repository at regular intervals.
+
+    Args:
+        repo_path (str): Path to the Git repository
+        interval_minutes (int): Time interval between pulls in minutes
+        log_file (str, optional): Path to log file. If None, logs to console.
+
+    Returns:
+        None
+    """
+
+    # Convert minutes to seconds
+    interval_seconds = interval_minutes * 60
+    logger.info("git_pull " + repo_path)
+    # Check if the path is a valid git repository
+    if not os.path.exists(os.path.join(repo_path, ".git")):
+        logging.error(f"The directory {repo_path} is not a valid Git repository.")
+        return
+
+    logging.info(
+        f"Starting periodic git pull every {interval_minutes} minutes for {repo_path}"
+    )
+
+    try:
+        while True:
+            try:
+                # Change to the repository directory
+                os.chdir(repo_path)
+
+                # Log the start time
+                now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                logging.info(f"Executing git pull at {now}")
+
+                # Execute git pull
+                result = subprocess.run(
+                    ["git", "pull", "--recurse-submodules"], capture_output=True, text=True, check=True
+                )
+
+                # Log the output
+                logging.info(f"Git pull output: {result.stdout.strip()}")
+                if result.stderr:
+                    logging.warning(f"Git pull stderr: {result.stderr.strip()}")
+
+            except subprocess.CalledProcessError as e:
+                logging.error(f"Git pull failed: {e.stderr.strip()}")
+            except Exception as e:
+                logging.error(f"Error during git pull: {str(e)}")
+
+            # Wait for the next interval
+            logging.info(f"Waiting {interval_minutes} minutes until next pull...")
+            time.sleep(interval_seconds)
+
+    except KeyboardInterrupt:
+        logging.info("Git pull process stopped by user.")

simstack/util/git_repository_status.py

@@ -0,0 +1,95 @@
+# Python
+import subprocess
+from pathlib import Path
+from typing import Optional, Dict
+
+
+def get_git_status(repo_path: Path) -> Dict[str, Optional[object]]:
+    """
+    Get the current Git short commit hash and whether the branch is up to date with its upstream.
+
+    Returns a dict:
+      {
+        "short_hash": Optional[str],   # e.g., "a1b2c3d", None if not a git repo
+        "branch": Optional[str],       # current branch name or "HEAD" if detached, None if not a repo
+        "up_to_date": Optional[bool],  # True/False if upstream exists, None if unknown/no upstream
+        "ahead": Optional[int],        # commits ahead of upstream (0 if up to date), None if unknown
+        "behind": Optional[int],       # commits behind upstream (0 if up to date), None if unknown
+      }
+    """
+
+    def run_git(args, check=False):
+        
+        return subprocess.run(
+            ["git", "-C", str(repo_path), *args],
+            capture_output=True,
+            text=True,
+            check=check,
+            timeout=30,
+        )
+
+    result: Dict[str, Optional[object]] = {
+        "short_hash": None,
+        "branch": None,
+        "up_to_date": None,
+        "ahead": None,
+        "behind": None,
+    }
+
+    # Verify we're in a git repository
+    try:
+        inside = run_git(["rev-parse", "--is-inside-work-tree"])
+        if inside.returncode != 0 or inside.stdout.strip() != "true":
+            return result  # Not a repository
+    except Exception:
+        return result
+
+    # Get short hash
+    try:
+        hash_res = run_git(["rev-parse", "--short", "HEAD"], check=True)
+        result["short_hash"] = hash_res.stdout.strip()
+    except subprocess.CalledProcessError:
+        # Detached or other state where HEAD isn't resolvable
+        result["short_hash"] = None
+
+    # Get branch (or "HEAD" if detached)
+    try:
+        branch_res = run_git(["rev-parse", "--abbrev-ref", "HEAD"], check=True)
+        result["branch"] = branch_res.stdout.strip()
+    except subprocess.CalledProcessError:
+        result["branch"] = None
+
+    # Find upstream; if none, we can't determine up-to-date status against a remote
+    try:
+        upstream_res = run_git(
+            ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]
+        )
+        if upstream_res.returncode != 0:
+            # No upstream configured
+            return result
+
+        upstream_ref = upstream_res.stdout.strip()
+
+        # Ensure we compare against the latest remote state
+        run_git(["fetch", "--quiet"])
+
+        # Compute ahead/behind relative to upstream
+        # Format: "<behind> <ahead>" because left is upstream, right is HEAD
+        counts_res = run_git(
+            ["rev-list", "--left-right", "--count", f"{upstream_ref}...HEAD"],
+            check=True,
+        )
+        behind_str, ahead_str = counts_res.stdout.strip().split()
+        behind, ahead = int(behind_str), int(ahead_str)
+
+        result["behind"] = behind
+        result["ahead"] = ahead
+        result["up_to_date"] = behind == 0 and ahead == 0
+    except subprocess.CalledProcessError:
+        # If comparison fails, leave up_to_date/ahead/behind as None
+        pass
+    except ValueError:
+        # Unexpected parsing format
+        pass
+
+    return result

simstack/util/import_module.py

@@ -0,0 +1,63 @@
+import importlib
+import logging
+import sys
+from pathlib import Path
+
+logger = logging.getLogger("import_module_from_file")
+
+
+def import_module_from_file(file_path: Path, root_dir: Path):
+    """
+    Import a Python file as a module.
+
+    Args:
+        root_dir:
+        file_path: Path object pointing to the Python file to import
+
+    Returns:
+        Imported module or None if import failed
+    """
+    try:
+        # logger.debug(f"Attempting to import module from: {file_path}")
+        if not file_path.exists():
+            print(f"File not found: {file_path}")
+            return []
+
+        relative_path = file_path.relative_to(root_dir)
+
+        basename = relative_path.stem
+        module_name = ".".join(relative_path.parts[:-1]) + "." + basename
+
+        if root_dir not in sys.path:
+            sys.path.insert(0, str(root_dir))
+            # logger.debug(f"Added {root_dir} to sys.path")
+        # Try a simple import first
+        try:
+            if module_name is None or module_name == "":
+                raise ImportError(f"Module name is None for file: {file_path}")
+            module = importlib.import_module(module_name)
+            return module
+        except ImportError as e:
+            logger.warning(f"Direct import failed: {e}  -- Trying spec-based import")
+
+            # Fall back to spec-based import
+            spec = importlib.util.spec_from_file_location(module_name, str(file_path))
+            if spec is None or spec.loader is None:
+                logger.error(f"Failed to create spec for {file_path}")
+                return None
+
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            try:
+                spec.loader.exec_module(module)
+                return module
+            except Exception as e:
+                logger.error(f"Import error when processing module: {file_path}  {e}")
+                return None
+
+    except Exception as e:
+        logger.error(f"Error importing module from {file_path}: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return None

simstack/util/importer.py

@@ -0,0 +1,312 @@
+import importlib
+import logging
+import re
+from typing import Any, Callable, Optional, Type, cast
+from odmantic import Model, AIOEngine, ObjectId
+
+from simstack.core.context import context
+from simstack.models.models import ModelMapping, NodeModel
+from simstack.util.db import Database
+
+logger = logging.getLogger("importer")
+
+NODES_SEARCH_BY_NAME_FALLBACK = True
+MODELS_SEARCH_BY_NAME_FALLBACK = True
+
+def _get_initialized_context() -> Any | None:
+    try:
+        from simstack.core.context import context
+
+        if context.initialized:
+            return context
+    except RuntimeError:
+        return None
+    return None
+
+
+def _context_cache_matches_engine(ctx: Any | None, db: Database | None = None) -> bool:
+    if ctx is None:
+        return False
+    if db is None:
+        return True
+    try:
+        return ctx.db is not None and db is ctx.db
+    except RuntimeError:
+        return False
+
+
+def _resolve_engine(ctx: Any | None, engine: AIOEngine | None = None) -> AIOEngine:
+    if engine is not None:
+        return engine
+    if ctx is not None:
+        try:
+            if ctx.db is not None:
+                return cast(AIOEngine, ctx.db.core_engine)
+        except RuntimeError:
+            pass
+    raise RuntimeError(
+        "Could not resolve engine both engine and context have no engine"
+    )
+
+
+def _lookup_node_cache(node_mappings: Any, function_path: str) -> Optional[NodeModel]:
+    if node_mappings is None:
+        return None
+    node_model = node_mappings.get_by_mapping(function_path)
+    if node_model is None and NODES_SEARCH_BY_NAME_FALLBACK:
+        if "." in function_path:
+            _, function_name = function_path.rsplit(".", 1)
+        else:
+            function_name = function_path
+        node_model = node_mappings.get_by_name(function_name)
+    return node_model
+
+
+async def _find_node_model(function_path: str, db: Database) -> Optional[NodeModel]:
+    if context.node_mappings is None:
+        await context.refresh_mappings(models=False, nodes=True)
+
+    node_model = _lookup_node_cache(context.node_mappings, function_path)
+    if node_model is not None:
+        return node_model
+
+    await context.refresh_mappings(models=False, nodes=True)
+    node_model = _lookup_node_cache(context.node_mappings, function_path)
+    if node_model is not None:
+        return node_model
+
+    node_model = await db.find_one(
+        NodeModel, NodeModel.function_mapping == function_path
+    )
+    if node_model is None and NODES_SEARCH_BY_NAME_FALLBACK:
+        if "." in function_path:
+            _, function_name = function_path.rsplit(".", 1)
+        else:
+            function_name = function_path
+        node_model = await db.find_one(NodeModel, NodeModel.name == function_name)
+    return node_model
+
+
+async def _find_node_model_by_name(
+    function_name: str, db: Database
+) -> Optional[NodeModel]:
+    if context.node_mappings is None:
+        await context.refresh_mappings(models=False, nodes=True)
+
+    node_model = context.node_mappings.get_by_name(function_name)
+    if node_model is not None:
+        return node_model
+
+    await context.refresh_mappings(models=False, nodes=True)
+    node_model = context.node_mappings.get_by_name(function_name)
+    if node_model is not None:
+        return node_model
+    return await db.find_one(NodeModel, NodeModel.name == function_name)
+
+
+def _lookup_model_cache(
+    model_mappings: Any, class_path: str, class_name: str
+) -> Optional[ModelMapping]:
+    if model_mappings is None:
+        return None
+    model_mapping = None
+    if MODELS_SEARCH_BY_NAME_FALLBACK:
+        model_mapping = model_mappings.get_by_name(class_name)
+    if not model_mapping:
+        model_mapping = model_mappings.get_by_mapping(class_path)
+    return model_mapping
+
+
+async def _find_model_mapping(model_path: str, db: Database) -> Optional[ModelMapping]:
+    _, model_name = model_path.rsplit(".", 1)
+
+    if context.model_mappings is None:
+        await context.refresh_mappings(models=True, nodes=False)
+
+    model_mapping = _lookup_model_cache(context.model_mappings, model_path, model_name)
+    if model_mapping is not None:
+        return model_mapping
+
+    await context.refresh_mappings(models=True, nodes=False)
+    model_mapping = _lookup_model_cache(context.model_mappings, model_path, model_name)
+    if model_mapping is not None:
+        return model_mapping
+
+    model_mapping = None
+    if MODELS_SEARCH_BY_NAME_FALLBACK:
+        model_mapping = await db.find_one(ModelMapping, ModelMapping.name == model_name)
+    if model_mapping is None:
+        model_mapping = await db.find_one(
+            ModelMapping, ModelMapping.mapping == model_path
+        )
+    return model_mapping
+
+
+# TODO engines remove: duplicate of find_class_mapping_by_name
+async def _find_model_mapping_by_name(
+    class_name: str, db: Database
+) -> Optional[ModelMapping]:
+    if context.model_mappings is None:
+        await context.refresh_mappings(models=True, nodes=False)
+
+    model_mapping = context.model_mappings.get_by_name(class_name)
+    if model_mapping is not None:
+        return model_mapping
+
+    await context.refresh_mappings(models=True, nodes=False)
+    model_mapping = context.model_mappings.get_by_name(class_name)
+    if model_mapping is not None:
+        return model_mapping
+
+    return await db.find_one(ModelMapping, ModelMapping.name == class_name)
+
+
+async def _function_from_model(
+    node_model: NodeModel, task_id: ObjectId | None = None
+) -> Callable[..., Any]:
+    """
+    Get the function from the NodeModel. Here the mapping may already be fixed if the original mapping was wrong
+    Otherwise, it is imported from the function_mapping.
+
+    Args:
+        node_model: NodeModel object
+        task_id: Optional task id
+
+    Returns:
+        The function object
+    """
+
+    function_path = node_model.function_mapping
+    try:
+        module_path, function_name = function_path.rsplit(".", 1)
+        module = importlib.import_module(module_path)
+        return cast(Callable[..., Any], getattr(module, function_name))
+    except (ImportError, AttributeError, ValueError) as e:
+        if NODES_SEARCH_BY_NAME_FALLBACK:
+            try:
+                # Try to load by the name field which might contain the correct path
+                # if it was a name-only search that found this model.
+                if "." in node_model.name:
+                    module_path, function_name = node_model.name.rsplit(".", 1)
+                    module = importlib.import_module(module_path)
+                    return cast(Callable[..., Any], getattr(module, function_name))
+            except (ImportError, AttributeError, ValueError):
+                pass
+        logger.error(
+            f"task_id: {task_id} Error importing function {function_path}: {e}"
+        )
+        raise e
+
+
+async def import_function(
+    function_path: str,
+    db: Database,
+    task_id: ObjectId | None = None,
+    tolerate_missing_function: bool = False,
+) -> Optional[Callable[..., Any]]:
+    """
+    Dynamically import a function from a module using its full path, including a migration mechanism.
+    load the function information using NodeModel
+    load the pickled version if it exists
+    if there is no pickled version, use regular import.
+
+    Args:
+        function_path: Dot notation path to the function (e.g. 'methods.submodule.function_name')
+        db: Database object
+        task_id: Optional task id
+        tolerate_missing_function: If True, return None if function is not found, otherwise raise exception
+
+    Returns:
+        The imported function object or None if import fails
+    """
+    node_model = await _find_node_model(function_path, db)
+
+    if node_model is None:
+        try:
+            module_path, function_name = function_path.rsplit(".", 1)
+            module = importlib.import_module(module_path)
+            return cast(Callable[..., Any], getattr(module, function_name))
+        except (ImportError, AttributeError, ValueError):
+            raise LookupError(
+                f"task_id: {task_id} Function {function_path} not found in the NodeModel Table"
+            )
+
+    try:
+        return await _function_from_model(node_model, task_id)
+    except Exception as e:
+        if tolerate_missing_function:
+            return None
+        else:
+            raise e
+
+
+async def import_function_by_name(
+    function_name: str, db: Database, task_id: ObjectId
+) -> Optional[Callable[..., Any]]:
+    node_model = await _find_node_model_by_name(function_name, db)
+
+    if node_model is None:
+        logger.error(f"Could not find function mapping for name: {function_name}")
+        raise ValueError(f"Could not find function mapping for name: {function_name}")
+
+    return await _function_from_model(node_model, task_id)
+
+
+async def import_class(class_path: str, db: Database) -> Type[Model] | None:
+    """
+    Dynamically import a class from a module using its full path.
+    First tries to load the class from the database using ModelMapping
+
+    A pickled version of the class is used primarily
+    Args:
+
+        :param class_path:   class_path: Dot notation path to the class (e.g. 'models.submodule.ClassName')
+        :param db:    db: Database object
+    Returns:
+        The imported class object or None if import fails
+    """
+
+    try:
+        # Split the path into module path and class name
+        module_path, class_name = class_path.rsplit(".", 1)
+        model_mapping = await _find_model_mapping(class_path, db)
+
+        # If not found by name, try by mapping
+        if not model_mapping:
+            model_mapping = await db.find_one(
+                ModelMapping, ModelMapping.mapping == class_path
+            )
+        else:  # when searching by name, the path may have changed
+            module_path, class_name = model_mapping.mapping.rsplit(".", 1)
+
+        if model_mapping is None:
+            try:
+                # Import the module
+                module = importlib.import_module(module_path)
+                # Get the class from the module
+                return cast(Type[Model], getattr(module, class_name))
+            except (ImportError, AttributeError):
+                logger.error(f"Error finding ModelMapping for {class_name}")
+                raise LookupError(f"Error finding ModelMapping for {class_name}")
+
+        # Import the module
+        module = importlib.import_module(module_path)
+
+        # Get the class from the module
+        return cast(Type[Model], getattr(module, class_name))
+    except (ImportError, AttributeError, ValueError) as e:
+        logger.error(f"Error importing class {class_path}: {e}")
+        raise e
+
+
+async def import_class_by_name(class_name: str, db: Database) -> Type[Model]:
+    model_mapping = await _find_model_mapping_by_name(class_name, db)
+
+    if not model_mapping:
+        logger.error(f"Error finding ModelMapping for {class_name}")
+        raise LookupError(f"Error finding ModelMapping for {class_name}")
+
+    model_class = await import_class(model_mapping.mapping, db)
+    if model_class is None:
+        raise LookupError(f"Error importing mapped model class for {class_name}")
+    return model_class