autosim 0.0.1__tar.gz

autosim-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The Alan Turing Institute
+
+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.

autosim-0.0.1/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.3
+Name: autosim
+Version: 0.0.1
+Summary: A package to generate simulation data easily
+Author: AI for Physical Systems Team at The Alan Turing Institute
+Author-email: AI for Physical Systems Team at The Alan Turing Institute <ai4physics@turing.ac.uk>
+License: MIT License
+         
+         Copyright (c) 2026 The Alan Turing Institute
+         
+         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.
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: tqdm>=4.65
+Requires-Dist: torch>=2.0
+Requires-Dist: ipykernel>=7.1.0 ; extra == 'dev'
+Requires-Dist: pytest>=9.0.1 ; extra == 'dev'
+Requires-Dist: pytest-cov>=7.0.0 ; extra == 'dev'
+Requires-Dist: ruff==0.12.11 ; extra == 'dev'
+Requires-Dist: pyright==1.1.407 ; extra == 'dev'
+Requires-Dist: pre-commit>=4.4.0 ; extra == 'dev'
+Requires-Dist: matplotlib ; extra == 'dev'
+Requires-Python: >=3.10, <3.13
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# autosim
+Lots of Simulations
+
+## Installation
+
+This project uses [uv](https://docs.astral.sh/uv/) for dependency management.
+
+### Install uv
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+### Install the package
+
+```bash
+uv pip install -e .
+```
+
+This installs `autosim` in editable mode along with its runtime dependencies:
+- `numpy>=1.24`
+- `scipy>=1.10`
+- `tqdm>=4.65`
+- `torch>=2.0`
+
+### Install development dependencies (includes pytest)
+
+```bash
+uv sync --group dev
+```
+
+## Running tests
+
+Once dev dependencies are installed:
+
+```bash
+uv run pytest
+```

autosim-0.0.1/README.md

@@ -0,0 +1,38 @@
+# autosim
+Lots of Simulations
+
+## Installation
+
+This project uses [uv](https://docs.astral.sh/uv/) for dependency management.
+
+### Install uv
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+### Install the package
+
+```bash
+uv pip install -e .
+```
+
+This installs `autosim` in editable mode along with its runtime dependencies:
+- `numpy>=1.24`
+- `scipy>=1.10`
+- `tqdm>=4.65`
+- `torch>=2.0`
+
+### Install development dependencies (includes pytest)
+
+```bash
+uv sync --group dev
+```
+
+## Running tests
+
+Once dev dependencies are installed:
+
+```bash
+uv run pytest
+```

autosim-0.0.1/pyproject.toml

@@ -0,0 +1,98 @@
+[project]
+name = "autosim"
+version = "0.0.1"
+description = "A package to generate simulation data easily"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "AI for Physical Systems Team at The Alan Turing Institute", email = "ai4physics@turing.ac.uk" },
+]
+requires-python = ">=3.10,<3.13"
+
+dependencies = [
+    "numpy>=1.24",
+    "scipy>=1.10",
+    "tqdm>=4.65",
+    "torch>=2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ipykernel>=7.1.0",
+    "pytest>=9.0.1",
+    "pytest-cov>=7.0.0",
+    "ruff==0.12.11",
+    "pyright==1.1.407",
+    "pre-commit>=4.4.0",
+    "matplotlib"
+]
+
+[build-system]
+requires = ["uv_build"]
+build-backend = "uv_build"
+
+[tool.coverage.run]
+relative_files = true
+source = [".", "/tmp"]
+
+[tool.pytest.ini_options]
+addopts = "--ignore=v0"
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = [
+    "D",   # docstring conventions
+    "E",
+    "F",
+    "W",   # flake8
+    "B",   # flake8-bugbear
+    "I",   # isort
+    "ARG", # flake8-unused-arguments
+    "C4",  # flake8-comprehensions
+    "EM",  # flake8-errmsg
+    "ICN", # flake8-import-conventions
+    "ISC", # flake8-implicit-str-concat
+    "G",   # flake8-logging-format
+    "PGH", # pygrep-hooks
+    "PIE", # flake8-pie
+    "PL",  # pylint
+    "PT",  # flake8-pytest-style
+    "RET", # flake8-return
+    "RUF", # Ruff-specific
+    "SIM", # flake8-simplify
+    "UP",  # pyupgrade
+    "YTT", # flake8-2020
+    "EXE", # flake8-executable
+]
+
+ignore = [
+    "PLR2004", # Magic value used in comparison
+    "EM102",   # Exception must not use an f-string literal, assign to variable first
+    "ISC001",  # Conflicts with formatter
+    # "D417",    # Missing trailing new line in docstring
+    "D100",    # Missing docstring in public module
+    "D104",    # Missing docstring in public package
+    "PLR0913", # too many arguments
+]
+
+unfixable = [
+    "F401", # Would remove unused imports
+    "F841", # Would remove unused variables
+]
+flake8-unused-arguments.ignore-variadic-names = true # allow unused *args/**kwargs
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*.py" = ["D"]

