clean up a style warning; update test matrix

Author: weaverba137

.github/workflows/ci_workflows.yml

@@ -37,29 +37,24 @@ jobs:
             toxargs: -v
             toxposargs: --remote-data=astropy
 
-          - name: Python 3.11 (Windows)
+          - name: Python 3.12 (Windows)
             os: windows-latest
-            python: 3.11
+            python: '3.12'
             toxenv: py311-test
 
-          - name: Python 3.11 (MacOS X)
+          - name: Python 3.10 (MacOS X)
             os: macos-latest
-            python: 3.11
+            python: '3.10'
             toxenv: py311-test
 
           - name: Python 3.10
             os: ubuntu-latest
             python: '3.10'
             toxenv: py310-test
 
-          - name: Python 3.9
-            os: ubuntu-latest
-            python: 3.9
-            toxenv: py39-test
-
-          - name: Python 3.8 with oldest supported version of key dependencies
-            os: ubuntu-20.04
-            python: 3.8
+          - name: Python 3.10 with oldest supported version of key dependencies
+            os: ubuntu-22.04
+            python: '3.10'
             toxenv: py38-test-oldestdeps
 
     steps:
@@ -71,13 +66,13 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python }}
-    - name: Install language-pack-de and tzdata
-      if: startsWith(matrix.os, 'ubuntu')
-      run: |
-          sudo apt-get update
-          sudo apt-get install language-pack-de tzdata graphviz
+    # - name: Install language-pack-de and tzdata
+    #   if: startsWith(matrix.os, 'ubuntu')
+    #   run: |
+    #       sudo apt-get update
+    #       sudo apt-get install language-pack-de tzdata graphviz
     - name: Install Python dependencies
-      run: python -m pip install --upgrade tox codecov
+      run: python -m pip install --upgrade tox
     - name: Run tests
       env:
         COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
@@ -91,10 +86,10 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - name: (Allowed Failure) Python 3.11 with development versions of key dependencies
+          - name: (Allowed Failure) Python 3.13 with development versions of key dependencies
             os: ubuntu-latest
-            python: '3.11'
-            toxenv: py311-test-devdeps
+            python: '3.13'
+            toxenv: py313-test-devdeps
             toxargs: -v
 
           - name: (Allowed Failure) Python 3.12 with remote data and dev version of key dependencies
@@ -113,13 +108,13 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python }}
-    - name: Install language-pack-de and tzdata
-      if: startsWith(matrix.os, 'ubuntu')
-      run: |
-          sudo apt-get update
-          sudo apt-get install language-pack-de tzdata
+    # - name: Install language-pack-de and tzdata
+    #   if: startsWith(matrix.os, 'ubuntu')
+    #   run: |
+    #       sudo apt-get update
+    #       sudo apt-get install language-pack-de tzdata
     - name: Install Python dependencies
-      run: python -m pip install --upgrade tox codecov
+      run: python -m pip install --upgrade tox
     - name: Run tests
       # This is the specific switch for allowed failures.
       continue-on-error: true

pydl/pydlspec2d/spec1d.py

@@ -195,10 +195,10 @@ def gstep(self):
         d = np.zeros((K, K, M), dtype=self.a.dtype)
         if self.epsilon is not None and self.epsilon > 0:
             foo = self.epsilon * np.eye(K, dtype=self.a.dtype)
-            for l in range(M):
-                d[:, :, l] = foo
-                if l > 0 and l < M-1:
-                    d[:, :, l] *= 2
+            for ll in range(M):
+                d[:, :, ll] = foo
+                if ll > 0 and ll < M-1:
+                    d[:, :, ll] *= 2
             # d[:, :, 0] = foo
             # d[:, :, 1:M-1] = 2*foo
             # d[:, :, M-1] = foo
@@ -1536,10 +1536,10 @@ def template_input(inputfile, dumpfile, flux=False, verbose=False):
             istart = k*nfluxes
             iend = min(istart+nfluxes, nspectra) - 1
             fig, ax = plt.subplots(1, 1, figsize=_default_figsize, dpi=100)
