Merge pull request #275 from herbertludowieg/master

Some changes for codacy

Author: Herbert D Ludowieg

.github/workflows/branch.yml

@@ -3,7 +3,7 @@ name: Branch
 on:
   push:
     branches-ignore:
-      - master
+      - [master, main]
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
@@ -54,7 +54,7 @@ jobs:
       - name: Run Tests
         uses: ./.github/workflows/run-tests
         with:
-          coverage-artifact-name: ${{ needs.coverage-artifact-name.outputs.ref }}
+          coverage-artifact-name: code-coverage
 
   codacy-coverage-reporter:
     runs-on: ubuntu-latest
@@ -65,7 +65,7 @@ jobs:
       - name: Download Coverage Report
         uses: actions/download-artifact@v2
         with:
-          name: code-coverage-report-${{ needs.coverage-artifact-name.outputs.ref }}
+          name: code-coverage-report-code-coverage
       - name: Run codacy-coverage-reporter
         uses: codacy/codacy-coverage-reporter-action@v1
         with:

.github/workflows/master.yml

@@ -3,7 +3,7 @@ name: Master
 on:
   push:
     branches:
-      master
+      [master, main]
 
 concurrency:
   group: ${{ github.workflow }}

.github/workflows/pull-request.yml

@@ -0,0 +1,56 @@
+name: Branch
+
+on:
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+
+  support-matrix:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - uses: actions/checkout@v2
+      - id: set-matrix
+        run: echo "::set-output name=matrix::$(python cicd-matrix.py)"
+
+  coverage-artifact-name:
+    runs-on: ubuntu-latest
+    outputs:
+      ref: ${{ steps.get-ref.outputs.ref }}
+    steps:
+      - id: get-ref
+        run: |
+          ref=${{ github.ref }}
+          echo "::set-output name=ref::${ref////-}"
+
+  run-tests:
+    needs: [ support-matrix, coverage-artifact-name ]
+    name: Test Python ${{ matrix.python-version }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ${{ fromJson(needs.support-matrix.outputs.matrix).os }}
+        python-version: ${{ fromJson(needs.support-matrix.outputs.matrix).python-version }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - uses: actions/cache@v2
+        with:
+          path: ${{ env.pythonLocation }}
+          key: ${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements.dev.txt') }}
+      - name: Install Dependencies
+        run: |
+          pip install --upgrade --upgrade-strategy eager -r requirements.txt -r requirements.dev.txt -e .
+      - name: Run Tests
+        uses: ./.github/workflows/run-tests
+        with:
+          coverage-artifact-name: code-coverage
+

.github/workflows/run-tests/action.yml

@@ -20,10 +20,12 @@ runs:
       run: pytest --doctest-modules -v
 
     - name: Upload Coverage
-      if: (runner.os == 'Linux') && (matrix.python-version == '3.8')
+      # needs always() to make sure that even if the linux/3.8 fails it will
+      # still upload the artifact to export coverage to codacy
+      if: (runner.os == 'Linux') && (matrix.python-version == '3.8') && (always())
       uses: actions/upload-artifact@v2
       with:
         name: code-coverage-report-${{ inputs.coverage-artifact-name }}
         path: coverage.xml
         retention-days: 1
-        
+

exatomic/adf/output.py

@@ -391,7 +391,7 @@ def parse_excitation(self):
         while self[stop].strip(): stop += 1
         df = self.pandas_dataframe(start, stop, ncol=6)
         df.columns = ['excitation', 'energy', 'energy_ev', 'osc', 'tau', 'symmetry']
-        nan = np.where(list(map(lambda x: any(x), df.isna().values)))[0]
+        nan = np.where(df.isna().values)[0]
         df.loc[nan, 'symmetry'] = df.loc[nan, 'tau'].copy()
         df.loc[nan, 'tau'] = 0.0
         df['tau'] = df['tau'].astype(float)
@@ -536,7 +536,7 @@ def parse_frequency(self):
             else:
                 start = stop + 4
             stop = start + natoms
-            freqs = list(map(lambda x: float(x), self[start-2].split()))
+            freqs = list(map(float, self[start-2].split()))
             ncol = len(freqs)
             df = self.pandas_dataframe(start, stop, ncol=1+3*ncol)
             tmp = list(map(lambda x: x.split('.'), df[0]))
@@ -660,26 +660,9 @@ def parse_gradient(self):
         self.gradient = grad
 
     def parse_excitation(self):
-        _reexc = "no.     E/a.u.        E/eV      f"
-        found = self.find(_reexc, keys_only=True)
-        if not found:
-            return
-        # there should only be one in the entire output
-        start = found[0] + 2
-        stop = start
-        while self[stop].strip(): stop += 1
-        df = self.pandas_dataframe(start, stop, ncol=6)
-        df.columns = ['excitation', 'energy', 'energy_ev', 'osc', 'tau', 'symmetry']
-        nan = np.where(list(map(lambda x: any(x), df.isna().values)))[0]
-        df.loc[nan, 'symmetry'] = df.loc[nan, 'tau'].copy()
-        df.loc[nan, 'tau'] = 0.0
-        df['tau'] = df['tau'].astype(float)
-        df['excitation'] = [int(x[:-1]) for x in df['excitation'].values]
-        df.index = df['excitation'] - 1
-        df.drop('excitation', axis=1, inplace=True)
-        df['frame'] = 0
-        df['group'] = 0
-        self.excitation = df
+        # the output has not changed from the last few iterations
+        # of ADF
+        ADF.parse_excitation(self)
 
     def parse_electric_dipole(self):
         _reexc = "Excitation energies E in a.u. and eV, dE wrt prev. cycle"
@@ -707,21 +690,20 @@ def parse_electric_dipole(self):
         tdm = self.pandas_dataframe(start, stop, ncol=10)
         tdm.dropna(axis=1, how='all', inplace=True)
         if tdm.shape[1] == 9:
-            spinorbit=True
+            # TODO: should we get the magnitude here instead?
             tdm.columns = ['excitation', 'energy_ev', 'osc', 'remu_x' ,'remu_y', 'remu_z',
                            'immu_x', 'immu_y', 'immu_z']
         else:
             tdm.columns = ['excitation', 'energy_ev', 'osc', 'mu_x' ,'mu_y', 'mu_z']
-            spinorbit=False
         tdm['excitation'] -= 1
         diff = np.setdiff1d(df['excitation'].values.flatten(),
                             tdm['excitation'].values.flatten())
         if len(diff) > 0:
-            for idx in range(len(diff)):
-                df1 = tdm.loc[range(diff[idx])]
-                df2 = tdm.loc[range(diff[idx], tdm.shape[0])]
-                new_line = [diff[idx], df.loc[diff[idx], 'energy_ev'],
-                            df.loc[diff[idx], 'osc']]+[0.0]*int(len(tdm.columns)-3)
+            for d in diff:
+                df1 = tdm.loc[range(d)]
+                df2 = tdm.loc[range(d, tdm.shape[0])]
+                new_line = [d, df.loc[d, 'energy_ev'],
+                            df.loc[d, 'osc']]+[0.0]*int(len(tdm.columns)-3)
                 new_line = pd.DataFrame([new_line], columns=tdm.columns)
                 new_df = pd.concat([df1, new_line, df2], ignore_index=True)
                 tdm = new_df.copy()

exatomic/adf/tape21.py

@@ -10,15 +10,13 @@
 
 from exatomic.exa.core.container import TypedMeta
 from exatomic.exa.core.editor import Editor
-from exatomic.exa.util.units import Length, Mass, Energy
 from exatomic.core.atom import Atom, Frequency
 from exatomic.core.gradient import Gradient
 from exatomic.core.tensor import JCoupling, NMRShielding
 from exatomic.base import z2sym, sym2isomass
 import numpy as np
 import pandas as pd
 import six
-import warnings
 
 class MissingSection(Exception):
     pass
@@ -167,7 +165,6 @@ def parse_frequency(self, cart=True):
         # these should be the ones that ADF determines to be translations and rotations
         # TODO: need a test case with one imaginary frequency
         low = freq != 0
-        nlow = low.shape[0]
         # get only the ones that are non-zero
         freq = freq[low]
         nmodes = freq.shape[0]
@@ -202,14 +199,10 @@ def parse_frequency(self, cart=True):
         dz = np.array(dz).flatten()
         freqdx = np.repeat(range(nmodes), nat)
         label = np.tile(self.atom['label'], nmodes)
-        symbol = self.atom['symbol']
-        # get the isotopic masses
-        mass = _get_isomass(symbol)
         symbol = np.tile(self.atom['symbol'], nmodes)
         # put the data together
         df = pd.DataFrame({'dx': dx, 'dy': dy, 'dz': dz, 'frequency': freq,
                            'freqdx': freqdx})
-        cols = ['dx', 'dy', 'dz']
         # calculate the reduced masses
         if not cart:
             r_mass = df.groupby(['freqdx']).apply(self.rmass_mwc,
@@ -220,6 +213,7 @@ def parse_frequency(self, cart=True):
         df['r_mass'] = np.repeat(r_mass, nat)
         df['symbol'] = symbol
         df['label'] = label
+        # TODO: find out if this is stored in the file anywhere
         df['ir_int'] = 0
         df['frame'] = 0
         self.frequency = df
@@ -311,7 +305,6 @@ def parse_gradient(self, input_order=False):
         self.parse_atom(input_order=input_order)
         symbol = self.atom.last_frame['symbol'].values
         Z = self.atom.last_frame['Z'].values.astype(int)
-        nat = self.atom.last_frame.shape[0]
         # get the gradients
         ngrad = self._intme(np.array(found[_regrad]))
         grad = self._dfme(np.array(found[_regrad]), ngrad)
@@ -323,7 +316,6 @@ def parse_gradient(self, input_order=False):
                                      'fy': y, 'fz': z, 'symbol': symbol,
                                      'frame': 0})
         df = df[['atom', 'Z', 'fx', 'fy', 'fz', 'symbol', 'frame']]
-        #for u in ['fx', 'fy', 'fz']: df[u] *= 1./Length['Angstrom', 'au']
         self.gradient = df
 
     def parse_nmr_shielding(self):

exatomic/core/basis.py

@@ -119,14 +119,16 @@ def spherical_by_shell(self, program, spherical=True):
     def functions_by_shell(self):
         """Return a series of n functions per (set, L).
         This does not include degenerate functions."""
-        obj = self.groupby(self._indexes)['shell'].nunique()
+        obj = self._revert_categories(inplace=False)
+        obj = obj.groupby(self._indexes)['shell'].nunique()
         obj.index.set_names(self._indexes, inplace=True)
         return obj
 
     def primitives_by_shell(self):
         """Return a series of n primitives per (set, L).
         This does not include degenerate primitives."""
-        obj = self.groupby(self._indexes)['alpha'].nunique()
+        obj = self._revert_categories(inplace=False)
+        obj = obj.groupby(self._indexes)['alpha'].nunique()
         obj.index.set_names(self._indexes, inplace=True)
         return obj
 

exatomic/core/gradient.py

@@ -23,10 +23,10 @@ def stats(self):
             norms = np.linalg.norm(data[cols].values, axis=1)
             rms = np.sqrt(np.mean(np.square(norms)))
             avg = np.mean(norms)
-            max = norms.max()
-            min = norms.min()
-            sr = pd.Series([rms, avg, max, min], index=['rms', 'mean',
-                                                        'max', 'min'])
+            max_grad = norms.max()
+            min_grad = norms.min()
+            sr = pd.Series([rms, avg, max_grad, min_grad],
+                           index=['rms', 'mean', 'max', 'min'])
             srs.append(sr)
         df = pd.concat(srs, axis=1, ignore_index=True).T
         return df
@@ -46,7 +46,7 @@ def avg_grad(self):
         cols = ['fx', 'fy', 'fz']
         arr = []
         for _, data in self.groupby('frame'):
-            val = np.mean(data[cols].values)
+            val = np.mean(data[cols].abs().values)
             arr.append(val)
         avg = pd.Series(arr)
         return avg

exatomic/exa/core/numerical.py

@@ -46,10 +46,6 @@ def slice_naive(self, key):
         key = check_key(self, key)
         return cls(self.loc[key])
 
-    def __repr__(self):
-        name = '.'.join([self.__module__, self.__class__.__name__])
-        return '{0}{1}'.format(name, self.shape)
-
     def __str__(self):
         return self.__repr__()
 
@@ -60,7 +56,7 @@ class BaseSeries(Numerical):
 
     Attributes:
         _sname (str): May have a required name (default None)
-        _iname (str: May have a required index name
+        _iname (str): May have a required index name
         _stype (type): May have a required value type
         _itype (type): May have a required index type
     """
@@ -193,13 +189,20 @@ def copy(self, *args, **kwargs):
         cls = self.__class__    # Note that type conversion does not perform copy
         return cls(pd.DataFrame(self).copy(*args, **kwargs))
 
-    def _revert_categories(self):
+    def _revert_categories(self, inplace=True):
         """
         Inplace conversion to categories.
         """
-        for column, dtype in self._categories.items():
-            if column in self.columns:
-                self[column] = self[column].astype(dtype)
+        if inplace:
+            for column, dtype in self._categories.items():
+                if column in self.columns:
+                    self[column] = self[column].astype(dtype)
+        else:
+            copy = self.copy()
+            for column, dtype in copy._categories.items():
+                if column in copy.columns:
+                    copy[column] = copy[column].astype(dtype)
+            return copy
 
     def _set_categories(self):
         """

exatomic/gaussian/output.py

@@ -706,14 +706,17 @@ def parse_hessian(self):
               +"using this molecular orientation.")
         ldx = found[0] + 1
         dfs = []
+        srs = []
+        srs_old = []
         try:
             while float(self[ldx].split()[0]):
                 d = self[ldx].split()
                 if 'D' not in d[1]:
                     ncols = len(d)
                     cols = list(map(lambda x: int(x)-1, d))
                     if cols[0] != 0:
-                        dfs.append(pd.concat(srs, axis=1).T)
+                        srs_old = srs
+                        dfs.append(pd.concat(srs_old, axis=1).T)
                     srs = []
                 else:
                     arr = np.zeros(ncols)