simstack 2.0.1__py3-none-any.whl

simstack/models/project.py

@@ -0,0 +1,13 @@
+from typing import List, Optional
+
+from odmantic import Model, Field, ObjectId
+
+
+class Project(Model):
+    field_name: str = Field(unique=True)
+    description: Optional[str] = None
+    tag_ids: List[ObjectId] = Field(default_factory=list)
+
+    model_config = {
+        "collection": "projects",
+    }

simstack/models/resource_assignment.py

@@ -0,0 +1,170 @@
+import re
+from typing import Optional, ClassVar, Dict, Any
+
+from odmantic import Field, Model, EmbeddedModel
+from pydantic import field_validator, model_validator
+
+
+class SlurmParametersPatch(EmbeddedModel):
+    nodes: Optional[int] = Field(default=None, ge=1)
+    tasks: Optional[int] = Field(default=None, ge=1)
+    tasks_per_node: Optional[int] = Field(default=None, ge=1)
+    cpus_per_task: Optional[int] = Field(default=None, ge=1)
+    mem: Optional[str] = None
+    mem_per_cpu: Optional[str] = None
+    time: Optional[str] = None
+    begin: Optional[str] = None
+    partition: Optional[str] = None
+    qos: Optional[str] = None
+    job_name: Optional[str] = None
+    output: Optional[str] = None
+    error: Optional[str] = None
+    mail_type: Optional[str] = None
+    mail_user: Optional[str] = None
+    gres: Optional[str] = None
+    account: Optional[str] = None
+    priority: Optional[int] = None
+    reservation: Optional[str] = None
+    constraint: Optional[str] = None
+    exclusive: Optional[bool] = None
+    nice: Optional[int] = None
+    dependency: Optional[str] = None
+    array: Optional[str] = None
+    startup_commands: Optional[list[str]] = None
+    chdir: Optional[str] = None
+    export: Optional[str] = None
+    signal: Optional[str] = None
+    requeue: Optional[bool] = None
+    no_requeue: Optional[bool] = None
+
+    model_config: ClassVar[Dict[str, Any]] = {
+        "extra": "forbid",
+    }
+
+
+class ResourceAssignmentRule(Model):
+    name: str = Field(unique=True)
+    regex_pattern: str
+    priority: int = Field(default=0)
+    enabled: bool = Field(default=True)
+    resource_str: Optional[str] = None
+    queue: Optional[str] = None
+    slurm_parameters_patch: Dict[str, Any] = Field(default_factory=dict)
+    description: Optional[str] = ""
+
+    model_config = {"collection": "resource_assignment_rule"}
+
+    @field_validator("name", "regex_pattern", mode="before")
+    @classmethod
+    def _strip_required_strings(cls, value):
+        if value is None:
+            return value
+        return str(value).strip()
+
+    @field_validator("resource_str", "queue", "description", mode="before")
+    @classmethod
+    def _strip_optional_strings(cls, value):
+        if value is None:
+            return None
+        normalized = str(value).strip()
+        return normalized or None
+
+    @field_validator("regex_pattern", mode="after")
+    @classmethod
+    def _validate_regex_pattern(cls, value: str) -> str:
+        if not value:
+            raise ValueError("Path pattern must not be empty")
+        try:
+            re.compile(cls.pattern_to_regex(value))
+        except ValueError:
+            raise
+        except re.error as exc:
+            raise ValueError(f"Invalid path pattern: {exc}") from exc
+        return value
+
+    @model_validator(mode="after")
+    def _validate_has_effect(self):
+        has_slurm_patch = bool(self.slurm_parameters_patch)
+        if not any([self.resource_str, self.queue, has_slurm_patch]):
+            raise ValueError(
+                "ResourceAssignmentRule must set at least one of resource_str, queue, or slurm_parameters_patch"
+            )
+        return self
+
+    @staticmethod
+    def normalize_pattern(pattern: str) -> str:
+        normalized = (pattern or "").strip()
+        if normalized.startswith("."):
+            without_leading_dots = normalized.lstrip(".")
+            if without_leading_dots and "." not in without_leading_dots:
+                return f"*.{without_leading_dots}"
+            return without_leading_dots
+        return normalized
+
+    @classmethod
+    def _pattern_segments(cls, pattern: str) -> list[str]:
+        return [
+            segment for segment in cls.normalize_pattern(pattern).split(".") if segment
+        ]
+
+    @staticmethod
+    def _segment_to_regex(segment: str) -> str:
+        return "".join("[^.]*" if char == "*" else re.escape(char) for char in segment)
+
+    @classmethod
+    def pattern_to_regex(cls, pattern: str) -> str:
+        segments = cls._pattern_segments(pattern)
+        if not segments:
+            raise ValueError("Path pattern must not be empty")
+        if segments == ["*"]:
+            return r"[^.]+(?:\.[^.]+)*"
+
+        regex_parts: list[str] = []
+        for index, segment in enumerate(segments):
+            if segment == "*":
+                regex_parts.append(r"(?:[^.]+\.)*" if index == 0 else r"(?:\.[^.]+)*")
+                continue
+
+            segment_regex = cls._segment_to_regex(segment)
+            previous_is_leading_wildcard = index == 1 and segments[0] == "*"
+            if index == 0 or previous_is_leading_wildcard:
+                regex_parts.append(segment_regex)
+            else:
+                regex_parts.append(r"\." + segment_regex)
+
+        return "".join(regex_parts)
+
+    @classmethod
+    def pattern_specificity_score(cls, pattern: str) -> int:
+        segments = cls._pattern_segments(pattern)
+        literal_segment_count = sum(1 for segment in segments if segment != "*")
+        literal_char_count = sum(len(segment.replace("*", "")) for segment in segments)
+        wildcard_count = sum(segment.count("*") for segment in segments)
+        return (
+            literal_segment_count * 10000
+            + literal_char_count * 100
+            + len(segments)
+            - wildcard_count
+        )
+
+    @classmethod
+    def matches_call_path(cls, pattern: str, normalized_call_path: str) -> bool:
+        return (
+            re.fullmatch(cls.pattern_to_regex(pattern), normalized_call_path)
+            is not None
+        )
+
+    @field_validator("slurm_parameters_patch", mode="before")
+    @classmethod
+    def _normalize_slurm_patch(cls, value):
+        if value is None:
+            return {}
+        if isinstance(value, SlurmParametersPatch):
+            return value.model_dump(exclude_none=True)
+        if isinstance(value, dict):
+            return SlurmParametersPatch.model_validate(value).model_dump(
+                exclude_none=True
+            )
+        raise ValueError(
+            "slurm_parameters_patch must be a dictionary or SlurmParametersPatch"
+        )