-            for l in range(istart, iend+1):
+            for indx in range(istart, iend+1):
                 _ = ax.plot(10.0**pcaflux['newloglam'],
-                            pcaflux['newflux'][l, :] + separation*(l % nfluxes),
-                            colorvec[l % len(colorvec)]+'-',
+                            pcaflux['newflux'][indx, :] + separation*(indx % nfluxes),
+                            colorvec[indx % len(colorvec)]+'-',
                             linewidth=1)
             _ = ax.set_xlabel(r'Wavelength [Å]')
             _ = ax.set_ylabel(r'Flux [$\mathsf{10^{-17} erg\, cm^{-2} s^{-1} \AA^{-1}}$] + Constant')

pydl/pydlspec2d/spec2d.py

@@ -46,18 +46,18 @@ def aesthetics(flux, invvar, method='traditional'):
             goodpts = invvar > 0
             newflux[~goodpts] = newflux[goodpts].mean()
         elif method == 'damp':
-            l = 250  # damping length in pixels
+            damp_len = 250  # damping length in pixels
             goodpts = invvar.nonzero()[0]
             nflux = flux.size
             mingood = goodpts.min()
             maxgood = goodpts.max()
             newflux = djs_maskinterp(flux, invvar == 0, const=True)
             pixels = np.arange(nflux, dtype='f')
             if mingood > 0:
-                damp1 = float(min(mingood, l))
+                damp1 = float(min(mingood, damp_len))
                 newflux *= 0.5*(1.0+erf((pixels-mingood)/damp1))
             if maxgood < (nflux - 1):
-                damp2 = float(min(maxgood, l))
+                damp2 = float(min(maxgood, damp_len))
                 newflux *= 0.5*(1.0+erf((maxgood-pixels)/damp2))
         elif method == 'nothing':
             newflux = flux.copy()

pydl/pydlspec2d/tests/test_spec1d.py

@@ -104,9 +104,9 @@ def test_template_metadata():
 
 
 def test_wavevector():
-    l = wavevector(3, 4, binsz=0.1)
-    ll = np.array([3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0])
-    assert np.allclose(l, ll)
-    l = wavevector(3, 4, wavemin=3, binsz=0.1)
-    ll = np.array([3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0])
-    assert np.allclose(l, ll)
+    w = wavevector(3, 4, binsz=0.1)
+    ww = np.array([3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0])
+    assert np.allclose(w, ww)
+    w = wavevector(3, 4, wavemin=3, binsz=0.1)
+    ww = np.array([3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0])
+    assert np.allclose(w, ww)

pydl/pydlutils/bspline.py

@@ -334,10 +334,10 @@ def bsplvn(self, x, ileft):
             imj = ileft-j
             deltam[:, j] = x - bkpt[imj]
             vmprev = 0.0
-            for l in range(j+1):
-                vm = vnikx[:, l]/(deltap[:, l] + deltam[:, j-l])
-                vnikx[:, l] = vm*deltap[:, l] + vmprev
-                vmprev = vm*deltam[:, j-l]
+            for k in range(j+1):
+                vm = vnikx[:, k]/(deltap[:, k] + deltam[:, j-k])
+                vnikx[:, k] = vm*deltap[:, k] + vmprev
+                vmprev = vm*deltam[:, j-k]
             j += 1
             vnikx[:, j] = vmprev
         return vnikx
@@ -451,7 +451,7 @@ def maskpoints(self, err):
             return -2
 
 
-def cholesky_band(l, mininf=0.0):
+def cholesky_band(low, mininf=0.0):
     """Compute *lower* Cholesky decomposition of a banded matrix.
 
     This function provides informative error messages to pass back to the
@@ -460,15 +460,15 @@ def cholesky_band(l, mininf=0.0):
 
     Parameters
     ----------
-    l : :class:`numpy.ndarray`
+    low : :class:`numpy.ndarray`
         A matrix on which to perform the Cholesky decomposition.  The
         matrix must be in a special, *lower* form described in
         :func:`scipy.linalg.cholesky_banded`.  In addition, the input
         must be padded.  If the original, square matrix has size
         :math:`N \\times N`, and the width of the band is :math:`b`,
-        `l` must be :math:`b \\times (N + b)`.
+        `low` must be :math:`b \\times (N + b)`.
     mininf : :class:`float`, optional
-        Entries in the `l` matrix are considered negative if they are less
+        Entries in the `low` matrix are considered negative if they are less
         than this value (default 0.0).
 
     Returns
@@ -479,19 +479,19 @@ def cholesky_band(l, mininf=0.0):
         be the input matrix.  If no problems were detected, the first item
         will be -1, and the second item will be the Cholesky decomposition.
     """
