Update CI, and add linting

Author: hkjeldsberg

.github/workflows/check_and_test_package.yml

@@ -1,96 +1,78 @@
-name: CI
+name: OasisMove CI
 
 on:
   push:
-    # The CI is executed on every push on every branch
     branches:
       - main
   pull_request:
-    # The CI is executed on every pull request to the main branch
     branches:
       - main
-
   schedule:
-    # The CI is executed every day at 8am
-    - cron: "0 8 * * *"
+    - cron: '0 8 * * *'
 
 env:
-  CACHE_NUMBER: 3 # Increase to reset cache
+  CACHE_NUMBER: 4 # Increase to reset cache
 
 jobs:
-  check-code:
+  run-lint-check:
     name: Check code
     runs-on: ubuntu-latest
 
     steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Upgrade pip and setuptools
-        run: python3 -m pip install pip setuptools --upgrade
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
 
-      - name: Install OasisMove
-        run: python3 -m pip install .[test]
+      - name: Install dependencies and OasisMove
+        run: |
+          python -m pip install --upgrade pip setuptools
+          python -m pip install '.[test]'
 
-      - name: Check code with Flake8
-        run: python3 -m flake8
+      - name: Run linting and checks
+        run: |
+          bash linting.sh
 
-  test-code:
-    needs: check-code
+  run-tests:
+    needs: run-lint-check
     strategy:
       matrix:
         include:
           - os: ubuntu-latest
             label: linux-64
-            prefix: /usr/share/miniconda3/envs/oasismove
-          - os: macos-latest
+            prefix: /usr/share/miniconda3/envs/oasismove-env
+          - os: macos-13
             label: osx-64
-            prefix: /Users/runner/miniconda3/envs/oasismove
+            prefix: /Users/runner/miniconda3/envs/oasismove-env
 
-    name: Test OasisMove on ${{ matrix.label }}
+    name: Test OasisMove on ${{ matrix.os}}
     runs-on: ${{ matrix.os }}
-
-    # https://github.com/marketplace/actions/setup-miniconda#use-a-default-shell
     defaults:
-      run:
-        shell: bash -l {0}
+      run: # https://github.com/marketplace/actions/setup-miniconda#use-a-default-shell
+        shell: bash -el {0}
 
     steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Upgrade pip and setuptools
-        run: |
-          python3 -m pip install pip setuptools --upgrade
-
-      # See: https://github.com/marketplace/actions/setup-miniconda
-      - name: Setup Mambaforge
-        uses: conda-incubator/setup-miniconda@v2
+      - uses: actions/checkout@v4
+      - uses: mamba-org/setup-micromamba@v1
         with:
-          miniforge-variant: Mambaforge
-          miniforge-version: latest
-          channels: conda-forge
-          activate-environment: oasismove
-          use-mamba: true
+          environment-file: environment.yml
+          init-shell: bash
+          cache-environment: true
 
-      - name: Set cache date
-        run: echo "DATE=$(date +'%Y%m%d')" >> $GITHUB_ENV
-
-      - uses: actions/cache@v2
+      - uses: actions/cache@v3
         with:
           path: ${{ matrix.prefix }}
-          key: ${{ matrix.label }}-conda-${{ hashFiles('environment.yml') }}-${{ env.DATE }}-${{ env.CACHE_NUMBER }}
-        id: cache
+          key: ${{ matrix.label }}-${{ env.CACHE_NUMBER }}-${{ hashFiles('environment.yml') }}
+          restore-keys: ${{ matrix.label }}-${{ env.CACHE_NUMBER }}-
 
-      - name: Update environment
-        run: mamba env update -n oasismove -f environment.yml
-        if: steps.cache.outputs.cache-hit != 'true'
 
       - name: Install OasisMove
-        run: python3 -m pip install --editable .[test]
+        run: |
+          python -m pip install '.[test]'
 
       - name: Run tests
-        run: python3 -m pytest tests
+        run: |
+          python -m pytest tests
 
       - name: Upload coverage report to codecov
         if: matrix.os == 'ubuntu-latest'

linting.sh

@@ -0,0 +1,7 @@
+#! /usr/bin/env bash
+
+isort src tests
+
+black src tests
+
+flake8 src tests

pyproject.toml