simstack/models/resource_definition.py

@@ -0,0 +1,125 @@
+from typing import Optional, List
+import urllib.parse
+import socket
+import re
+from pathlib import Path
+from odmantic import EmbeddedModel, Field, Model
+from pydantic import field_validator, model_serializer
+
+from simstack.util.transform_file_name import transform_file_name
+class GitRepo(Model):
+    """
+    Represents a Git repository with relevant attributes such as its URL, branch,
+    and whether it is a submodule. Ensures that the URL provided is valid.
+
+    This class is used to model information about a Git repository, including
+    its URL, the branch being used, and whether it is included as a submodule
+    within another repository. It provides validation for the URL to ensure that
+    it is in the correct format.
+
+    In the user database there is a list of Git repositories for the user
+
+    :ivar url: The URL of the Git repository.
+    :type url: str
+    :ivar branch: The branch of the Git repository. Optional.
+    :type branch: Optional[str]
+    :ivar is_submodule: Indicates whether the repository is a submodule. Defaults to False.
+    :type is_submodule: bool
+    """
+    url: str
+    branch: Optional[str]  
+    is_submodule: bool = Field(default=False)
+
+    @field_validator("url", mode="after")
+    @classmethod
+    def validate_url(cls, v):
+        try:
+            result = urllib.parse.urlparse(v)
+            if not all([result.scheme, result.netloc]):
+                raise ValueError("Invalid URL format")
+        except Exception:
+            raise ValueError("Invalid URL format")
+        return v
+
+class ResourceDefinition(Model):
+    resource_str: str = Field(unique=True)
+    workdir: str  # Change Path to str
+    hostname: str
+    python_paths: List[str] = Field(default_factory=list)  # Change List[Path] to List[str]
+    environment_start: Optional[str] = None
+    ssh_key: Optional[str] = None  # Change Optional[Path] to Optional[str]
+    routes: Optional[List[str]] = []
+    queue: str = "default"
+    is_default: bool = False
+    git_branch: str = "main"
+
+    @staticmethod
+    def _convert_backslashes(path_str: str) -> str:
+        return re.sub(r'\\+', '/', path_str)
+
+    @field_validator("workdir", mode="before")
+    @classmethod
+    def convert_workdir(cls, v):
+        if isinstance(v, (Path, str)):
+            return str(cls._convert_backslashes(str(v)))
+        return v
+
+    @field_validator("python_paths", mode="before")
+    @classmethod
+    def convert_python_paths(cls, v):
+        if isinstance(v, list):
+            return [str(cls._convert_backslashes(str(p))) for p in v]
+        return v
+
+    @field_validator("ssh_key", mode="before")
+    @classmethod
+    def convert_ssh_key(cls, v):
+        if v is None:
+            return None
+        return str(cls._convert_backslashes(str(v)))
+
+    @field_validator("queue", mode="before")
+    @classmethod
+    def normalize_queue(cls, v):
+        if v is None:
+            return "default"
+        normalized = str(v).strip()
+        return normalized or "default"
+
+
+    def validate_hostname(self):
+        current_hostname = socket.gethostname()
+        if self.hostname != current_hostname:
+            raise ValueError(f"Hostname must match current host. Expected: {current_hostname}, got: {self.hostname}")
+
+    def validate_ssh_key(self):
+        if self.ssh_key is not None:
+            file_path = transform_file_name(Path(self.ssh_key)) # Convert to Path for utility
+            if not file_path:
+                raise ValueError(f"SSH key path does not exist: {self.ssh_key}")
+
+    def get_ssh_key_path(self):
+        if self.ssh_key is not None:
+            return transform_file_name(Path(self.ssh_key))
+        return None
+
+    def validate_python_path(self):
+        for path_str in self.python_paths:
+            path = Path(path_str)
+            real_path = transform_file_name(path)
+            if not path.exists():
+                raise ValueError(f"Python path does not exist: {path}")
+            if not path.is_dir():
+                raise ValueError(f"Python path is not a directory: {path}")
+
+    def get_python_path(self):
+        if self.python_paths:
+            return [transform_file_name(Path(p)) for p in self.python_paths]
+        return None
+
+    def __repr__(self):
+        return f"ResourceDefinition(name={self.resource_str})"
+
+    @classmethod
+    def from_resource_definition(cls, resource_definition: dict):
+        return cls(**resource_definition)