-    bw, nn = l.shape
+    bw, nn = low.shape
     n = nn - bw
-    negative = l[0, 0:n] <= mininf
-    if negative.any() or not np.all(np.isfinite(l)):
+    negative = low[0, 0:n] <= mininf
+    if negative.any() or not np.all(np.isfinite(low)):
         warn('Bad entries: ' + str(negative.nonzero()[0]), PydlutilsUserWarning)
-        return (negative.nonzero()[0], l)
+        return (negative.nonzero()[0], low)
     try:
-        lower = cholesky_banded(l[:, 0:n], lower=True)
+        lower = cholesky_banded(low[:, 0:n], lower=True)
     except LinAlgError:
         #
         # Figure out where the error is.
         #
-        lower = l.copy()
+        lower = low.copy()
         kn = bw - 1
         spot = np.arange(kn, dtype='i4') + 1
         for j in range(n):
@@ -500,11 +500,11 @@ def cholesky_band(l, mininf=0.0):
             x = lower[spot, j]
             if not np.all(np.isfinite(x)):
                 warn('NaN found in cholesky_band.', PydlutilsUserWarning)
-                return (j, l)
+                return (j, low)
     #
     # Restore padding.
     #
-    L = np.zeros(l.shape, dtype=l.dtype)
+    L = np.zeros(low.shape, dtype=low.dtype)
     L[:, 0:n] = lower
     return (-1, L)
 

pydl/pydlutils/mangle.py

@@ -677,7 +677,7 @@ def read_mangle_polygons(filename):
     with open(filename, 'r') as ply:
         # lines = ply.read().split(ply.newlines)
         lines = ply.readlines()
-    lines = [l.strip() for l in lines]
+    lines = [ln.strip() for ln in lines]
     try:
         _ = int(lines[0].strip().split()[0])
     except ValueError:

pydl/pydlutils/misc.py

