1519 memilio-simulation PyPI package

.github/actions/build-py/action.yml

@@ -6,24 +6,38 @@ inputs:
     required: true
 runs:
   using: "composite"
-  steps:    
+  steps:
+    - name: Configure Git safe directory
+      shell: bash 
+      run: git config --global --add safe.directory /__w/memilio/memilio    
     - name: Install dependencies
       shell: bash
       run: yum install ninja-build cmake git -qy
     - name: Make artifact dir
       shell: bash
       run: |
-        cd pycode/memilio-${{ inputs.package }}/
+        if [ "${{ inputs.package }}" != "simulation" ]; then
+          cd pycode/memilio-${{ inputs.package }}/
+        # else stay in root directory
+        fi
         mkdir wheelhouse
     - name: Build Python Wheels
       shell: bash
       run: |
-        cd pycode/memilio-${{ inputs.package }}/
+        if [ "${{ inputs.package }}" != "simulation" ]; then
+          cd pycode/memilio-${{ inputs.package }}/
+        # else stay in root directory
+        fi
         /opt/python/cp38-cp38/bin/python -m pip install --upgrade pip setuptools wheel
-        /opt/python/cp38-cp38/bin/python -m pip install scikit-build scikit-build-core
-        /opt/python/cp38-cp38/bin/python -m build --no-isolation --wheel
         /opt/python/cp312-cp312/bin/python -m pip install --upgrade pip setuptools wheel
+        /opt/python/cp38-cp38/bin/python -m pip install scikit-build scikit-build-core 
         /opt/python/cp312-cp312/bin/python -m pip install scikit-build scikit-build-core
+        # Install setuptools-scm only for memilio-simulation
+        if [ "${{ inputs.package }}" == "simulation" ]; then
+          /opt/python/cp38-cp38/bin/python -m pip install setuptools-scm
+          /opt/python/cp312-cp312/bin/python -m pip install setuptools-scm
+        fi
+        /opt/python/cp38-cp38/bin/python -m build --no-isolation --wheel
         /opt/python/cp312-cp312/bin/python -m build --no-isolation --wheel
         # Exclude memilio-generation, because its a pure python package, cmake is only used in the build process to retrieve data from cpp
         if [[ -f "CMakeLists.txt" ]] && [ "${{ inputs.package }}" != "generation" ]; then 