simstack/models/runner_model.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+from enum import Enum
+from typing import Optional, List
+
+from odmantic import Model, ObjectId, Field
+from pydantic import ConfigDict
+
+from simstack.models.parameters import Resource
+
+
+class RunnerEventEnum(str, Enum):
+    SHUTDOWN = "shutdown"
+    RUNNER_STARTED = "runner_started"
+    NODE_STARTED = "node_started"
+    NODE_SUBMIT = "node_submit"
+    ALIVE = "alive"
+    RESTART = "restart"
+    CRONTAB_OK = "crontab_ok"
+    CRONTAB_GONE = "crontab_gone"
+
+
+class RunnerType(str, Enum):
+    NODE_RUNNER = "node_runner"
+    RESOURCE_RUNNER = "resource_runner"
+
+
+class RunnerEvent(Model):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    timestamp: datetime = Field(default_factory=datetime.now)
+    event: RunnerEventEnum
+    resource: Resource
+    runner_type: RunnerType
+    hostname: Optional[str] = None
+    user: Optional[str] = None
+    pid: Optional[int] = None
+    node_id: Optional[ObjectId] = None
+    message: Optional[str] = None
+    git_status: List[str] = Field(default_factory=list)

simstack/models/simple_table.py

@@ -0,0 +1,79 @@
+from enum import Enum
+from typing import Any, Dict, List
+
+from odmantic import Model, Field
+from pydantic import field_validator
+
+from simstack.models import simstack_model
+
+
+class SimpleTableColumnType(str, Enum):
+    STRING = "string"
+    NUMBER = "number"
+
+    @classmethod
+    def from_value(
+        cls, value: "SimpleTableColumnType | str"
+    ) -> "SimpleTableColumnType":
+        if isinstance(value, cls):
+            return value
+        if not isinstance(value, str):
+            raise ValueError(f"Invalid SimpleTable column type: {value!r}")
+
+        normalized = value.strip()
+        try:
+            return cls(normalized)
+        except ValueError:
+            pass
+
+        try:
+            return SIMPLE_TABLE_COLUMN_TYPE_LEGACY_ALIASES[normalized.lower()]
+        except KeyError as exc:
+            raise ValueError(f"Invalid SimpleTable column type: {value!r}") from exc
+
+
+SIMPLE_TABLE_COLUMN_TYPE_LEGACY_ALIASES = {
+    # Existing producers and stored DB documents used these variants before
+    # SimpleTable column types were narrowed to logical data types.
+    "str": SimpleTableColumnType.STRING,
+    "int": SimpleTableColumnType.NUMBER,
+    "float": SimpleTableColumnType.NUMBER,
+}
+
+
+@simstack_model
+class SimpleTable(Model):
+    """
+    A simple table model to display tabular data using ag-grid
+    """
+
+    name: str = Field(default="SimpleTable")
+    heading: List[str] = Field(default_factory=list)
+    row: List[Dict[str, Any]] = Field(default_factory=list)
+    type: List[SimpleTableColumnType] = Field(default_factory=list)
+
+    @field_validator("type", mode="before")
+    @classmethod
+    def normalize_column_types(cls, value: Any) -> Any:
+        if value is None:
+            return value
+        if isinstance(value, list):
+            return [SimpleTableColumnType.from_value(item) for item in value]
+        return value
+
+    def add_column(
+        self, column_name: str, column_type: SimpleTableColumnType | str
+    ) -> None:
+        if column_name not in self.heading:
+            self.heading.append(column_name)
+            self.type.append(SimpleTableColumnType.from_value(column_type))
+
+    def add_row(self, row: Dict[str, Any]) -> None:
+        self.row.append(row)
+
+    @classmethod
+    def ui_schema(cls) -> Dict[str, str]:
+        ui_schema = {
+            "ui:field": "SimpleTableField",
+        }
+        return ui_schema

