simstack 0.2.0__py3-none-any.whl

simstack/util/find_python_files.py

@@ -0,0 +1,33 @@
+import os
+from typing import List
+
+
+def find_python_files(directory: str) -> List[str]:
+    """
+    Returns full paths of all .py files in the given directory and its subdirectories,
+    excluding __init__.py files.
+
+    Args:
+        directory: The root directory to search from
+
+    Returns:
+        List of absolute file paths to all .py files that aren't __init__.py
+    """
+    python_files = []
+
+    # Ensure the directory exists
+    if not os.path.isdir(directory):
+        raise ValueError(f"'{directory}' is not a valid directory")
+
+    # Convert to absolute path
+    directory = os.path.abspath(directory)
+
+    # Walk through directory structure
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            # Check if it's a Python file but not __init__.py
+            if file.endswith(".py") and file != "__init__.py":
+                full_path = os.path.join(root, file)
+                python_files.append(full_path)
+
+    return python_files

simstack/util/generate_ui_schema.py

@@ -0,0 +1,80 @@
+from typing import Union
+
+
+def generate_ui_schema(cls):
+    """
+    Generates a UI schema that uses GenericForm for fields with ui_schema function.
+    Also preserves any existing UI schema configurations from the class.
+
+    Args:
+        cls: The model class to generate UI schema for
+
+    Returns:
+        dict: The generated UI schema
+    """
+    # Get base UI schema from the class if it exists
+
+    base_schema = cls.ui_base_schema() if hasattr(cls, "ui_base_schema") else {}
+
+    # Process each field in the model
+    for field_name, field in cls.model_fields.items():
+        field_type = field.annotation
+
+        # Unwrap Optional type to get the underlying type
+        if hasattr(field_type, "__origin__") and field_type.__origin__ is Union:
+            # Optional[X] is implemented as Union[X, None]
+            args = field_type.__args__
+            if len(args) == 2 and args[1] is type(None):
+                field_type = args[0]
+
+        # Handle Lists by checking their inner type
+        is_list = hasattr(field_type, "__origin__") and field_type.__origin__ is list
+        if is_list:
+            field_type = field_type.__args__[0]
+
+            # Check for Optional inside List
+            if hasattr(field_type, "__origin__") and field_type.__origin__ is Union:
+                args = field_type.__args__
+                if len(args) == 2 and args[1] is type(None):
+                    field_type = args[0]
+
+        # Check if field type has ui_schema method (this is true for all simstack_model classes)
+        if hasattr(field_type, "ui_schema"):
+            module_path = field_type.__module__
+            full_path = f"{module_path}.{field_type.__name__}"
+            # if simstack is in the module path, skip all elements after the last simstack occurrence
+            if "simstack" in module_path:
+                full_path = ".".join(
+                    module_path[module_path.rfind("simstack") :].split(".")
+                    + [field_type.__name__]
+                )
+
+            field_schema = field_type.ui_schema()  # get the field schema for the field
+            # Don't override if there's already a UI configuration for this field
+            if field_name not in base_schema:
+                if "ui:field" in field_schema:
+                    # If the field schema already has a ui:field, use it
+                    if is_list:
+                        base_schema[field_name] = {"items": field_schema}
+                    else:
+                        base_schema[field_name] = field_schema
+                else:
+                    # Check if field type is a list
+                    ui_ref = {
+                        "ui:field": "GenericFormField",
+                        "ui:options": {
+                            "model": full_path,
+                        },
+                    }
+                    # in rjsf the ui_scheme for list element must be in "items" key
+                    if is_list:
+                        base_schema[field_name] = {"items": ui_ref}
+                    else:
+                        ui_ref["ui:options"]["accordion"] = "true"
+                        base_schema[field_name] = ui_ref
+
+    # Always hide the id field if it exists
+    if "id" not in base_schema:
+        base_schema["id"] = {"ui:widget": "hidden"}
+
+    return base_schema

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,26 @@
+import os
+
+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 = os.path.abspath(file_path)
+
+    # # Get all directories in the Python path
+    # for path in sys.path:
+    #     if path and file_path.startswith(path):
+    #         # Remove the path prefix and the .py extension
+    #         relative_path = file_path[len(path):].lstrip(os.sep)
+    #         module_path = os.path.splitext(relative_path)[0].replace(os.sep, '.')
+    #         return module_path
+
+    # If not found in sys.path, use an alternative approach
+    project_root = find_project_root()  # Assumes running from project root
+    if file_path.startswith(project_root):
+        relative_path = file_path[len(project_root) :].lstrip(os.sep)
+        module_path = os.path.splitext(relative_path)[0].replace(os.sep, ".")
+        return module_path
+
+    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"], 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,93 @@
+# 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,
+        )
+
+    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,65 @@
+import importlib
+import logging
+import os
+import sys
+from pathlib import Path
+
+from simstack.util.project_root_finder import find_project_root
+
+logger = logging.getLogger("import_module_from_file")
+
+
+def import_module_from_file(file_path: Path):
+    """
+    Import a Python file as a module.
+
+    Args:
+        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 []
+
+        root_dir = find_project_root()
+        relative_path = file_path.relative_to(root_dir)
+        directory, filename = os.path.split(str(relative_path))
+        basename = filename.split(".")[0]
+
+        module_name = ".".join(relative_path.parts[:-1]) + "." + basename
+
+        if root_dir not in sys.path:
+            sys.path.insert(0, root_dir)
+            logger.debug(f"Added {root_dir} to sys.path")
+        # Try simple import first
+        try:
+            module = importlib.import_module(module_name)
+            return module
+        except ImportError as e:
+            logger.error(f"Direct import failed: {e}")
+
+            # 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:
+                print(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"Error 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,163 @@
+import importlib
+import logging
+from typing import Callable, Optional, Type
+
+from odmantic import Model, AIOEngine, ObjectId
+
+from simstack.core.context import context
+from simstack.core.engine import current_engine_context
+from simstack.models.models import ModelMapping, NodeModel
+
+logger = logging.getLogger("importer")
+
+
+async def function_from_model(model, task_id: ObjectId) -> Optional[Callable]:
+    function_path = model.function_mapping
+    module_path, function_name = function_path.rsplit(".", 1)
+
+    # if model.pickle_function is not None:
+    #     logger.info(f"task_id: {task_id} found pickle_function for {function_path}")
+    #     # The pickle_function is a reference to the FunctionPickle
+    #     function_pickle = model.pickle_function
+    #     logger.info(f"task_id: {task_id} loading function {function_path} from database")
+    #     # Load the function from the FunctionPickle
+    #     func = function_pickle.load_function()
+    #     logger.info(f"task_id: {task_id} Signature: {inspect.signature(func)} _inner: {hasattr(func, "_inner")}")
+    #
+    #     # Safe source code retrieval for pickled functions
+    #     try:
+    #         source_code = inspect.getsource(func)
+    #         logger.info(f"Source: {source_code}")
+    #     except (OSError, TypeError):
+    #         logger.info("Source code not available (function loaded from pickle)")
+    #
+    #     return func
+    # else:
+
+    logger.info(
+        f"task_id: {task_id} loading function {function_path} using regular import"
+    )
+    # Import the module
+    module = importlib.import_module(module_path)
+    # Get the function from the module
+    function = getattr(module, function_name)
+    return function
+
+
+async def import_function(
+    function_path: str, task_id: ObjectId = None
+) -> Optional[Callable]:
+    """
+    Dynamically import a function from a module using its full path.
+    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')
+        task_id: Optional task Id
+
+    Returns:
+        The imported function object or None if import fails
+    """
+    engine = current_engine_context.get()
+
+    node_model = await engine.find_one(
+        NodeModel, NodeModel.function_mapping == function_path
+    )
+    if node_model is None:
+        raise LookupError(
+            f"task_id: {task_id} Function {function_path} not found in the NodeModel Table"
+        )
+
+    return await function_from_model(node_model, task_id)
+
+
+async def import_function_by_name(
+    function_name: str, task_id: ObjectId, engine: AIOEngine = None
+) -> Optional[Callable]:
+    if not engine:
+        engine = context.db.engine
+
+    node_model = await engine.find_one(NodeModel, NodeModel.name == function_name)
+    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) -> 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:
+        class_path: Dot notation path to the class (e.g. 'models.submodule.ClassName')
+        :param class_path:
+    Returns:
+        The imported class object or None if import fails
+    """
+
+    try:
+        engine = current_engine_context.get()
+        # Split the path into module path and class name
+        module_path, class_name = class_path.rsplit(".", 1)
+        model_mapping = await engine.find_one(
+            ModelMapping, ModelMapping.name == class_name
+        )
+
+        # If not found by name, try by mapping
+        if not model_mapping:
+            model_mapping = await engine.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 not model_mapping:
+            logger.error(f"Error finding ModelMapping for {class_name}")
+            raise LookupError(f"Error finding ModelMapping for {class_name}")
+
+        # TODO where do picke classes come from?
+        # If we found a ModelMapping with a pickle_class reference, try to load from the database
+        # if model_mapping.pickle_class:
+        #     logger.info(f"Found ModelMapping for {class_name} with pickle_class")
+        #     try:
+        #         # The pickle_class is a reference to the ClassPickle
+        #         class_pickle = model_mapping.pickle_class
+        #         if class_pickle:
+        #             logger.info(f"Loading class {class_name} from database")
+        #             # Load the class from the ClassPickle
+        #             pickle_result = cast(Type[Model], class_pickle.load_class())
+        #             return pickle_result
+        #         else:
+        #             logger.warning(f"ClassPickle not found for {class_name}")
+        #             raise LookupError(f"ClassPickle not found for {class_name}")
+        #     except Exception as e:
+        #         logger.error(f"Error loading class {class_name} from database: {e}")
+        #         raise e
+        # else:
+
+        # Import the module
+        module = importlib.import_module(module_path)
+
+        # Get the class from the module
+        return 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) -> Type[Model]:
+    engine = current_engine_context.get()
+    model_mapping = await engine.find_one(ModelMapping, ModelMapping.name == class_name)
+
+    if not model_mapping:
+        logger.error(f"Error finding ModelMapping for {class_name}")
+        raise LookupError(f"Error finding ModelMapping for {class_name}")
+
+    return await import_class(model_mapping.mapping)