autosim-0.0.1/src/autosim/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

autosim-0.0.1/src/autosim/device.py

@@ -0,0 +1,191 @@
+import logging
+import os
+
+import torch
+from torch import nn
+
+from autosim.types import DeviceLike, TensorLike
+
+SUPPORTED_DEVICES: list[str] = ["cpu", "mps", "cuda", "xpu"]
+
+# Set this environment variable (to anything) to force mps to turn off.
+# This is necessary because in github runners
+# torch.backends.mps.is_available() returns true although it isn't.
+if "TURN_OFF_MPS_IF_RUNNING_CI" in os.environ:
+    TURN_OFF_MPS_IF_RUNNING_CI = True
+else:
+    TURN_OFF_MPS_IF_RUNNING_CI = False
+
+
+class TorchDeviceError(NotImplementedError):
+    """Exception raised when the device is not implemented in torch."""
+
+    def __init__(self, device: str):
+        msg = f"Backend ({device}) not implemented."
+        super().__init__(msg)
+
+
+def get_torch_device(device: DeviceLike | None) -> torch.device:
+    """
+    Get the device returning the torch default device if None.
+
+    Parameters
+    ----------
+    device: DeviceLike | None
+        The device to get. If None, the default torch device is returned.
+
+    Returns
+    -------
+    torch.device
+        The device.
+
+    Raises
+    ------
+    TorchDeviceError
+        If the device is not a valid torch device.
+    """
+    if isinstance(device, torch.device):
+        return device
+    if device is None:
+        return torch.get_default_device()
+    if device in SUPPORTED_DEVICES:
+        return torch.device(device)
+    raise TorchDeviceError(device)
+
+
+def move_tensors_to_device(
+    *args: TensorLike, device: torch.device
+) -> tuple[TensorLike, ...]:
+    """
+    Move the given tensor to the device.
+
+    Parameters
+    ----------
+    *args: TensorLike
+        The tensors to move.
+    device: torch.device
+        The device to move the tensors to.
+
+    Returns
+    -------
+    tuple[TensorLike, ...]
+        The tensors on the device.
+    """
+    return tuple(tensor.to(device) for tensor in args)
+
+
+# ruff: noqa: PLR0911
+def check_torch_device_is_available(device: DeviceLike) -> bool:
+    """
+    Check if the given device type is available.
+
+    Parameters
+    ----------
+    device: DeviceLike
+        The device to check.
+
+    Returns
+    -------
+    bool
+        True if the device is available, False otherwise.
+
+    Raises
+    ------
+    TorchDeviceError
+        If the device is not a valid torch device.
+    """
+    if device == "cpu" or (
+        isinstance(device, torch.device) and device.type == torch.device("cpu").type
+    ):
+        return True
+    if device == "mps" or (
+        isinstance(device, torch.device) and device.type == torch.device("mps").type
+    ):
+        if TURN_OFF_MPS_IF_RUNNING_CI:
+            return False
+        return torch.backends.mps.is_available()
+    if device == "cuda":
+        return torch.cuda.is_available()
+    if isinstance(device, torch.device) and device.type == "cuda":
+        if device.index is not None:
+            return device.index < torch.cuda.device_count()
+        return True
+    if device == "xpu" or (
+        isinstance(device, torch.device) and device.type == torch.device("xpu").type
+    ):
+        return torch.xpu.is_available() if hasattr(torch, "xpu") else False
+    raise TorchDeviceError(str(device))
+
+
+def check_model_device(model: nn.Module, expected_device: str) -> bool:
+    """
+    Check if the model is on the expected device.
+
+    Parameters
+    ----------
+    model: nn.Module
+        The model to check.
+    expected_device: str
+        The expected device.
+
+    Returns
+    -------
+    bool
+        True if the model is on the expected device (ignoring device index), False
+        otherwise.
+    """
+    return (
+        str(next(model.parameters()).device).split(":")[0]
+        == str(expected_device).split(":")[0]
+    )
+
+
+class TorchDeviceMixin:
+    """
+    Mixin class to add device management to a PyTorch model.
+
+    Attributes
+    ----------
+    device: torch.device
+        The device to use. If None, the default torch device is used.
+
+    Raises
+    ------
+    TorchDeviceError
+        If the device is not a valid torch device.
+    """
+
+    def __init__(self, device: DeviceLike | None = None, cpu_only: bool = False):
+        # Warn if given device not CPU and cpu_only
+        # TODO: check handling
+        if cpu_only and (
+            (isinstance(device, str) and device != "cpu")
+            or (isinstance(device, torch.device) and torch.device("cpu") != device)
+        ):
+            msg = (
+                f"The device ({device}) must be CPU for given model. Setting device as "
+                "'cpu'."
+            )
+            # warnings.warn(msg, stacklevel=2)
+            logging.warning(msg)
+
+        self.device = get_torch_device(device)
+
+        if not check_torch_device_is_available(self.device):
+            raise TorchDeviceError(str(self.device))
+
+    def _move_tensors_to_device(self, *args: TensorLike) -> tuple[TensorLike, ...]:
+        """
+        Move the given tensor to the device.
+
+        Parameters
+        ----------
+        *args: TensorLike
+            The tensors to move.
+
+        Returns
+        -------
+        tuple[TensorLike, ...]
+            The tensors on the device.
+        """
+        return move_tensors_to_device(*args, device=self.device)