simstack/models/simstack_model.py

@@ -0,0 +1,97 @@
+from functools import wraps
+from typing import TypeVar, Type, Any, get_type_hints, overload
+
+from simstack.util.cleaned_json_schema import cleaned_json_schema
+from simstack.util.custom_model_dump import custom_model_dump
+from simstack.util.default_from_dict import default_from_dict, default_from_model
+from simstack.util.generate_ui_schema import generate_ui_schema
+from simstack.util.ui_tools import ui_make_title
+
+T = TypeVar("T")
+
+
+@overload
+def simstack_model(cls: Type[T]) -> Type[T]:
+    ...
+
+
+def simstack_model(cls: T) -> T:
+    """
+    Decorates a given class to equip it with default implementations of utility
+    methods for handling operations such as dictionary conversion, schema
+    generation, and UI schema generation.
+    """
+
+    # Function to create a properly typed wrapper that preserves docstrings
+    def create_typed_wrapper(func, first_param_name="this_class"):
+        # Get original type hints
+        original_hints = get_type_hints(func)
+
+        # Create a wrapper with the correct parameters
+        @wraps(func)  # This preserves metadata like docstrings
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        # Add explicit docstring if not preserved by wraps
+        if not wrapper.__doc__ and func.__doc__:
+            wrapper.__doc__ = func.__doc__
+
+        # Copy the original function's annotations
+        wrapper.__annotations__ = {
+            first_param_name: Type[Any],  # the first param is now the class
+            **{
+                k: v
+                for k, v in original_hints.items()
+                if k != "return" and k != first_param_name
+            },
+        }
+
+        # Preserve the return annotation if it exists
+        if "return" in original_hints:
+            wrapper.__annotations__["return"] = original_hints["return"]
+
+        return wrapper
+
+    # Create typed wrappers for all functions with explicit docstrings
+    default_class_methods = {
+        "json_schema": create_typed_wrapper(cleaned_json_schema),
+        "ui_schema": create_typed_wrapper(generate_ui_schema),
+        "ui_make_title": create_typed_wrapper(ui_make_title),
+        "from_dict": create_typed_wrapper(default_from_dict),
+        "from_model": create_typed_wrapper(default_from_model),
+        #'make_column_defs': create_typed_wrapper(make_column_defs_helper),
+    }
+
+    # Add methods only if they don't exist
+    for method_name, default_implementation in default_class_methods.items():
+        if not hasattr(cls, method_name):
+            setattr(cls, method_name, classmethod(default_implementation))
+
+    default_methods = {
+        "custom_model_dump": custom_model_dump,
+        #'make_table_entries': make_table_entries_helper
+    }
+
+    # Add methods only if they don't exist
+    for method_name, default_implementation in default_methods.items():
+        if not hasattr(cls, method_name):
+            setattr(cls, method_name, default_implementation)
+
+    # Add a marker attribute to identify decorated classes
+    setattr(cls, "_is_simstack_model", True)
+
+    # Return the original class without casting - the overload handles the typing
+    return cls
+
+
+def is_simstack_model(cls: Type) -> bool:
+    """
+    Check if a class has been decorated with @simstack_model.
+
+    Args:
+        cls: The class to check
+
+    Returns:
+        bool: True if the class was decorated with @simstack_model, False otherwise
+    """
+    return getattr(cls, "_is_simstack_model", False)