@@ -17,6 +17,8 @@ test = [
     "flake8",
     "pytest",
     "pytest-cov",
+    "isort",
+    "black"
 ]
 docs = [
     "jupyter-book",

requirements.txt

@@ -1,4 +1,4 @@
 jupyter-book
 matplotlib
 numpy
-ghp-import
+ghp-import

src/oasismove/NSCoupled.py

@@ -1,7 +1,7 @@
-__author__ = 'Mikael Mortensen <[email protected]>'
-__date__ = '2014-04-04'
-__copyright__ = 'Copyright (C) 2014 ' + __author__
-__license__ = 'GNU Lesser GPL version 3 or any later version'
+__author__ = "Mikael Mortensen <[email protected]>"
+__date__ = "2014-04-04"
+__copyright__ = "Copyright (C) 2014 " + __author__
+__license__ = "GNU Lesser GPL version 3 or any later version"
 
 import importlib
 
@@ -27,16 +27,18 @@
 commandline_kwargs = parse_command_line()
 
 # Find the problem module
-default_problem = 'DrivenCavity'
-problemname = commandline_kwargs.get('problem', default_problem)
-problemspec = importlib.util.find_spec('.'.join(('oasismove.problems.NSCoupled', problemname)))
+default_problem = "DrivenCavity"
+problemname = commandline_kwargs.get("problem", default_problem)
+problemspec = importlib.util.find_spec(
+    ".".join(("oasismove.problems.NSCoupled", problemname))
+)
 if problemspec is None:
     problemspec = importlib.util.find_spec(problemname)
 if problemspec is None:
-    raise RuntimeError(problemname + ' not found')
+    raise RuntimeError(problemname + " not found")
 
 # Import the problem module
-print('Importing problem module ' + problemname + ':\n' + problemspec.origin)
+print("Importing problem module " + problemname + ":\n" + problemspec.origin)
 problemmod = importlib.util.module_from_spec(problemspec)
 problemspec.loader.exec_module(problemmod)
 
@@ -49,33 +51,34 @@
 vars().update(post_import_problem(**vars()))
 
 # Import chosen functionality from solvers
-solver = importlib.import_module('.'.join(('oasismove.solvers.NSCoupled', solver)))
+solver = importlib.import_module(".".join(("oasismove.solvers.NSCoupled", solver)))
 vars().update({name: solver.__dict__[name] for name in solver.__all__})
 
 # Create lists of components solved for
-u_components = ['u']
-sys_comp = ['up'] + scalar_components
+u_components = ["u"]
+sys_comp = ["up"] + scalar_components
 
 # Get the chosen mixed elment
-element = commandline_kwargs.get('element', 'TaylorHood')
+element = commandline_kwargs.get("element", "TaylorHood")
 vars().update(elements[element])
 
 # TaylorHood may overload degree of elements
-if element == 'TaylorHood':
-    degree['u'] = commandline_kwargs.get('velocity_degree', degree['u'])
-    degree['p'] = commandline_kwargs.get('pressure_degree', degree['p'])
+if element == "TaylorHood":
+    degree["u"] = commandline_kwargs.get("velocity_degree", degree["u"])
+    degree["p"] = commandline_kwargs.get("pressure_degree", degree["p"])
     # Should assert that degree['p'] = degree['u']-1 ??
 
 # Declare Elements
-V = VectorElement(family['u'], mesh.ufl_cell(), degree['u'])
-Q = FiniteElement(family['p'], mesh.ufl_cell(), degree['p'])
+V = VectorElement(family["u"], mesh.ufl_cell(), degree["u"])
+Q = FiniteElement(family["p"], mesh.ufl_cell(), degree["p"])
 
 # Create Mixed space
 # MINI element has bubble, add to V
 if bubble:
     B = VectorElement("Bubble", mesh.ufl_cell(), mesh.geometry().dim() + 1)
-    VQ = FunctionSpace(mesh, MixedElement(V + B, Q),
-                       constrained_domain=constrained_domain)
+    VQ = FunctionSpace(
+        mesh, MixedElement(V + B, Q), constrained_domain=constrained_domain
+    )
 
 else:
     VQ = FunctionSpace(mesh, V * Q, constrained_domain=constrained_domain)
@@ -86,7 +89,7 @@
 v, q = TestFunctions(VQ)
 
 # For scalars use CG space
-CG = FunctionSpace(mesh, 'CG', 1, constrained_domain=constrained_domain)
+CG = FunctionSpace(mesh, "CG", 1, constrained_domain=constrained_domain)
 c = TrialFunction(CG)
 ct = TestFunction(CG)
 
@@ -95,17 +98,19 @@
 
 # Create dictionaries for the solutions at two timesteps
 q_ = dict((ui, Function(VV[ui], name=ui)) for ui in sys_comp)
-q_1 = dict((ui, Function(VV[ui], name=ui + '_1')) for ui in sys_comp)
+q_1 = dict((ui, Function(VV[ui], name=ui + "_1")) for ui in sys_comp)
 
 # Short forms
-up_ = q_['up']  # Solution at next iteration
-up_1 = q_1['up']  # Solution at previous iteration
+up_ = q_["up"]  # Solution at next iteration
+up_1 = q_1["up"]  # Solution at previous iteration
 u_, p_ = split(up_)
 u_1, p_1 = split(up_1)
 
 # Create short forms for accessing the solution vectors
 x_ = dict((ui, q_[ui].vector()) for ui in sys_comp)  # Solution vectors
-x_1 = dict((ui, q_1[ui].vector()) for ui in sys_comp)  # Solution vectors previous iteration
+x_1 = dict(
+    (ui, q_1[ui].vector()) for ui in sys_comp
+)  # Solution vectors previous iteration
 
 # Create vectors to hold rhs of equations
 b = dict((ui, Vector(x_[ui])) for ui in sys_comp)
@@ -154,7 +159,7 @@ def iterate(iters=max_iter):
             x_1[ui].zero()
             x_1[ui].axpy(1.0, x_[ui])
 
-        error = b['up'].norm('l2')
+        error = b["up"].norm("l2")
         print_velocity_pressure_info(**locals())
 
         iter += 1
@@ -171,25 +176,25 @@ def iterate_scalar(iters=max_iter, errors=max_error):
                 scalar_assemble(**globals())
                 scalar_hook(**globals())
                 scalar_solve(**globals())
-                err[ci] = b[ci].norm('l2')
+                err[ci] = b[ci].norm("l2")
                 if MPI.rank(MPI.comm_world) == 0:
-                    print('Iter {}, Error {} = {}'.format(citer, ci, err[ci]))
+                    print("Iter {}, Error {} = {}".format(citer, ci, err[ci]))
                 citer += 1
 
 
-timer = OasisTimer('Start Newton iterations flow', True)
+timer = OasisTimer("Start Newton iterations flow", True)
 # Assemble rhs once, before entering iterations (velocity components)
-b['up'] = assemble(Fs['up'], tensor=b['up'])
-for bc in bcs['up']:
-    bc.apply(b['up'], x_['up'])
+b["up"] = assemble(Fs["up"], tensor=b["up"])
+for bc in bcs["up"]:
+    bc.apply(b["up"], x_["up"])
 
 iterate(max_iter)
 timer.stop()
 
 # Assuming there is no feedback to the flow solver from the scalar field,
 # we solve the scalar only after converging the flow
 if len(scalar_components) > 0:
-    scalar_timer = OasisTimer('Start Newton iterations scalars', True)
+    scalar_timer = OasisTimer("Start Newton iterations scalars", True)
     # Assemble rhs once, before entering iterations (velocity components)
     for scalar in scalar_components:
         b[scalar] = assemble(Fs[scalar], tensor=b[scalar])
@@ -200,13 +205,17 @@ def iterate_scalar(iters=max_iter, errors=max_error):
     scalar_timer.stop()
 
 list_timings(TimingClear.keep, [TimingType.wall])
-info_red('Total computing time = {0:f}'.format(timer.elapsed()[0]))
-oasis_memory('Final memory use ')
+info_red("Total computing time = {0:f}".format(timer.elapsed()[0]))
+oasis_memory("Final memory use ")
 total_initial_dolfin_memory = MPI.sum(MPI.comm_world, initial_memory_use)
-info_red('Memory use for importing dolfin = {} MB (RSS)'.format(
-    total_initial_dolfin_memory))
-info_red('Total memory use of solver = ' +
-         str(oasis_memory.memory - total_initial_dolfin_memory) + ' MB (RSS)')
+info_red(
+    "Memory use for importing dolfin = {} MB (RSS)".format(total_initial_dolfin_memory)
+)
+info_red(
+    "Total memory use of solver = "
+    + str(oasis_memory.memory - total_initial_dolfin_memory)
+    + " MB (RSS)"
+)
 
 # Final hook
 theend_hook(**vars())