autosim-0.0.1/src/autosim/logging.py

@@ -0,0 +1,125 @@
+import logging
+import os
+import sys
+from pathlib import Path
+
+
+def configure_logging(log_to_file=False, level: str = "INFO"):
+    """
+    Configure the logging system.
+
+    Parameters
+    ----------
+    log_to_file: bool or string, optional
+        If True, logs will be written to a file.
+        If a string, logs will be written to the specified file.
+    verbose: str, optional
+        The verbosity level. Can be "critical", "error", "warning",
+          "info", or "debug". Defaults to "info".
+    """
+    logger = logging.getLogger("autosim")
+    logger.handlers = []  # Clear existing handlers
+
+    logger.setLevel(logging.DEBUG)
+
+    verbose_lower = level.lower()
+    match verbose_lower:
+        case "error":
+            console_log_level = logging.ERROR
+        case "warning":
+            console_log_level = logging.WARNING
+        case "info":
+            console_log_level = logging.INFO
+        case "debug":
+            console_log_level = logging.DEBUG
+        case "critical":
+            console_log_level = logging.CRITICAL
+        case _:
+            msg = 'verbose must be "critical", "error", "warning", "info", or "debug"'
+            raise ValueError(msg)
+
+    # Create console handler with a higher log level
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(console_log_level)
+
+    # Create formatter and add it to the handler
+    # formatter = logging.Formatter("%(name)s - %(message)s")
+    formatter = logging.Formatter("%(levelname)-8s%(asctime)s - %(name)s - %(message)s")
+    ch.setFormatter(formatter)
+
+    # Add the handler to the logger
+    logger.addHandler(ch)
+
+    # Optionally log to a file
+    if log_to_file:
+        if isinstance(log_to_file, bool):
+            log_file_path = Path.cwd() / "autosim.log"
+        else:
+            log_file_path = Path(log_to_file)
+        # Create the directory if it doesn't exist
+        log_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        log_file_dir = os.path.dirname(log_file_path)
+        if log_file_dir and not os.path.exists(log_file_dir):
+            os.makedirs(log_file_dir)
+
+        try:
+            fh = logging.FileHandler(log_file_path)
+            fh.setLevel(logging.DEBUG)
+            fh.setFormatter(formatter)
+            logger.addHandler(fh)
+        except Exception:
+            logger.exception("Failed to create log file at %s", log_file_path)
+
+    # Capture (model) warnings and redirect them to the logging system
+    logging.captureWarnings(True)
+
+    warnings_logger = logging.getLogger("py.warnings")
+    for handler in logger.handlers:
+        warnings_logger.addHandler(handler)
+    warnings_logger.setLevel(logger.getEffectiveLevel())
+
+    return logger
+
+
+def get_configured_logger(
+    log_level, progress_bar_attr="progress_bar"
+) -> tuple[logging.Logger, bool]:
+    """
+    Configure logger and progress bar flag consistently.
+
+    Parameters
+    ----------
+    log_level: str
+        The logging level to set. Can be "progress_bar", "debug", "info",
+        "warning", "error", or "critical".
+    progress_bar_attr: str
+        The attribute to check for progress bar. If log_level is set to this value,
+        the logger will be set to "error" level and progress_bar will be True. Defaults
+        to "progress_bar".
+
+    Returns
+    -------
+    tuple[logging.Logger, bool]
+        The configured logger and the progress bar flag.
+    """
+    valid_log_levels = [
+        "progress_bar",
+        "debug",
+        "info",
+        "warning",
+        "error",
+        "critical",
+    ]
+    log_level = log_level.lower()
+    if log_level not in valid_log_levels:
+        raise ValueError(
+            f"Invalid log level: {log_level}. Must be one of: {valid_log_levels}"
+        )
+    if log_level == progress_bar_attr:
+        log_level = "error"
+        progress_bar = True
+    else:
+        progress_bar = False
+    logger = configure_logging(level=log_level)
+    return logger, progress_bar

autosim-0.0.1/src/autosim/simulations/__init__.py

@@ -0,0 +1,22 @@
+from .epidemic import Epidemic
+from .flow_problem import FlowProblem
+from .projectile import Projectile, ProjectileMultioutput
+from .seir import SEIRSimulator
+
+ALL_SIMULATORS = [
+    Epidemic,
+    SEIRSimulator,
+    FlowProblem,
+    Projectile,
+    ProjectileMultioutput,
+]
+
+__all__ = [
+    "Epidemic",
+    "FlowProblem",
+    "Projectile",
+    "ProjectileMultioutput",
+    "SEIRSimulator",
+]
+
+SIMULATOR_REGISTRY = dict(zip(__all__, ALL_SIMULATORS, strict=False))