@@ -374,7 +374,7 @@ def struct_print(array, filename=None, formatcodes=None, alias=None,
     rowformat = (colstart + colsep.join([formatcodes[tag]
                                          for tag in array.dtype.names]) + colend)
     for k in range(array.size):
-        lines.append(rowformat.format(*([decode_mixed(l) for l in array[k].tolist()])))
+        lines.append(rowformat.format(*([decode_mixed(ll) for ll in array[k].tolist()])))
     if html:
         lines.append('</table>')
     f = None   # This variable will store a file handle

pydl/pydlutils/sdss.py

@@ -170,21 +170,21 @@ def sdss_flagexist(flagname, bitname, flagexist=False, whichexist=False):
         bitnames = [bitname.upper()]
     else:
         bitnames = [b.upper() for b in bitname]
-    f = False
-    l = False
+    flexist = False
+    allexist = False
     which = [False] * len(bitnames)
     if flagname.upper() in maskbits:
-        f = True
+        flexist = True
         which = [n in maskbits[flagname.upper()] for n in bitnames]
-        l = sum(which) == len(which)
+        allexist = sum(which) == len(which)
     if flagexist and whichexist:
-        return (l, f, which)
+        return (allexist, flexist, which)
     elif flagexist:
-        return (l, f)
+        return (allexist, flexist)
     elif whichexist:
-        return (l, which)
+        return (allexist, which)
     else:
-        return l
+        return allexist
 
 
 def sdss_flagname(flagname, flagvalue, concat=False):

pydl/pydlutils/spheregroup.py

@@ -291,29 +291,29 @@ def friendsoffriends(self, ra, dec, linkSep):
                     chunkGroup = self.chunkfriendsoffriends(ra, dec, self.chunkList[i][j], linkSep)
                     for k in range(chunkGroup.nGroups):
                         minEarly = 9*nPoints
-                        l = chunkGroup.firstGroup[k]
-                        while l != -1:
-                            if inGroup[self.chunkList[i][j][l]] != -1:
-                                checkEarly = inGroup[self.chunkList[i][j][l]]
+                        ll = chunkGroup.firstGroup[k]
+                        while ll != -1:
+                            if inGroup[self.chunkList[i][j][ll]] != -1:
+                                checkEarly = inGroup[self.chunkList[i][j][ll]]
                                 while mapGroups[checkEarly] != checkEarly:
                                     checkEarly = mapGroups[checkEarly]
                                 minEarly = min(minEarly, checkEarly)
                             else:
-                                inGroup[self.chunkList[i][j][l]] = nMapGroups
-                            l = chunkGroup.nextGroup[l]
+                                inGroup[self.chunkList[i][j][ll]] = nMapGroups
+                            ll = chunkGroup.nextGroup[ll]
                         if minEarly == 9*nPoints:
                             mapGroups[nMapGroups] = nMapGroups
                         else:
                             mapGroups[nMapGroups] = minEarly
-                            l = chunkGroup.firstGroup[k]
-                            while l != -1:
-                                checkEarly = inGroup[self.chunkList[i][j][l]]
+                            ll = chunkGroup.firstGroup[k]
+                            while ll != -1:
+                                checkEarly = inGroup[self.chunkList[i][j][ll]]
                                 while mapGroups[checkEarly] != checkEarly:
                                     tmpEarly = mapGroups[checkEarly]
                                     mapGroups[checkEarly] = minEarly
                                     checkEarly = tmpEarly
                                 mapGroups[checkEarly] = minEarly
-                                l = chunkGroup.nextGroup[l]
+                                ll = chunkGroup.nextGroup[ll]
                         nMapGroups += 1
         #
         # Now all groups which are mapped to themselves are the real groups

pydl/pydlutils/tests/test_bspline.py

@@ -81,11 +81,11 @@ def test_cholesky_band():
     ab = np.array([[8., 9., 10., 11., 12., 13., 14., 0., 0., 0.],
                    [1., 2., 3., 4., 5., 6., 0., 0., 0., 0.],
                    [1., 2., 3., 4., 5., 0., 0., 0., 0., 0.]])
-    l = np.array([[2.82842712, 2.97909382, 3.07877788, 3.1382224, 3.16559183, 3.16295604, 3.12782377, 0., 0., 0.],
-                  [0.35355339, 0.62938602, 0.8371714, 1.01466666, 1.17093392, 1.31223108, 0., 0., 0., 0.],
-                  [0.35355339, 0.67134509, 0.97441261, 1.27460692, 1.57948348, 0., 0., 0., 0., 0.]])
+    low = np.array([[2.82842712, 2.97909382, 3.07877788, 3.1382224, 3.16559183, 3.16295604, 3.12782377, 0., 0., 0.],
+                    [0.35355339, 0.62938602, 0.8371714, 1.01466666, 1.17093392, 1.31223108, 0., 0., 0., 0.],
+                    [0.35355339, 0.67134509, 0.97441261, 1.27460692, 1.57948348, 0., 0., 0., 0., 0.]])
     i, ll = cholesky_band(ab)
-    assert np.allclose(l, ll)
+    assert np.allclose(low, ll)
     ab[0, 0] = 1.0e-6
     with pytest.warns(PydlutilsUserWarning) as w:
         i, ll = cholesky_band(ab, mininf=1.0e-5)
@@ -99,10 +99,10 @@ def test_cholesky_band():
 
 
 def test_cholesky_solve():
-    l = np.array([[2.82842712, 2.97909382, 3.07877788, 3.1382224, 3.16559183, 3.16295604, 3.12782377, 0., 0., 0.],
+    a = np.array([[2.82842712, 2.97909382, 3.07877788, 3.1382224, 3.16559183, 3.16295604, 3.12782377, 0., 0., 0.],
                   [0.35355339, 0.62938602, 0.8371714, 1.01466666, 1.17093392, 1.31223108, 0., 0., 0., 0.],
                   [0.35355339, 0.67134509, 0.97441261, 1.27460692, 1.57948348, 0., 0., 0., 0., 0.]])
-    b = np.ones((10,), dtype=l.dtype)
+    bb = np.ones((10,), dtype=a.dtype)
     xx = np.array([0.10848432, 0.07752049, 0.05460496, 0.04231068, 0.02116434, 0.03276732, 0.04982674, 0., 0., 0.])
-    x = cholesky_solve(l, b)
+    x = cholesky_solve(a, bb)
     assert np.allclose(x, xx)