Project

Description

As part of the course you will work in small teams (2-4) to develop a package of your choice, preferably something relevant to your research. The package should

• Be version controlled using git and have a public repository on e.g. github or gitlab.
• Use pyproject.toml and uv.lock to manange dependencies.
• Have documentation, either through a well written README.md or a static site (e.g. with mkdocs).
• Implement systematic testing using a testing framework such as pytest.
• Make use of continouos integration through Github Actions or Gitlab CI, for example for testing, or hosting docs.
• Be installable as a proper python package.
• The core code should use best practice principles.

Preferably the core code does something that is interesting to you, but it does not need to be complex - you are also welcome to use LLM tools to help write the core code or migrate/refactor already written code.

Project Ideas

Some ideas for project are

• A package for analysis of experimental data in your field of study, e.g. to make plots that you commonly make.
• A simulation relevant to your research.
• An interactive website show-casing a research project, for this I recommened streamlit. This can for example have interactive figures for exploring a dataset or visualizing a key concept from your research.

These are just broad ideas, you are encouraged to come up with an idea together in each group.

Example Projects

Below I list some of my projects, these are meant as inspiration and don’t all necessarily make use of all practices covered in the course.

Most have seen significantly more development hours than you’re expected to put in, again the important part for your project is making use of the tools available to make reproducible, shareable, maintainable and extendable projects - not build a very complex program.

AGOX

AGOX logo created as an optimization in a custom PyTorch based potential

Gitlab - Documentation

AGOX is an optimization package for atomistic structures, it implements several global optimization algorithms by leveraging a composable and modular design. This has been used in several published research projects. It is by far the largest project of the ones I’ve listed here, having had development time being put in by many people over several years.

It uses sphinx for documentation, which I would not necessarily recommend but which is extremely feature rich. It has a rather extensive test suite using pytest, but it could still use some work. AGOX has a CLI for analyzing optimization runs. Additionally parts of the code use Cython to leverage C for performance critical parts, nowadays I would prefer the Rust option discussed in Section 3.5.

Shephex

Gitlab - Documentation

This is a ‘computational experiment manager’ that can painlessly create and submit Python scripts as jobs to a SLURM High Performance Compute cluster and offers CLI tools to monitor job progress and functions to cleanly gather computed results.

It uses pytest with Gitlab CI for testing and mkdocs with Gitlab Pages to deploy a static documentation site.

mcqpy

Github - Documentation

This project builds multiple-choice quiz PDF documents using pylatex to programmatically create and compile LaTeX and has functionality to automatically grade and analyze student handins.

The project uses mkdocs for documentation and Github pages to deploy the static site. It has a thorough test suite using pytest and uses Github Actions to run the test suite on commits and pull requests.

fysisk-biokemi

Github - Website

This is a project containing Python exercises for the “Fysisk Biokemi & Datanalayse”-course at AU MBG written using Quarto and an accompanying Python package used in the exercises. It uses Github actions to build the material and deploys the static site using Github Pages.

mandel-fast

Mandelbrot illustration

Github

I wrote this as an example for this course and as a project for me to try maturin. It implements code to calculate the Mandelbrot set in pure Python, using vectorized numpy, and in rust in a a serial and parallel version. It utitlizes maturin to make the compiled Rust binaries available from Python. This shows how a high-performance language, like Rust, can be integrated in a Python package. If you have a project where performance critical parts are hard to optimize in Python this is a nice way of moving those parts to a compiled language.