simstack/models/slurm_info.py

@@ -0,0 +1,17 @@
+import datetime
+
+from odmantic import Model, ObjectId
+
+from simstack.models.parameters import Resource
+
+
+class SlurmInfo(Model):
+    node_registry: ObjectId
+    updated: datetime.datetime
+    resource: Resource
+    job_id: str
+    name: str
+    user: str
+    code: str
+    time: str
+    nodes: list[str]

simstack/models/table_artifact.py

@@ -0,0 +1,87 @@
+from typing import List, Optional, Dict, Any
+
+from odmantic import EmbeddedModel, Field, Model, ObjectId
+
+
+class AGGridColumnDef(EmbeddedModel):
+    """AG-Grid column definition with support for nested tables."""
+
+    # Core properties
+    field: str = Field(..., description="The field name in the row data to bind to")
+    headerName: str = Field(..., description="Display name for the column header")
+
+    # Sizing properties
+    width: Optional[int] = Field(default=None, description="Column width in pixels")
+    minWidth: Optional[int] = Field(
+        default=None, description="Minimum column width in pixels"
+    )
+    maxWidth: Optional[int] = Field(
+        default=None, description="Maximum column width in pixels"
+    )
+    flex: Optional[int] = Field(
+        default=None, description="Flex sizing for responsive columns"
+    )
+
+    # Display and interaction properties
+    hide: Optional[bool] = Field(default=None, description="Whether to hide the column")
+    # pinned: Optional[Literal["left", "right"]] = Field(default=None, description="Pin column to left or right")
+    sortable: Optional[bool] = Field(
+        default=None, description="Whether the column can be sorted"
+    )
+    resizable: Optional[bool] = Field(
+        default=None, description="Whether the column can be resized"
+    )
+    editable: Optional[bool] = Field(
+        default=None, description="Whether cells in this column are editable"
+    )
+
+    # # Filtering and rendering
+    # filter: Optional[Union[bool, str]] = Field(default=None, description="Filter type")
+    # cellRenderer: Optional[str] = Field(default=None, description="Custom cell renderer component")
+    # cellRendererParams: Optional[Dict[str, Any]] = Field(default=None, description="Parameters for cell renderer")
+
+    # # Master-Detail specific properties for nested tables
+    # cellRendererSelector: Optional[Dict[str, Any]] = Field(default=None, description="Function to select cell renderer based on data")
+    #
+    # # Nested table configuration
+    # is_nested_table: Optional[bool] = Field(default=False, description="Whether this column contains nested table data")
+    # nested_table_config: Optional[Dict[str, Any]] = Field(default=None, description="Configuration for nested table rendering")
+    #
+    # # Row grouping and detail rows
+    # rowGroup: Optional[bool] = Field(default=None, description="Whether this column is used for row grouping")
+    # showRowGroup: Optional[Union[bool, str]] = Field(default=None, description="Show row group column")
+    #
+    # # Additional properties
+    # custom_properties: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Additional custom properties")
+
+
+class TableArtifactModel(Model):
+    parent_id: ObjectId = Field(default=None, description="ID of the node registry")
+    columns_defs: List[AGGridColumnDef] = Field(
+        default_factory=list, description="AG-Grid column definitions"
+    )
+    row_data: List[Dict[str, Any]] = Field(
+        default_factory=list, description="List of row objects"
+    )
+
+    # Master-Detail configuration
+    master_detail: Optional[bool] = Field(
+        default=False, description="Enable master-detail rows"
+    )
+    detail_cell_renderer: Optional[str] = Field(
+        default=None, description="Detail panel cell renderer"
+    )
+    detail_cell_renderer_params: Optional[Dict[str, Any]] = Field(
+        default=None, description="Parameters for detail renderer"
+    )
+    # TODO implement nested tables and rendering
+    # # Nested tables storage - simplified to avoid recursion
+    # nested_tables: Optional[Dict[str, str]] = Field(default_factory=dict, description="Nested table IDs by reference key")
+    #
+    # # Tree data configuration
+    # tree_data: Optional[bool] = Field(default=False, description="Enable tree data structure")
+    # get_data_path: Optional[str] = Field(default=None, description="Function to get data path for tree structure")
+    #
+    # # Row grouping
+    # auto_group_column_def: Optional[AGGridColumnDef] = Field(default=None, description="Auto group column definition")
+    # group_default_expanded: Optional[int] = Field(default=None, description="Default expansion level for groups")

simstack/models/tag.py

@@ -0,0 +1,12 @@
+from typing import Optional
+
+from odmantic import Field, Model
+
+
+class Tag(Model):
+    name: str = Field(unique=True)
+    description: Optional[str] = None
+
+    model_config = {
+        "collection": "tags",
+    }

simstack/models/unused_test_file.py

@@ -0,0 +1,5 @@
+
+
+if __name__ == "__main__":
+    print("hi")
+

simstack/simstack_marker.com

@@ -0,0 +1 @@
+# this file makes sure that find_root keeps searching

simstack/static/docs/.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file records the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: a5fbdea24be32225dfc70ca293aee737
+tags: 645f666f9bcd5a90fca523b33c5a78b7