@@ -33,7 +47,11 @@ runs:
           # no auditwheel necessary for pure python packages, so only copy the wheels to the same output directory 
           cp dist/*.whl wheelhouse
         fi
-        cp -r wheelhouse ..
+        if [ "${{ inputs.package }}" != "simulation" ]; then
+          cp -r wheelhouse ..
+        else
+          cp -r wheelhouse pycode
+        fi 
     - name: Upload Python Wheels
       uses: actions/upload-artifact@v4
       with:

.github/workflows/pypi.yml

@@ -0,0 +1,62 @@
+name: PyPI
+
+on:  
+  release:  
+    types:  
+      - published
+
+jobs:
+
+  build_wheels:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: pypa/cibuildwheel@v3.4.1
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-${{ matrix.os }}
+          path: ./wheelhouse/*.whl
+
+  build_sdist: 
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - run: pipx run build --sdist
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: cibw-sdist
+        path: dist/*.tar.gz
+
+  upload_pypi:
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          # unpacks all CIBW artifacts into dist/
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
+          # To test uploads to TestPyPI, uncomment the following:
+          # repository-url: https://test.pypi.org/legacy/

CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.14)
+project(memilio-simulation)
+
+set(CMAKE_CXX_STANDARD "20")
+set(CMAKE_CXX_STANDARD_REQUIRED "20")
+
+# add in C++ library
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/cpp ${CMAKE_CURRENT_BINARY_DIR}/cpp EXCLUDE_FROM_ALL)
+
+add_subdirectory(pycode/memilio-simulation)

README.md

@@ -1,6 +1,6 @@
 # MEmilio - a high performance Modular EpideMIcs simuLatIOn software #
 
-![memilio_logo](docs/memilio-small.png)
+![memilio_logo](https://github.com/SciCompMod/memilio/blob/main/docs/memilio-small.png?raw=true)
 
 [![CI](https://github.com/SciCompMod/memilio/actions/workflows/main.yml/badge.svg)](https://github.com/SciCompMod/memilio/actions/workflows/main.yml)
 [![codecov](https://codecov.io/gh/SciCompMod/memilio/branch/main/graph/badge.svg?token=DVQXIQJHBM)](https://codecov.io/gh/SciCompMod/memilio)

docs/source/getting_started.rst

@@ -300,39 +300,70 @@ Option A: Installing the Python packages (Recommended for nonexperienced users o
 
 You can run simulations, download data, or create plots, by only installing our Python packages.
 
+Installing ``memilio-simulation``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The simulation package ``memilio-simulation`` provides two installation options depending on your use case:
+
+**Option A.1: Install from PyPI (Recommended - no C++ compiler required)**
+
+If you just want to run simulations with the latest released version, install the pre-built wheel directly from PyPI:
+
+.. code-block:: console
+
+   pip install memilio-simulation
+
+This requires no C++ compiler or CMake. Pre-built wheels are provided for Linux and Windows on Python 3.8 to 3.13.
+
+**Option A.2: Install from source (for the latest development version)**
+
+If you need the latest (unreleased) code, or want to contribute to the package, you need to build from source.
+This requires a **C++20 compiler** (e.g. GCC or Clang), **CMake** (>= 3.18), and **Ninja**.
+
+.. code-block:: console
+
+   pip install -e .[dev]
+
+This command must be run from the **root of the MEmilio repository** (the directory containing the top-level ``pyproject.toml``).
+This is necessary because the C++ build requires access to the ``cpp/`` directory.
+Note that this only installs ``memilio-simulation`` and not any other Python packages. The root-level ``pyproject.toml`` belongs exclusively to ``memilio-simulation``.
+
+.. warning::
+   C++ code changes always require re-running ``pip install -e .[dev]`` to recompile.
+
+Installing other Python packages
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 1.  Navigate to the directory containing our Python code:
 
     .. code-block:: console
 
        cd pycode
 
-2.  To install the simulation package ``memilio-simulation``, from here you can do:
+2.  To install the ``memilio-epidata`` package for data downloading and handling:
 
     .. code-block:: console
 
-       cd memilio-simulation
+       cd memilio-epidata
        pip install -e .
 
-3.  For afterwards installing the ``memilio-epidata`` package for data downloading and handling, run:
+3.  To install the ``memilio-surrogatemodel`` package for surrogate models:
 
     .. code-block:: console
 
        cd ..  # Go back to the pycode directory
-       cd memilio-epidata
+       cd memilio-surrogatemodel
        pip install -e .
 
 .. tip:: For Contributors: Installing development packages
 
    The ``-e`` flag installs the package in a mode, which links the installation to your local source code folder.
-
-   If you plan to contribute to MEmilio, you can also install all the necessary development dependencies by adding ``[dev]`` to the command:
+   If you plan to contribute to any package, install all development dependencies by adding ``[dev]``:
 
    .. code-block:: console
 
       pip install -e .[dev]
 
-   For regular use, the simple ``pip install -e .`` is sufficient.
-
 To install other packages, see the items below *Python Interface* in the menu on the left hand side.
 
 Option B: Building the C++ core (Advanced)

docs/source/python/m-simulation.rst

@@ -5,12 +5,49 @@ MEmilio Simulation is a Python interface to the MEmilio C++ library. Using pytho
 
 The package is contained inside the folder `pycode/memilio-simulation <https://github.com/SciCompMod/memilio/blob/main/pycode/memilio-simulation>`_.
 
+Installation
+------------
+
+The ``memilio-simulation`` package can be installed in two ways depending on your use case.
+
+**Option 1: Install from PyPI (Recommended - no C++ compiler required)**
+
+Pre-built wheels are provided for Linux and Windows on Python 3.8 to 3.13.
+
+.. code-block:: console
+
+   pip install memilio-simulation
+
+This is the easiest way to get started. No C++ compiler or CMake is needed.
+
+**Option 2: Install from source (latest development version, or contributing)**
+
+If you need the latest unreleased code, or want to modify the bindings, build from source.
+
+Requirements:
+
+* A **C++20 compiler**
+* **CMake** >= 3.18
+* **Ninja** build tool
+* All :doc:`C++ library dependencies <../getting_started>`
+
+Install from the **root of the MEmilio repository** (the directory containing the top-level ``pyproject.toml``):
+
+.. code-block:: console
+
+   pip install -e .[dev]
+
+This is necessary because the C++ build requires access to the ``cpp/`` directory.
+Note that this only installs ``memilio-simulation`` and not any other Python packages.The ``-e`` flag links the installation to your local source code so Python changes are reflected immediately.
+C++ changes require re-running this command to recompile.
+
 Dependencies
 ------------
 
-Required Python packages:
+Required Python packages (installed automatically):
 
-* scikit-build
+* numpy >= 1.22 (not 1.25.*)
+* pandas >= 2.0.0
 
 For a successful build, the development libraries for Python need to be installed, i.e. python3.x-dev. 
 Additionally, as this package builds upon the MEmilio C++ library, 

pycode/memilio-simulation/CMakeLists.txt

@@ -1,9 +1,3 @@
-cmake_minimum_required(VERSION 3.14)
-project(memilio-python)
-
-set(CMAKE_CXX_STANDARD "20")
-set(CMAKE_CXX_STANDARD_REQUIRED "20")
-
 option(MEMILIO_USE_BUNDLED_PYBIND11 "Use pybind11 bundled with this library." ON)
 mark_as_advanced(MEMILIO_USE_BUNDLED_PYBIND11)
 
@@ -48,9 +42,6 @@ else()
     find_package(pybind11 REQUIRED)
 endif()
 
-# add in C++ library
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../cpp ${CMAKE_CURRENT_BINARY_DIR}/cpp EXCLUDE_FROM_ALL)
-
 # a list of all "LINKED_LIBRARIES" that are given to add_pymio_module. will contain duplicates
 # used for wheel installation
 set(PYMIO_MEMILIO_LIBS_LIST)

pycode/memilio-simulation/README.md

@@ -4,17 +4,34 @@ This package contains Python bindings for the MEmilio C++ library. It enables se
 
 ## Installation
 
-This project is configured via ``pyproject.toml`` and is built with [scikit-build-core](https://scikit-build-core.readthedocs.io). CMake and Ninja must be available on the system. The package uses the [Pybind11 C++ library](https://pybind11.readthedocs.io) to create the bindings.
+### Option 1: Install from PyPI (Recommended)
 
-To install the package, use the command (from the directory containing ``pyproject.toml``)
+Pre-built wheels are provided for Linux and Windows on Python 3.8 to 3.13.
 
 ```bash
-pip install .
+pip install memilio-simulation
 ```
 
-This builds the C++ library and C++ Python extension module and copies everything required to your site-packages.
+### Option 2: Install from source (latest code or development)
 
-All the requirements of the [C++ library](../../cpp/README.md) must be met in order to build and use the python bindings. A virtual environment is recommended. 
+Use this option if you need the latest unreleased code, or want to modify the C++ bindings.
+
+This project is configured via `pyproject.toml`. The following tools must be available on the system:
+
+- A **C++20 compiler**
+- **CMake** >= 3.18
+- **Ninja**
+- All [C++ library dependencies](../../cpp/README.md)
+
+A virtual environment is recommended. Install from the **root of the MEmilio repository** (the directory containing the top-level `pyproject.toml`):
+
+```bash
+pip install -e .[dev]
+```
+
+This is necessary because the C++ build requires access to the `cpp/` directory. Note that this only installs `memilio-simulation` and not any other Python packages.
+
+**Note:** The `-e` flag links the installation to your local source code. Python changes take effect immediately, but C++ changes require re-running this command to recompile.
 
 CMake is executed internally by scikit-build-core. All the options provided by the CMake configuration of the C++ library are available when building the Python extension as well. Additionally, the CMake configuration for the bindings provide the following CMake options:
 
@@ -30,7 +47,7 @@ Alternatively, edit the `CMakeCache.txt` in the directory created by scikit-buil
 
 ## Development
 
-For developement of the cpp bindings use
+For developement of the cpp bindings use the following command from the root of this repository (i.e. the directory containing ``pyproject.toml``)
 
 ```bash
 pip install -e .[dev]